实训笔记6.21

实训笔记6.21

  • 6.21
    • 一、座右铭
    • 二、知识回顾
      • 2.1 JavaIO流
        • 2.1.1 从三个角度分为六类
        • 2.1.2 IO流的四大抽象基类
        • 2.1.3 IO流的常用类
          • 2.1.3.1 节点流
            • 2.1.3.1.1 数组流:
            • 2.1.3.1.2 文件流:
          • 2.1.3.2 功能流
            • 2.1.3.2.1 缓冲流:
            • 2.1.3.2.2 转换流:
            • 2.1.3.2.3 对象流:
            • 2.1.3.2.4 打印流:
            • 2.1.3.2.5 标准输入和标准输出流:
      • 2.2 Java注解
      • 2.3 注解的应用--Lombok
    • 三、Java反射(reflect)机制
      • 3.1 反射的作用主要有两个:
      • 3.2 反射的核心机制--Class类
      • 3.3 反射
        • 3.3.1 获取该类的Class实例对象:
        • 3.3.2 反射的作用一
        • 3.3.2 反射的作用二

6.21

一、座右铭

我的故事你说,我的文字我落,我值几两你定,我去何方我挑。

二、知识回顾

2.1 JavaIO流

2.1.1 从三个角度分为六类

  1. 输入流和输出流
  2. 字节流和字符流
  3. 节点流和功能流

2.1.2 IO流的四大抽象基类

四大抽象基类
InputStream
OutputStream
Reader
Writer

InputStream、OutputStream:

所有格式的数据

Reader、Writer:

因为涉及到字符编码的转换,因此只能处理纯文本类型的数据。

2.1.3 IO流的常用类

2.1.3.1 节点流
2.1.3.1.1 数组流:
  1. ByteArrayInputStream
  2. ByteArrayOutputStream
  3. CharArrayReader
  4. CharArrayWriter
2.1.3.1.2 文件流:
  1. FileInputStream
  2. FileOutputStream
  3. FileWriter
  4. FileReader
  5. File文件对象类
2.1.3.2 功能流
2.1.3.2.1 缓冲流:
  1. BufferedInputStream
  2. BufferedOutputStream
  3. BufferedReader
  4. BufferedWriter
2.1.3.2.2 转换流:
  1. InputStreamReader
  2. OutputStreamWriter
2.1.3.2.3 对象流:
  1. ObjectInputStream

  2. ObjectOutputStream

  3. 序列化和反序列化

  4. 两个让Java类具备序列化和反序列化能力的接口

    1. Serializable:static、transient

    2. Externalizable:两个重写方法自己指定哪些需要序列化

      主要就是指定Java中哪些属性值可以被序列化,哪些不能被序列化

    3. 任何一个可以被序列化的类都具备一个序列化版本ID

2.1.3.2.4 打印流:
  1. PrintStream
  2. PrintWriter
2.1.3.2.5 标准输入和标准输出流:
  1. System.in
  2. System.out

2.2 Java注解

注解是给Java程序进行解释说明或者是在Java的编译期间、运行期间提供一些特殊的“服务”

注解的声明

@元注解 访问控制修饰符 @interface 注解名{ 属性类型 属性名() default 默认值; }

元注解–四个

注解名称
@Target
@Retention
@Documented
@Inherited

2.3 注解的应用–Lombok

帮助我们基于注解快速生成一个JavaBean类,借助几个SOURCE声明周期的注解,在Java编译时期将JavaBean有关的内容给我们生成到.class文件当中

注解名称 包含注解
@Data @ToString @Getter @Setter @EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
@Builder

三、Java反射(reflect)机制

反射是在Java运行期间,可以获取类中任何一块组成,以及可以调用或者运行类中任何一块内容

3.1 反射的作用主要有两个:

  1. 运行期间获取类中的任何一种成分:注解、方法、属性、构造器等等
  2. 不用自己手动构建该类对象,也可以调用执行这个类中所有的内容

3.2 反射的核心机制–Class类

Class类是Java中所有类的类。Java中所有的类。都是Class类的一个实例对象

在Java当中,任何一个类一旦加载到JVM内存当中,那么我们就会把这个类创建称为Class类的一个实例对象,然后使用这个类的时候,JVM会通过Class的实例对象去看在这个类当中有没有我们调用的属性和方法。

通过Class类就可以获取任何一个类当中声明的任何一种成分,同时还可以调用这些成

3.3 反射

反射第一步:获取该类的运行时类对象–获取该类的Class实例对象

任何一个类的Class实例对象,我们自己是无法创建的,他们都是在JVM内存加载的时候,由JVM内存自动创建的,在内存中仅且只有一份。因此我们只能获取,不能创建

3.3.1 获取该类的Class实例对象:

  1. 对象名.getClass():Class
  2. 类名.class:Class
  3. Class.forName(“全限定类名”):Class

同一个Class实例

