2021-11-10 迈向程序猿的第二十五步

目录

一.网络编程案例

1.1 注册功能

1.2 聊天室程序

二. 反射

2.1 反射概述

 2.2 反射常用方法

2.3 反射操作属性

2.4 反射操作方法

2.5 反射应用场景

---

一.网络编程案例

1.1 注册功能

//案例：注册功能
//分析：
//1.客户端与服务器建立连接
//2.客户端准备好注册数据，拼成一个字符串；例如:{id:"1001",name:"zs",age:30}
//3.发送注册数据，服务器接收数据
//4.服务器拆分数据，取出id对应的value作为key，接收的注册信息作为value
//5.判断key在配置文件中是否存在，如果存在，则返回"已存在"
//6.不存在，把这些数据存到配置文件，并返回“注册成功”
-----服务器------
public class Server {
	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(9527);
		Socket socket = ss.accept();
		InputStream is = socket.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		String msg = br.readLine(); //{id:1001,name:zs,age:30}
		String strId = msg.split(",")[0];  //{id:1001
		String id = strId.split(":")[1];   //1001
		
		//通过Properties集合去加载配置文件
		Properties p = new Properties();
		p.load(new FileInputStream("user.properties"));
		
		OutputStream os = socket.getOutputStream();
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
		if(p.containsKey(id)) {
			bw.write("已存在");
			
		}else {
			Tool.saveProperties(id,msg);  //将数据存储到配置文件
			bw.write("注册成功");
		}
		bw.newLine();
		bw.flush();
		
		IOUtils.closeAll(bw,os,br,is,socket);
		
	}
}



-----客户端------
public class Client {
	public static void main(String[] args) throws IOException {
		Socket socket = new Socket("127.0.0.1",9527);
		OutputStream os = socket.getOutputStream();
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
		
		String json = getData(); //{id:1001,name:zs,age:30}
		//发数据
		bw.write(json);
		bw.newLine();
		bw.flush();
		
		InputStream is = socket.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(is));
		String msg = br.readLine();
		System.out.println("服务器响应:"+msg);
		
		IOUtils.closeAll(is,br,os,bw,socket);
	}

	private static String getData() {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入ID：");
		String id = sc.next();
		System.out.println("请输入用户名：");
		String name = sc.next();
		System.out.println("请输入年龄：");
		int age = sc.nextInt();
		return "{id:"+id+",name:"+name+",age:"+age+"}";
	}
}


----工具类----
public class Tool {
	public static void saveProperties(String id, String msg) throws FileNotFoundException, IOException {
		Properties properties = new Properties();
		properties.put(id, msg);
		properties.store(new FileOutputStream("user.properties"), "");
	}
}

1.2 聊天室程序

//案例：聊天室程序
//分析： 多人聊天---多线程
//1.通过多线程形式接收多个客户端的连接
//2.客户端要录入姓名，传入服务器接收，并存储到线程中
//（注意：客户端的发送和接收要分为两个线程，才能方便群发）
//3.服务器给客户端回应“欢迎进入聊天室”
//4.该客户端就可以实时发数据聊天了
//5.要实现服务器群发信息给客户端，需要先将所有线程对象存储
//6.退出方式，客户端退出，其他用户应该都知道
 

-------服务器-------
public class Server {
	public static List<ServerThread> list = new ArrayList<ServerThread>();
	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(9527);
		//多线程方式监听及创建socket
		while(true) {
			Socket socket = ss.accept();
			System.out.println("有一个客户端进来了");
			ServerThread st = new ServerThread(socket);
			st.start();
			list.add(st);  //存储线程对象
		}
	}
}


------服务器线程-------
public class ServerThread extends Thread {
	private Socket socket;
	
	private BufferedReader br;
	private BufferedWriter bw;
	
	public ServerThread(Socket socket) throws IOException {
		this.socket = socket;
		br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
	}
	
