JavaSE Day20

目录

• 网络编程
  • 网络
  • 网络协议
  • 协议
  • IP地址
  • 域名
  • 端口
  • URL
• 数据传输
  • 网络编程的模式
• Java.net包
  • 可用的类
  • Socket类
    • 构造方法
  • 客户端与服务器端 单用户通信
    • client
    • server
  • 多客户端 与 服务器端 通信；但是客户端需要排队
    • client
    • server
  • 多客户端 与 服务器端 通信；多线程实现
    • client
    • server
  • 服务器端与客户端 对话
    • client
    • server
  • 多客户端 与 服务器 对话，多线程实现；
    • client
    • server
• 枚举类型
  • 语法：
  • 注意：
  • 查看枚举类的成员

---

网络编程

网络

一组由网线连接的计算机

网络协议

1. Internet 互联网
2. Internet 因特网
3. WWW 万维网 web
4. FTP

协议

网络中计算机之间通信的规则

常用的协议

1. IP:网际协议
2. TCP：传输控制协议
3. 超文本传输协议（HTTP）
4. 文件传输协议(FTP)
5. 简单邮件协议（SMTP）

IP地址

用来标识 网络中的一个通信实体

域名

DNS

端口

用于实现程序间的通信
端口号： 用来访问网络中的一个计算机上的某个程序

URL

统一资源定位符
protocol://hostname[:port]/path/[?query]#fragment
协议：//主机名[:端口]/路径/？查询字符串#片段

package day20;

import java.net.MalformedURLException;
import java.net.URL;