代码示例:

		ArrayList<String> list = new ArrayList<>();
		//1、通过某个类的对象名.getClass()方法可以获取该类的class实列对象
		Class < ? extends ArrayList >  class1 = list.getClass();
		//2、通过类名.class去获取该类的运行时类
		Class<ArrayList> class2 = ArrayList. class;
		//3、通过Class.forName(全限定类名)
		Class<?> class3 = Class.forName("java.util.ArrayList");
		System.out.println(class1==class2);//true
		System.out.println(class2==class3);//true

3.3.2 反射的作用一

反射的作用一:通过Class类获取类中的任何一个成分

  1. 获取类中的属性
  2. 获取类中的方法
  3. 获取类中的构造器
  4. 获取类上声明的注解

代码示例

Class<Student> cls = Student.class;
		Field field = cls.getField("phone");
		System.out.println(field.getModifiers());//1
		System.out.println(field.getName());//phone
		System.out.println(field.getType());//class java.lang.String
		
		Field[] fields = cls.getFields();
		
		Field field2 = cls.getDeclaredField("name");
		System.out.println(field2);//private java.lang.String com.sxuek.study.Student.name
		
		Field[] declaredFields = cls.getDeclaredFields();
		for(Field f : declaredFields) {
			System.out.println(f);
			//private java.lang.String com.sxuek.study.Student.name
			//protected java.lang.Integer com.sxuek.study.Student.age
			//java.lang.String com.sxuek.study.Student.sex
			//public java.lang.String com.sxuek.study.Student.phone
		}
Class<Student> cls = Student.class;
		Method[] methods = cls.getDeclaredMethods();
		for(Method method:methods) {
			System.out.println(method.getModifiers());//2
			System.out.println(method.getName());//run
			System.out.println(method.getReturnType());//void
			Parameter[] parameters = method.getParameters();
			for(Parameter p : parameters) {
				System.out.println(p.getType());//4  int  0 void  class java.lang.String  1  int  int  int
				System.out.println(p.getName());//sum call   arg0  diff  arg0  arg1
			}
		}
		
		Constructor<Student> constructor = cls.getConstructor(String.class,Integer.class);

3.3.2 反射的作用二

反射的作用二:通过反射调用类中的成分

  1. 通过反射获取的构造器创建该类的对象
  2. 通过反射获得的属性去设置或者获取属性的值
  3. 通过反射获得的方法去调用方法执行
  4. 通过反射只能获取RUNTIME周期的注解

代码示例:

Class<Student> clz = Student.class;
		Constructor<Student> constructor = clz.getDeclaredConstructor(String.class,Integer.class);
		constructor.setAccessible(true);
		/**
		 * 可以根据获取的构造器创建这个类的对象
		 */
		Student student = constructor.newInstance("zs",20);
		System.out.println(student);//Student [name=zs, age=20, sex=null, phone=null]
		
		Field field = clz.getDeclaredField("name");
		field.setAccessible(true);
		Object object = field.get(student);
		System.out.println(object);//zs
		
		field.set(student,"ls");
		System.out.println(student.getName());//ls
		
		Method method = clz.getDeclaredMethod("diff",int.class,int.class);
		method.setAccessible(true);
		Object value = method.invoke(student, 2,1);
		System.out.println(value);//1
package com.sxuek.study.reflectdemo;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class ObjectGen {
	public static void main(String[] args) {
		Teacher teacher = genObject(Teacher.class);
		System.out.println(teacher);//null
		
		Book book = genObject(Book.class);
		System.out.println(book);//Book(bookName=流浪地球, author=刘慈欣, publisher=淘票票, price=39)
	}
	
	
	public static <T> T genObject(Class<T> cls) {
		//1、获取这个类上声明的注解值--
		MyAnno annotation = cls.getDeclaredAnnotation(MyAnno.class);
		//文件的路径
		String value = annotation.value();
		
		//2、根据IO流读取文件数据获取配置项的值
		Map<String, Object> map = new HashMap<>();
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(value));
			String line = null;
			while((line = br.readLine()) != null) {
				String[] array = line.split("=");
				map.put(array[0], array[1]);
			}
			//3、根据反射获取类中构造器,构建对象
//			T newInstance = cls.newInstance();//调用的是无参构造器 无参构造器必须存在,而且必须是public
			Constructor<T> constructor = cls.getDeclaredConstructor();
			constructor.setAccessible(true);
			T t = constructor.newInstance();
			//4、根据反射去获取类中的属性,然后结合构建的对象以及读取的文件中的数据给对应的属性赋值
			Field[] fields = cls.getDeclaredFields();
			for(Field f : fields) {
				//5、属性赋值时 读取属性上的注解值,然后根据属性的注解值去配置文件获取对应的值给属性赋值
				MyAnno anno = f.getDeclaredAnnotation(MyAnno.class);
				String value2 = anno.value();
				f.setAccessible(true);
				f.set(t, map.get(value2));
			}
			return t;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(br != null) {
				try {
					br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		return null;
	}
}

你可能感兴趣的:(实训,笔记,java)