	@Override
	public void run() {
	
		try {
			sendHello();  //欢迎
			
			while(true){
				String name = this.br.readLine(); //读取到数据后，发给自身
				String msg = this.getName()+"说:"+name;
				//循环遍历线程对象，除了自己，都发一份出去
				for(ServerThread st : Server.list) {
					if(st!=this) {
						st.bw.write(msg);
						st.bw.newLine();
						st.bw.flush();
					}
				}
			}
		} catch (Exception e) {
			String msg = this.getName()+"退出了聊天室";  //群发退出信息
			Server.list.remove(this);  //将当前线程对象在集合中移除
			
			for(ServerThread st : Server.list) { //移除后群发
				try {
					st.bw.write(msg);
					st.bw.newLine();
					st.bw.flush();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
			
		}finally {
			IOUtils.closeAll(bw,br,socket);
		}
	}

	private void sendHello() throws IOException {
		String name = br.readLine(); //读取到数据后，发给自身
		String msg = "【温馨提示】:欢迎"+name+"进入聊天室";
		this.setName(name);  //记录客户的访问
		bw.write(msg);
		bw.newLine();
		bw.flush();
	}
}


------客户端-------
public class Client {
	public static void main(String[] args) throws IOException {
		Socket socket = new Socket("127.0.0.1",9527);
		
		//客户端读写分离
		new WriteClient(socket).start();
		
		new ReadClient(socket).start();

	}
}



-------客户端写线程-------
public class WriteClient extends Thread {
	private Socket socket;
	
	public WriteClient(Socket socket) {
		this.socket = socket;
	}
	
	@Override
	public void run() {
		OutputStream os = null;
		BufferedWriter bw = null;
		try {
			os = socket.getOutputStream();
			bw = new BufferedWriter(new OutputStreamWriter(os));
			System.out.println("请输入用户名:");
			Scanner sc = new Scanner(System.in);
			
			while(true) {
				String name = sc.next(); //第一次是输入名字，后面就是聊天内容
				bw.write(name);
				bw.newLine();
				bw.flush();
			}
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			IOUtils.closeAll(os,bw,socket);
		}
		
	}
}



-------客户端读线程--------
public class ReadClient extends Thread {
	private Socket socket;
	
	public ReadClient(Socket socket) {
		this.socket = socket;
	}
	
	@Override
	public void run() {
		InputStream is = null;
		BufferedReader br = null;
		try {
			is = socket.getInputStream();
			br = new BufferedReader(new InputStreamReader(is));
			while(true) {
				String msg = br.readLine();
				System.out.println(msg);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			IOUtils.closeAll(is,br,socket);
		}
		
	}
}

二. 反射

2.1 反射概述

/**
 *概述：反射对象，就是类对象，是类加载的产物，
     只要有了类对象，就可以知道类的所有信息（类名，接口，包名，属性，方法等）

	获取类对象方式：
	1.类名.class  (常用)  
	2.对象.getClass()   
	3.Clas.forname("包名.类名")  （常用）
	
	结论：无论哪种方式获取的类对象，都是同一个
 *
 */

class Person{
	private String name;
	private int    age;
	

	
	public Person() {
		System.out.println("调无参构造");
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}


	public void test() {
		System.out.println("test");
	}
	
	
}
public class Test1 {
	public static void main(String[] args) throws ClassNotFoundException {
		Class class1 = Person.class;
		Class class2 = new Person().getClass();
		Class class3 = Class.forName("com.qf.d_reflect.Person");
		
		System.out.println(class1==class2); //true
		System.out.println(class1==class3); //true
	}
}

 2.2 反射常用方法

public class Test2 {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException {
		Class clazz1 = Person.class;  //获取反射对象
		
		System.out.println(clazz1.getName()); //获取类名
		System.out.println(clazz1.getPackage());  //获取包名
		System.out.println(clazz1.getSuperclass()); //获取父类
		System.out.println(Arrays.toString(clazz1.getInterfaces())); //获取接口
		System.out.println(Arrays.toString(clazz1.getFields())); //性能高，不能处理私有权限属性
		System.out.println(Arrays.toString(clazz1.getDeclaredFields())); //（常用）可以处理私有权限
		System.out.println(Arrays.toString(clazz1.getMethods()));//（常用）
		System.out.println(Arrays.toString(clazz1.getConstructors())); //获取所有构造器
		System.out.println(clazz1.getDeclaredField("name"));  //(常用) 获取Field对象
		System.out.println(clazz1.getMethod("test"));  //(常用) 获取Method对象 
		System.out.println(clazz1.newInstance()); //调无参构造 (常用)
	}
}

2.3 反射操作属性

//通过反射对象，给私有属性赋值及取值
//分析：
//1.获取反射对象
//2.获取Field对象
//3.调用set方法赋值 ，通过get方法取值
class Student{
	private String name;
	private int    age;
	
	public String getName() {
		return name;
	}
	
	public void hello(String name,int age) {
		System.out.println("反射的方法调用--"+name+"--"+age);
	}
}
public class Test1 {
	public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {
		Class clazz = Student.class;
		Field field = clazz.getDeclaredField("name");
		field.setAccessible(true);  //开启私有权限
		Student st = (Student) clazz.newInstance();
		field.set(st, "zsf");
		
		System.out.println(field.get(st));
		System.out.println(st.getName());  //验证value值是否存储到name属性
		
	}
}

2.4 反射操作方法

//案例2：通过反射对象调用方法
//1.获取反射对象
//2.通过反射获取Method对象，传方法名和反射类型
//3.通过Method对象调invoke方法

//反射作用：可以灵活动态操作属性和方法
public class Test2 {
	public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
		Class<Student> class1 = Student.class;
		//获取Method对象，参数1:方法名    后面参数：参数类型反射对象
		Method method = class1.getMethod("hello", String.class,int.class);
		method.invoke(class1.newInstance(), "谭小虎",28);
	}
}

2.5 反射应用场景

//案例3：通过反射对象灵活的获取老师和学生的对象
class Teacher{
}
public class Test3 {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException {
		//常规获取对象方式：
		//弊端： 每次获取对象时，都创建了不同的方法
		Teacher teacher = Tool.getTeacher();
		Student student = Tool.getStudent();
		
		//使用反射灵活获取对象
		Teacher t1 = Tool.getObject(Teacher.class);
		Student s1 = Tool.getObject(Student.class);
		System.out.println(t1+"---"+s1);
		
	}
}

----工具类调用-----
public class Tool {
	public static Teacher getTeacher() {
		return new Teacher();
	}

	public static Student getStudent() {
		return new Student();
	}

	//泛型方法
	public static <T> T getObject(Class<T> class1) throws InstantiationException, IllegalAccessException {
		return class1.newInstance();
	}
}

(rua~小白通往程序猿的第一道门槛即将迈过去,下周开始应该就开始和虚拟机斗智斗勇了!冲冲冲!!!)