public class TestURL {
	public static void main(String[] args) {
		try {
			URL url = new URL("http://192.168.1.190:4567/data/a.txt?id=1&page=2#hello");
			// 获得协议
			System.out.println(url.getProtocol());
			System.out.println(url.getHost());
			System.out.println(url.getPort());
			System.out.println(url.getDefaultPort());
			System.out.println(url.getQuery());// 查询字符串
			System.out.println(url.getRef());//定位符
			
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

数据传输

1. java支持TCP和UDP协议族
2. TCP/ip
   较可靠的双向流协议
   发送任意数量的数据
3. UDP
   比较不可靠；

网络编程的模式

1. c/s模式：客户端 / 服务器
2. B/S模式：浏览器/ 服务器

Java.net包

java的java.net包包含了所有的用于网络操作的类

可用的类

1. Socket
2. ServerSoceket

Socket类

当客户程序需要与服务器程序通讯的时候，客户程序必须在客户端创建一个Scoket对象。

构造方法

1. Socket(InetAddress addr,int port)
2. Socket(String host，int port)

服务器端实质上就是socket与socket在通信
客户端写 -> 写给服务器
服务器写 -> 写给客户端

客户端与服务器端 单用户通信

client

package day20.socket1;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Client {
	public static void main(String[] args) {
		// 创建一个客户端
		//                           "127.0.0.1"
		//                            服务器的IP    服务器软件的端口号
		try {
			Socket client = new Socket(InetAddress.getLocalHost(),5678);
			// 聊天
			// 获得了 底层的 socket流，输入流
			InputStream is = client.getInputStream();
			OutputStream os = client.getOutputStream();
			
			// 包装
			Scanner in = new Scanner(is);// 读
			PrintWriter out = new PrintWriter(os,true);// 刷新缓冲区，必须写
			//
			String sr,sw;
			// 读
			while(true){
				
				sr = in.nextLine();
				System.out.println("服务器说："+sr);
				if(sr.equals("end")){
					break;
				}
			}
			
			
			// 写
			Scanner input = new Scanner(System.in);
			while(true){
				System.out.println("客户端说：");
				sw = input.next();// 获得键盘输入的内容
				// 写入到服务器
				out.println(sw);
				if(sw.equals("end")){
					break;
				}
			}
			
			// 关闭客户端
			client.close();
			
			
			
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

server

package day20.socket1;

import java.io.IOException;
import java.io.*;
import java.net.*;
import java.util.Scanner;

public class Server {
	public static void main(String[] args) {
		//创建服务器对象
		try {
			//                                  服务器端口号
			ServerSocket server = new ServerSocket(5678);
			// 等待的过程 就是一个阻塞的过程；
			Socket socket = server.accept();
			// 流
			InputStream is = socket.getInputStream();
			OutputStream os = socket.getOutputStream();
			// 包装
			Scanner in = new Scanner(is);
			PrintWriter out = new PrintWriter(os,true);
			
			// 写
			out.println("客户端连接服务器成功");
			out.println("end");
			// 读
			String sr;
			while (true){
				sr = in.nextLine();
				System.out.println("客户端说"+sr);
				if(sr.equals("end")){
					break;
				}
			}
			
			socket.close();
			
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

多客户端 与 服务器端 通信；但是客户端需要排队

client

package day20.socket2;

import java.io.*;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.*;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Client {
	public static void main(String[] args) {
		try {
			Socket client = new Socket(InetAddress.getLocalHost(),5679);
			
			InputStream is = client.getInputStream();
			OutputStream os = client.getOutputStream();
			
			
			Scanner in = new Scanner(is);
			PrintWriter out = new PrintWriter(os,true);
			
			// 读，读取服务器端发送的数据
			String sr,sw;
			while(true){
				sr = in.nextLine();
				System.out.println("服务器说："+sr);
				if(sr.equals("end")){
					break;
				}
			}
			
			//写， 从键盘输入后 发送给服务器端
			Scanner input = new Scanner(System.in);
			while(true){
				System.out.println("客户端说：");
				sw = input.next();// 获得键盘输入的内容
				// 写入到服务器
				out.println(sw);
				if(sw.equals("end")){
					break;
				}
			}
			
			client.close();
			
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

server

package day20.socket2;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class Server {
	public static void main(String[] args) {
		 ServerSocket server;
		try {
			server = new ServerSocket(5679);
			while(true){
				// 等待服务器来连接 等待的过程 就是一个阻塞的过程；
				Socket socket = server.accept();
				
				InputStream is = socket.getInputStream();
				OutputStream os = socket.getOutputStream();
				
				Scanner in = new Scanner(is);
				PrintWriter out = new PrintWriter(os,true);
			
				// 写
				out.println("客户端连接成功");
				out.println("end");
				
				// 读
				String str;
				while(true){
					str = in.nextLine();
					System.out.println("客户端说："+str);
					if(str.equals("end")){
						break;
					}
				}
			
				socket.close();
			
			}
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		 
		 
		 
		 
		
	}
}

多客户端 与 服务器端 通信；多线程实现

client

package day20.socket3;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

public class Client {
	public static void main(String[] args) {
		try {
			Socket client = new Socket(InetAddress.getLocalHost(),5678);

            InputStream is = client.getInputStream();
            OutputStream os = client.getOutputStream();

            Scanner in = new Scanner(is);
            PrintWriter out = new PrintWriter(os,true);


            // 读
            String sr,sw;
            while(true){
                sr = in.nextLine();
                System.out.println("服务器说："+sr);
                if(sr.equals("end")){
                    break;
                }
            }


            Scanner input = new Scanner(System.in);
            while(true){
                System.out.println("客户端说：");
                sw = input.nextLine();
                // 写入到服务器
                out.println(sw);
                if(sw.equals("end")){
                    break;
                }
            }

            client.close();


		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

server

package day20.socket3;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

class ScoketThread implements Runnable{
    Socket socket;
    ScoketThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();


            Scanner in = new Scanner(is);
            PrintWriter out = new PrintWriter(os,true);


            out.println("客户端已连接；");
            out.println("end");

            String sr;
            while (true){
                sr = in.nextLine();
                System.out.println("客户端说："+sr);
                if(sr.equals("end")){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(5678);

            while(true) {
                Socket socket = server.accept();
                ScoketThread th = new ScoketThread(socket);
                Thread t = new Thread(th);
                t.start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

服务器端与客户端 对话

client

package day20.socket4;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try {
            Socket client = new Socket(InetAddress.getLocalHost(),5679);

            InputStream is = client.getInputStream();
            OutputStream os = client.getOutputStream();

            Scanner in = new Scanner(is);
            PrintWriter out = new PrintWriter(os,true);

            // 读、写
            String sr,sw;
            Scanner input = new Scanner(System.in);

            while(true){
                sr = in.nextLine();
                System.out.println("服务器端说："+sr);

                System.out.println("客户端说：");
                sw = input.nextLine();
                out.println(sw);
                if (sw.equals("end")){
                    break;
                }
            }

            client.close();


        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

server

package day20.socket4;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;


class ServerThread implements Runnable{
    Socket socket;
    ServerThread(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();

            Scanner in = new Scanner(is);
            PrintWriter out = new PrintWriter(os,true);


            out.println("客户端连接成功");
            // 读、写
            Scanner input = new Scanner(System.in);
            String sr,sw;
            while(true){
                sr = in.nextLine();
                System.out.println("客户端说："+sr);
                if(sr.equals("end")){
                    break;
                }
                System.out.println(socket.getChannel()+"服务器端说：");
                sw = input.nextLine();
                out.println(sw);
                if(sw.equals("end")){
                    break;
                }
            }

            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(5679);


            while(true) {
                Socket socket = server.accept();
                ServerThread serverThread = new ServerThread(socket);
                Thread thread = new Thread(serverThread);
                thread.start();

            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多客户端 与 服务器 对话，多线程实现；

client

package day20.socket5;


import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;


class ClientRead implements Runnable {
    Scanner in;

    ClientRead(Scanner in) {
        this.in = in;
    }

    @Override
    public void run() {
        String sr;
        while (true) {

            sr = in.nextLine();
            System.out.println("服务器端说：" + sr);
            if(sr.equals("end")){
                break;
            }

        }
    }
}

class ClientWrite implements Runnable {
    PrintWriter out;
    Socket client;

    ClientWrite(PrintWriter out,Socket client) {
        this.out = out;
        this.client = client;
    }

    @Override
    public void run() {
        String sw;
        Scanner input = new Scanner(System.in);
        while (true) {

                System.out.println("客户端说：");
                sw = input.nextLine();
                if (sw == null){
                    continue;
                }
                out.println(sw);
                if (sw.equals("end")) {
                    break;
                }
        }
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Client {
    public static void main(String[] args) {
        try {
            Socket client = new Socket(InetAddress.getLocalHost(), 5679);

            InputStream is = client.getInputStream();
            OutputStream os = client.getOutputStream();

            Scanner in = new Scanner(is);
            PrintWriter out = new PrintWriter(os, true);

            // 读、写
            String sr, sw;
            Scanner input = new Scanner(System.in);


            ClientRead clientRead = new ClientRead(in);
            Thread th1 = new Thread(clientRead);
            th1.start();
            th1.setPriority(Thread.MAX_PRIORITY);

            ClientWrite clientWrite = new ClientWrite(out,client);
            Thread th2 = new Thread(clientWrite);
            th2.start();
            th2.setPriority(Thread.MIN_PRIORITY);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

server

package day20.socket5;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;


class ServerRead implements Runnable {
    Scanner in;

    ServerRead(Scanner in) {
        this.in = in;
    }

    @Override
    public void run() {
        String sr;
        while (true) {

            sr = in.nextLine();
            System.out.println("客户端说：" + sr);
            if (sr.equals("end")) {
                break;
            }

        }
    }
}

class ServerWrite implements Runnable {
    PrintWriter out;
    Socket client;

    ServerWrite(PrintWriter out, Socket client) {
        this.out = out;
        this.client = client;
    }

    @Override
    public void run() {
        String sw;
        Scanner input = new Scanner(System.in);
        while (true) {

            System.out.println("服务器端说：");
            sw = input.nextLine();
            if(sw == null){
                continue;
            }
            out.println(sw);
            if (sw.equals("end")) {
                break;
            }

        }
    }
}

class ServerThread implements Runnable {
    Socket socket;

    ServerThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();

            Scanner in = new Scanner(is);
            PrintWriter out = new PrintWriter(os, true);


            out.println("客户端连接成功");
            // 读、写
            ServerRead serverRead = new ServerRead(in);
            Thread th1 = new Thread(serverRead);
            th1.start();

            ServerWrite serverWrite = new ServerWrite(out, socket);
            Thread th2 = new Thread(serverWrite);
            th2.start();

            th1.setPriority(Thread.MAX_PRIORITY);
            th2.setPriority(Thread.MIN_PRIORITY);

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(5679);


            while (true) {
                Socket socket = server.accept();
                ServerThread serverThread = new ServerThread(socket);
                Thread thread = new Thread(serverThread);
                thread.start();

            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

枚举类型

枚举类就是 固定的常量值；
枚举 是一种数据类型

语法：

Enum Color{
	枚举成员(对象)；
	成员变量；
	方法；
	构造；private
	抽象方法； abstract
	重写方法；
	实现其他接口中的方法；
}

注意：

1. 枚举类型底层 是一个类，隐式的继承了java.lang.Enum类，不能再继承其他的类了；
2. 枚举类的对象是固定的；必须在声明枚举类的第一行代码处列举出来；
3. 所有的枚举对象都是public static final的；
4. 枚举类的构造器都是私有的private；
5. 对于一个非抽象的枚举类都是final的
6. 一个枚举类中定义了abstract抽象方法，并且所有对象都实现了这个抽象方法，那么这个枚举类就成了abstract抽象枚举类了

package day20;

import java.util.Scanner;

/*// 原始方法
class Color{
	public static final int RED = 1;
	public static final int GREEN = 2;
	public static final int BLUE = 3;
	
}*/

interface Info{
	void f();
}

enum Color implements Info{
	// 这是枚举类的三个对象；
	// 一定要在枚举类的第一行代码处列举出来；
	// 
	RED(1,"红色") {
		@Override
		public void af() {
			// TODO Auto-generated method stub
			System.out.println("red_af");
		}
		public void f(){
			System.out.println("a");
		}
	},GREEN(2,"绿色") {
		@Override
		public void af() {
			// TODO Auto-generated method stub
			System.out.println("green_af");
		}

		@Override
		public void f() {
			// TODO Auto-generated method stub
			System.out.println("b");
		}
	},BLUE(3,"蓝色") {
		@Override
		public void af() {
			// TODO Auto-generated method stub
			System.out.println("blue_af");
		}

		@Override
		public void f() {
			// TODO Auto-generated method stub
			System.out.println("c");
		}
	};
	
	// 对象的成员变量
	private int no;
	private String name;
	
	Color(){}// 默认是private的
	private Color(int no,String name){
		this.no = no;
		this.name = name;
	}
	
	
	
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	// 对象的普通方法
	public void show(){
		System.out.println("show");
	}
	
	// 重写的是Enum类中的方法
	@Override
	public String toString(){
		return this.no+","+this.name;
		
	}
	
	// 抽象方法
	public abstract void af();
}
public class TestColor {
	public static void main(String[] args) {
		/*// 意义不明确
		System.out.println(Color.RED);
		// 类型不安全
		int n = Color.RED + 45;
		System.out.println(n);*/
		
		// 实现抽象方法
		Color.RED.af();
		Color.GREEN.af();
		Color.BLUE.af();
		
		// 重写toString
		System.out.println(Color.RED);
		
		Color.RED.show();
		
		//--------------------------
		/*System.out.println(Color.RED.getNo());
		System.out.println(Color.GREEN.getNo());
		System.out.println(Color.BLUE.getNo());
		System.out.println(Color.RED.getName());
		System.out.println(Color.GREEN.getName());
		System.out.println(Color.BLUE.getName());*/
		
		
		//-------------------------------
		/*for(Color c:Color.values()){
			System.out.println(c);
			System.out.println(c.ordinal());
		}*/
		/*//-----------switch--------------
		Scanner input = new Scanner(System.in);
		System.out.println("--输入一个颜色：");
		String str = input.next();
		// 将str转换成Color类型
		Color color = Color.valueOf(str);
		switch(color){
		case RED:
			System.out.println("是红色");
			break;
		case GREEN:
			System.out.println("是绿色");
			break;
		case BLUE:
			System.out.println("是蓝色");
			break;
			
			
		}*/	
	}
}

查看枚举类的成员

通过反编译来查看枚举类的成员

Javap day20.Color 反编译
定义抽象方法之后
λ cjavap -private day20.Color
Compiled from "TestColor.java"
abstract class day20.Color extends java.lang.Enum<day20.Color> {
public static final day20.Color RED;
public static final day20.Color GREEN;
public static final day20.Color BLUE;
private int no;
private java.lang.String name;
private static final day20.Color[] ENUM$VALUES;
static {};
private day20.Color(java.lang.String, int);
private day20.Color(java.lang.String, int, int, java.lang.String);
public int getNo();
public void setNo(int);
public java.lang.String getName();
public void setName(java.lang.String);
public void show();
public java.lang.String toString();
public abstract void af();
public static day20.Color[] values();
public static day20.Color valueOf(java.lang.String);
day20.Color(java.lang.String, int, int, java.lang.String, day20.Color);

	}