0726swing、lambda、socket通讯

Swing （c/s窗口应用）

JFrame f = new JFrame();
	f.setSize(600, 500);
	f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	//f.setLocation(200, 200);
	f.setLocationRelativeTo(null);
    //f.setLayout(manager);//设置布局
	//f.add(comp);//放入控件
	//f.setJMenuBar(menubar);//放入菜单
   	f.setVisible(true);



	public class MyFrame extends JFrame{
	public MyFrame() {
		setSize(600, 500);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setLocationRelativeTo(null);
		setVisible(true);
	}
}

控件：可视部件全部以大写字母J打头
控件全部继承自Jcomponent（可视区域）
不使用布局管理器：

setLayout(null);//布局管理器 默认borderlayout
JButton bt = new JButton("江湖if哦我IE");
bt.setSize(100,50);//setPreferredSize(preferredSize); 布局管理器使用
add(bt);

控件事件：（add打头 listener结尾的方法，事件监听器）

bt.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			System.out.println("fewf");
		}
	})；

lambda 1.8java 新特性

lambda是函数式接口实现的便捷方法（替代函数式接口的内部匿名类）

interface1 a = ()->{System.out.println("aaa");};//lambda
interface1 b = new interface1() {
	public void add() {
		System.out.println("实现1");
	}
};

函数式接口（只有一个抽象方法）

@FunctionalInterface
public interface interface1 {
	public int add(int a,int b);
}

list.forEach((a)->{
			System.out.println(a);
		});

lambda核心：
1、只支持@FunctionalInterface 处理
2、做接口实例化的一种方式
3、返回值为接口对象 （根据接口对象的方法 ）

socket通讯（套接字——IP地址+端口号）

UDP协议（对等网，包传输，不稳定，不安全，主要用于即时数据处理和局域网处理）
邮局寄信

sock=new DatagramSocket(port);
sock.send(pack);  //发送
new Thread(this).start();
sock.receive(p);

具体代码：

UDPsend.java
public class UDPSend {
public static void main(String[] args) throws Exception {
	DatagramSocket sock = new DatagramSocket();//自身端口
	byte[] data = "你好".getBytes();
	DatagramPacket pack = new DatagramPacket(data, data.length,
	InetAddress.getByName("127.0.0.1"), 446);//目的IP 端口
	sock.send(pack);//发送
}
}

UDPreceive.java 
public class UDPReceive {
public static void main(String[] args) throws Exception{
	DatagramSocket sock = new DatagramSocket(446);//自身端口
	new Thread(()->{
		while(true) {
			DatagramPacket p = new DatagramPacket(new byte[100], 100);
			try {
				sock.receive(p);
				byte[] data = Arrays.copyOf(p.getData(), p.getLength());
				System.out.println(new String(data));
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}).start();
}
}

TCP/IP（流处理，握手协议，长连接，心跳包，安全稳定的）
话务员-服务端 电话-客户端

server.java
public class server {
   public static void main(String[] args) {
	try {
		TcpServerManager  s = new TcpServerManager(12345);
		s.addNetListenner(new TcpServerManager.NetListenner() {
			
		@Override
		public void getMsg(String ip, int port, String msg) {
		
			System.out.println("服务端接收："+msg);
		}
	});
	Scanner sc = new Scanner(System.in);
	while(true) {
		System.out.print("服务端发送：");
		String txt=sc.next();
		s.send(0,txt);
	}
	
	
} catch (Exception e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}
}
}

client.java
public class client {
    public static void main(String[] args) {

try {
	TcpClientManager c = new TcpClientManager("127.0.0.1", 12345);
	c.addNetListenner(new TcpClientManager.NetListenner() {
		
		@Override
		public void getMsg(String ip, int port, String msg) {
			System.out.println(port+"接收："+msg);
			
		}
	});
	Scanner sc = new Scanner(System.in);
	while(true) {
		System.out.print("客户端发送：");
		String txt=sc.next();
		c.send(txt);
	}
	
} catch (Exception e) {
	e.printStackTrace();
}
}
}

TcpClientManager.java
public class TcpClientManager implements Runnable {
	private int  BufferSize=2000 ;
	private boolean isrun=true ;
	private Socket sock ;
	private NetListenner listenner;
public void addNetListenner(NetListenner listenner) {
	this.listenner = listenner;
}
public TcpClientManager(String ip,int port)throws Exception {
	sock= new Socket(ip, port);//连接服务端 
	new Thread(this).start();
}
public TcpClientManager(Socket sock)throws Exception {
	this.sock=sock;
	new Thread(this).start();
}

public void send(String msg)throws Exception {
	sock.getOutputStream().write(msg.getBytes());
}

@Override
public void run() {
	while(isrun) {
		try {
			InputStream in=sock.getInputStream();
			byte[] data=new byte[BufferSize];
			int len=in.read(data);
			data=Arrays.copyOf(data, len);
			if(listenner!=null) {
				InetSocketAddress ad=(InetSocketAddress) sock.getRemoteSocketAddress();
				listenner.getMsg(ad.getAddress().getHostAddress(), ad.getPort(), new String(data));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}		
}
public void close() {
	isrun=false;
	try {
		sock.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

public interface NetListenner{
	public void getMsg(String ip,int port,String msg);
}
}
TcpServerManager.java
public class TcpServerManager implements Runnable {
	private ServerSocket server;
	private boolean isrun=true;
	private int port;
	private Vector<TcpClientManager> clientlist=new Vector<>();
	private NetListenner listenner;
	public void addNetListenner(NetListenner listenner) {
		this.listenner = listenner;
	}
	public TcpServerManager(int port)throws Exception{
		super();
		this.port = port;
		server=new ServerSocket(port);
		new Thread(this).start();
	}
	@Override
	public void run() {
		while(isrun) {
			try {
				Socket sock=server.accept();
				TcpClientManager c=new TcpClientManager(sock);
				c.addNetListenner(act);
				clientlist.add(c);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	socket.TcpClientManager.NetListenner act=new socket.TcpClientManager.NetListenner() {
		@Override
		public void getMsg(String ip, int port, String msg) {
			if(listenner!=null)
				listenner.getMsg(ip, port, msg);
		}
	};
	public void send(int index,String msg)throws Exception {
		clientlist.get(index).send(msg);
	}
public void close() {
	isrun=false;
	try {
		server.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
	for(TcpClientManager c:clientlist) c.close();
	
}

public interface NetListenner{
	public void getMsg(String ip,int port,String msg);
}
}