黑马程序员-学习日记（反射）

  JAVA反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。

    动态获取类中信息，就是java反射。可以理解为对类的解剖。

    如果想要对指定名称的字节码文件进行加载并获取其中的内容并调用，这时就使用到了此技术。

示例：获取字节码文件对象的3种方式

Person.java 

package reflect;

public class Person {
    private int age;
    private String name;
    
    public Person(int age,String name)
    {
        super();
        this.age = age;
        this.name = name;
        System.out.println("Person param run..." + this.name + ":" + this.age);
    }
    public Person()
    {
        super();
        System.out.println("person run");
    }
    
     public void show(){
         System.out.println(name + "...show run..." + age);
 }

     private void privateMethod(){
             System.out.println("method run");
     }
    
     public void paramMethod(String str,int num){
             System.out.println("paramMethod run..." + str + ":" + num);
     }
    
     public static void staticMethod(){
             System.out.println("static method run...");
     }
}

1⃣️、Object类中的getClass()方法。使用该方法必须明确要获取的具体的类，并创建对象。所以比较麻烦。

2⃣️、任何数据类型都具备有一静态属性（.class）来获取其对应的Class对象。虽然相对上一种方式简单，但还是要明确用到类中的静态成员。

3⃣️、只要通过给定的类的字符串名称就能获取该类字节码文件。

ReflectDemo.java

package reflect;
//import reflect.Person;

public class ReflectDemo {

    public static void main(String[] args) throws ClassNotFoundException {
        
        getClassObject_3();
        
        
    }
    
    public static void getClassObject_1()
    {
        Person p = new Person();
        Class cls = p.getClass();
        
        Person p1 = new Person();
        Class cls1 = p1.getClass();
        
        System.out.println(cls==cls1);
    }
    
    public static void getClassObject_2()
    {
        Class clazz = Person.class;
        Class clazz1 = Person.class;
        
        System.out.println(clazz == clazz1);
    }
    
    public static void getClassObject_3() throws ClassNotFoundException
    {
        String className = "reflect.Person";
        Class clazz = Class.forName(className);
        System.out.print(clazz);
    }
}

如果指定 的类中没有空参数构造函数。或者要创建的类对象需要通过指定的构造函数进行初始化。此时就不能用到newInstance方法了。

得到这个类的所有构造函数：

Constructor[] constr = Class.forName("reflect.Person").getConstructors();

获取某一个构造函数：

Constructor constr = Person.class.getConstructor(String.class,int.class);

创建实例对象：

Person p = (Person)constr.newInstance(30,"小王");

要注意的是创建实例时newInstance方法中的参数列表必须与获取Constructor的方法getConstructor方法中的参数列表一致。

示例：获取Class中的构造函数

package reflect;


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
        
        createNewObject_1();
        createNewObject_2();
        
    }
    
    public static void createNewObject_1() throws ClassNotFoundException, InstantiationException, IllegalAccessException
    {
        String classname = "reflect.Person";
        Class cls = Class.forName(classname);
        Object obj = cls.newInstance();
    }
    
    public static void createNewObject_2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
    {
        /*
         * 使用getConstructor(parameterTypes)方法来获取指定名称对应类所
　　　　　　　　体现的对象的构造函数
         */
        String classname = "reflect.Person";
        //找到该名称类文件、加载进内存，并产生Class对象
        Class cls = Class.forName(classname);
        //获取到指定的构造函数对象
        Constructor contr = cls.getConstructor(int.class,String.class);
        //通过该构造函数对象的newInstance方法进行对象的初始化
        Object obj = contr.newInstance(29,"小王");
    }
}

示例：获取类的字段

package reflect;
//import reflect.Person;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo {

    public static void main(String[] args) throws Exception {
        
        getFieldDemo();
    }
    public static void getFieldDemo() throws Exception
    {
        Class cls = Class.forName("reflect.Person");
        //getDeclaredField可以都获取到公共字段或私有字段
        Field field = cls.getDeclaredField("age");
        //对私有字段的访问取消权限检查。
        field.setAccessible(true);
        
        Object obj = cls.newInstance();
        field.set(obj, 31);
        Object o = field.get(obj);
        System.out.println(field);
    }
27 }

Method类代表某个类中的一个成员方法 。调用某个对象上的方法，要先得到方法，再针对某个对象进行调用。

在写源程序时，并不知道使用者传入的类名是啥，知道的是这个类是有main这个方法的。所以可以通过反射的方式，传入类名获取其main方法，然后执行相应的内容。

示例：获取类中的方法

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

public class ReflectDemo {

    public static void main(String[] args) throws Exception {
        
        getMethodDemo_1();
        System.out.println("---------------------------");
        getMethodDemo_2();
        System.out.println("---------------------------");
        getMethodDemo_3();
    }
    
