java反射机制

一切皆对象

java中所有的东西都有对应的对象,包括包,类，方法，字段，注解，一切皆对象。
包package对应的类java.lang.reflect.Package
类class对应的java.lang.reflect.Class
字段field对应的类是java.lang.reflect.Field
方法method对应的类是java.lang.reflect.Method

1.package

Package可以操作的空间很小
知道怎么找到一个Package和getName方法就行了

• 获取包 getPackage可以拿到类所在的包
• 获取类名 getName() 返回的字符串包含了包名

        Package pk=Package.getPackage("com.demo.reflect");
        System.out.println(pk.getName());

2.class

获取对象的类对象，操作对象的方法，字段。

/获取已知类对象
Class<String> stringClz=String.class;
//获取未知类对象
Class<?> class=Class.forName("com.demo.xx.XX");

• 获取构造方法 getConstructor()
• 创建对象 newInstance() 这个必须保证有默认构造方法

 Class clz=Class.forName("com.demo.reflect.A");
/**
 * 获取构造函数 constructor(String)
 * 并创建对象
 */
 Object obj=clz.getConstructor(String.class).newInstance("嘿嘿");

• getSuperclass 获取父类 默认父类是Object
• getInterfaces 获取实现的接口

       Class<? super A> superAClass=aClass.getSuperclass();
        System.out.println(superAClass.getName());

        Class[] interfaces=aClass.getInterfaces();
        for (int i=0;i<interfaces.length;i++){
            System.out.println(interfaces[i].getName());
        }

3.Method

*获取方法 getMethod() getDeclaredMethod() 区别就是获取public 还是protect private

Class clz=Class.forName("com.demo.reflect.A");
/**
 * 获取构造函数 constructor(String)
 * 并创建对象
 */
 Object obj=clz.getConstructor(String.class).newInstance("嘿嘿");

Method getNameMethod=clz.getMethod("getName");

Method setNameMethod=clz.getMethod("setName",String.class);

 setNameMethod.invoke(obj,"设置的值");
System.out.println(getNameMethod.invoke(obj));

4.Field

• 获取字段 getField() getDeclaredField() 区别就是获取public 还是protect private

A类的name字段

Class clz=Class.forName("com.demo.reflect.A");
/**
 * 获取构造函数 constructor(String)
 * 并创建对象
 */
Object obj=clz.getConstructor(String.class).newInstance("哈哈");
//拿到private 或者protect的字段 name
Field nameField=clz.getDeclaredField("name");
//设置访问权限
nameField.setAccessible(true);
//取值
System.out.println(nameField.get(obj));

反射的作用

解耦且基于配置,依赖反转
让Computer类只依赖接口不依赖具体实现

public interface Cpu {

    String getName();
    double core();
}

public interface Disk {
    int size();
}

public interface Display {

    String show();
}

public class Computer {

    public Cpu cpu;
    public Disk disk;
    public Display display;

    public Computer(Cpu cpu, Disk disk, Display display) {
        this.cpu = cpu;
        this.disk = disk;
        this.display = display;
    }

    public void showMessage(){
        System.out.println("CPU："+this.cpu.core()+"核心 "+this.cpu.getName());
        System.out.println("硬盘："+disk.size()/1024+"m");
        System.out.println("显示器："+display.show());
    }
}

实现类

public class I7Cpu implements Cpu {
    @Override
    public String getName() {
        return "i7";
    }

    @Override
    public double core() {
        return 4;
    }
}

public class I9Cpu implements Cpu {
    @Override
    public String getName() {
        return "core i9";
    }

    @Override
    public double core() {
        return 9;
    }
}

public class SansungDisplay implements Display {
    @Override
    public String show() {
        return " 三星 1980*1070 显示器";
    }
}

public class SonyDisk implements Disk {
    @Override
    public int size() {
        return 2048;
    }
}

配置文件 computerA.txt

com.demo.reflect.impl.I9Cpu
com.demo.reflect.impl.SonyDisk
com.demo.reflect.impl.SansungDisplay

main方法

public static Object getClass(String str) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    return Class.forName(str).newInstance();
}

public static void main(String agrs[]) throws Exception {
    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(new FileInputStream("src/computerA.txt")));
    String cpu=bufferedReader.readLine();
    String disk=bufferedReader.readLine();
    String display=bufferedReader.readLine();
    bufferedReader.close();
    new Computer((Cpu) getClass(cpu),(Disk) getClass(disk),(Display) getClass(display)).showMessage();
}

通过读取配置文件自动构建出Computer类的实例，不修改程序的情况下 只需要修改配置文件就可以达到修改Cpu Disk和Display