java014学习记录

反射

难点重点

企业级框架底层都会涉及到反射技术

Spring IoC 自动创建对象需要用到反射

MyBatis 根据数据库自动创建对应对象需要用到反射

反射：通过对象可以获取到类的结构

程序运行期间动态获取到类的结构

程序通过反射机制可以动态获取类的结构，获取到类结构之后如何表示呢？

Java 是面向对象的编程语言，万物皆对象

使用对象来表示某个类的结构

怎么创建这个对象？

Class 类来创建这个特殊的对象

Class 是 Java 专门提供的一个用来表示其他类结构的类，Class 的每一个实例化对象都是用来表示某个类结构的

获取 User 类的结构，创建一个 Class 对象来表示它

获取 Account 类的结构，创建一个 Class 对象来表示它

创建 Class 对象有 3 种方式

每个类在内存中只有一份，运行程序的时候，会先把类加载到内存中，并且每个类只需要加载一次，对应的 Class 也只有一份，Class 对象只有一个，无论通过哪种方式获取到的 Class 对象，都是同一个

Class clazz1 = Class.forName("test.User");
//类字面量
Class clazz2 = User.class;
User user = new User();
Class clazz3 = user.getClass();

通过 Class 对象可以获取到类的结构，类中的各种信息，方法、属性、构造器

获取类中属性

Class 用来描述类

Field 用来描述类中的属性，每一个 Field 对象对应类中的一个属性

getFields() 只能获取类中的公有属性 public 修饰的，包括从父类继承过来的属性，只能获取 public 修饰的属性，非 public 修饰的属性无法获取

getDeclaredFields() 可以获取类中全部的属性，无论 public 还是 private，但是只能获取类自己定义的属性，而无法获取从父类继承来的属性

import test.User;

import java.lang.reflect.Field;

public class Test {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("test.User");
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                System.out.println(field);
            }
            Field id = clazz.getDeclaredField("id");
            System.out.println(id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Method 用来描述类中的方法，每一个 Method 对象都对应类中的一个方法

getMethods 可以获取类中的所有方法，包括从父类继承来的方法，只能获取 public 修饰的方法，非 public 修饰的方法无法获取

getDeclaredMethods 可以获取类中所有的方法，无论 public 还是 private，但是只能获取类自己定义的方法，而无法获取从父类继承来的方法

import test.User;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("test.User");
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println(method);
            }
            Method test = clazz.getDeclaredMethod("test3");
            System.out.println(test);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

获取构造器

Constructor 类专门用来描述构造器，每一个 Constructor 对象都对应一个类的构造器

import test.User;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("test.User");
            Constructor[] constructors = clazz.getConstructors();
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }
            System.out.println(clazz.getConstructor(String.class));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import test.User;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("test.User");
            System.out.println(clazz.getName());
            System.out.println(clazz.getPackage());
            System.out.println(clazz.getSuperclass());
            System.out.println("***********************");
            Class[] interfaces = clazz.getInterfaces();
            for (Class anInterface : interfaces) {
                System.out.println(anInterface);
            }
            ClassLoader classLoader = clazz.getClassLoader();
            System.out.println(classLoader);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

反射的应用

程序运行过程中通过反射机制来动态创建对象

无论扩展、修改类名，代码都可以实现复用

1、通过类名动态获取类 Class

2、获取构造器，调用构造器创建对象

3、获取方法，给属性赋值

import java.lang.reflect.Constructor;

public class Test {
    public static void main(String[] args) {
        createObj("Teacher");
    }

    public static void createObj(String name){
        //获取类Class
        try {
            Class<?> aClass = Class.forName(name);
            //获取构造器
            Constructor<?> constructor = aClass.getConstructor(null);
            //创建对象
            Object instance = constructor.newInstance(null);
            System.out.println(instance);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Test {
    public static void main(String[] args) {
        createObj("User",1,"张三",22);
    }

    public static void createObj(String name,Integer id,String name2,Integer age){
        //获取类Class
        try {
            Class<?> aClass = Class.forName(name);
            Object instance = aClass.getConstructor(null).newInstance(null);
            System.out.println(instance);
            Method setId = aClass.getMethod("setId", Integer.class);
            setId.invoke(instance, id);
            System.out.println(instance);
            Method setName = aClass.getMethod("setName", String.class);
            setName.invoke(instance, name2);
            System.out.println(instance);
            Method setAge = aClass.getMethod("setAge", Integer.class);
            setAge.invoke(instance, age);
            System.out.println(instance);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}