    public static void getMethodDemo_1() throws ClassNotFoundException
    {
        Class cls = Class.forName("reflect.Person");
        Method[] methods = cls.getMethods();
        methods = cls.getDeclaredMethods();
        for (Method mthd:methods)
        {
            System.out.println(mthd);
        }
    }
    public static void getMethodDemo_2() throws Exception
    {
        Class cls = Class.forName("reflect.Person");
        Method mt = cls.getMethod("show", null);
        Object obj = cls.newInstance();
        Constructor contr = cls.getConstructor(int.class,String.class);
        obj = contr.newInstance(21,"小米");
        mt.invoke(obj, null);
    }
    public static void getMethodDemo_3() throws Exception
    {
        Class cls = Class.forName("reflect.Person");
        Method mt = cls.getMethod("paramMethod", String.class,int.class);
        Object obj = cls.newInstance();
        
        Constructor constr = cls.getConstructor();
        obj = constr.newInstance();
        mt.invoke(obj, "小李",23);
    }
}

示例：根据用户提供的类名，执行该类中的main方法。

package reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class PerformMain {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        // TODO Auto-generated method stub
        //一般方式
        Test.main(new String[]{"12","34","56"});
        System.out.println("-----------------------------");
        //反射方式
        String className = args[0];
        Class cls = Class.forName(className);
        
        Method methodMain = cls.getMethod("main", String[].class);
        methodMain.invoke(null, (Object)new String[]{"12","34","56"});
        methodMain.invoke(null, new Object[]{new String[]{"123","456","789"}});
    }

}

class Test{
    public static void main(String[] args)
    {
        for(String arg:args)
        {
            System.out.println(arg);
        }
    }
}

示例：

一个应用程序已经完成编写，无需额外的代码加入了。而后期遇出现了需要加入新的功能的情况。就如同计算机一样，使用后期用户会置换更好的键盘、硬盘等，所以计算机事先预留了usb接口，只要符合此接口规则的设备，计算机就可以通过加载驱动来完成使用。

一个方便的作法是，对外提供一个配置文件，让后期出现的子类直接将类名写入配置文件中即可。该应用程序直接读取配置文件的内容，并查找与给定名称相同的类文件。

package reflect;

import java.io.File;
import java.io.FileInputStream;
import java.sql.PseudoColumnUsage;
import java.util.Properties;

public class ReflectTest {
     public static void main(String[] args)  throws Exception
     {
         Computer cp = new Computer();
         cp.run();
         
         //关联配置文件
         FileInputStream fis = new FileInputStream(new File("USB.properties"));
         //将配置文件信息缓存到集合中
         Properties props = new Properties();
         props.load(fis);
         for (int i = 1; i < props.size(); i++) {
            String className = props.getProperty("USB"+i);
            Class cls = Class.forName(className);
            USB usb = (USB)cls.newInstance();
            cp.viaUSB(usb);
        }
         fis.close();
     }
}

interface USB{
    void plug();
    void unplug();
}

class Computer{
    public void run() {
        System.out.println("Computer is running");
    }
    public void viaUSB(USB usb){
        if(usb!=null){
            usb.plug();
            usb.unplug();
        }
    }
}

class Keyboard implements USB{
    @Override
    public void plug() {
        // TODO Auto-generated method stub
        System.out.println("Keyboard plugged in!");
    }

    @Override
    public void unplug() {
        // TODO Auto-generated method stub
        System.out.println("Keyboard unplugged!");
    }    
}

class Monitor implements USB{

    @Override
    public void plug() {
        // TODO Auto-generated method stub
        System.out.println("Monitor plugged in!");
    }

    @Override
    public void unplug() {
        // TODO Auto-generated method stub
        System.out.println("Monitor unplugged!");
    }
    
}

 配置文件：

USB.properties

USB1 = reflect.Keyboard

USB2 = reflect.Monitor

 

 HashCode的分析

覆写hashCode()方法之意义：只有存入的是具有hashCode算法的集合。覆写该方法才有意义。

1、由来

若在一个集合中查找是否含有某个对象，通常是一个一个去比较。找到后还要进行equals的比较。当对象特别多时，效率低下。有这么一种HashCode算法，有一个集合，将此集合分成若干区域，每个存入集合的对象会被计算出一个哈希值，根据该值将对象放入相应的区域中。当需要查找某一对象时，只要算出其哈希值，看属于哪一个区域，然后到相应区域区寻找。如此查找的性能就提高了。

2、如果没有复写hashCode方法，对象的hashCode值是按照内存地址进行计算的。这样即使两个对象的内容是想等的，但是存入集合中的内存地址值不同，导致hashCode值也不同，被存入的区域也不同。所以即使是两个内容相等的对象，也能存入集合中。

所以就有这样的说法：如果两个对象equals相等的话，你应该让他们的hashCode也相等。如果对象存入的不是根据hash算法的集合中，就不需要复写hashCode方法。

3、一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了。否则对象修改后的哈希值与最初存储进HashSet集合中的哈希值就不同了。在这种情况下，调用contains方法或者remove方法来寻找或者删除这个对象的引用，就会找不到这个对象。从而导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。（程序中某一些对象不再被使用，以为被删掉了，但是没有，还一直在占用内存中，当这样的对象慢慢增加时，就会造成内存泄露。）