Java

大纲：
Class类的使用：
  三种获得Class类的实例的方法；
  基本数据类型对应的类类型；
  Class类的基本API:获取类的常用（全部）信息；
Java类加载机制：
  编译时加载（静态加载）；
  运行时加载（动态加载）；
方法的反射：
成员变量的反射：
构造函数的反射：
通过反射了解集合泛型的本质：

在面向对象的世界里，万事万物皆对象；但其实静态的成员、普通的数据类型不是对象，但我们最好看做万事万物皆对象；类也是对象，类是java.lang.Class类的实例对象；任何一个类都是Clss类的实例对象；

三种获得Class类的实例的方法：

/**
 * Class类的使用：Class类的实例对象的三种表示方法
 */
package reflect;

public class ClassTest01
{
    public static void main(String[] args)
    {
        // Foo类的实例对象：foo
        Foo foo = new Foo();
        
        // Foo这个类也是一个实例对象，是java.lang.Class类的实例对象
        // 任何一个类都是Class类的实例对象，这个实例对象有三种表示方法
        
        // 第一种表示方法：
        // 实际告诉我们，任何一个类都有一个隐含的静态成员变量：class
        Class c1 = Foo.class;
        
        // 第二种表示方法：已知该类的实例对象，通过getClass()方法获取
        Class c2 = foo.getClass();
        
        // 官网描述：c1、c2表示Foo类的类类型（class type）
        // 如何解释：Foo类本身就是一个实例对象，是Class类的实例对象
        // 以此区分：Foo类的实例对象为foo，Foo类的类类型为c1、c2
        
        // c1、c2都是同一个类（Foo）的类类型，一个类只可能是Class类的一个实例对象
        // 所以c1与c2完全相等
        System.out.println(c1 == c2);
        
        // 第三种表示方法：
        Class c3 = null;
        try
        {
            // 写出类的全量名
            c3 = Class.forName("reflect.Foo");
        } 
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        // c2与c3完全相等
        System.out.println(c2 == c3);
        
        // 可以通过一个类的类类型创建该类的实例对象
        try
        {
            // 前提：要有无参的构造方法
            Foo f1 = (Foo) c1.newInstance();
            // 此时可以调用类的方法了
            f1.display();
        } 
        catch (InstantiationException e)
        {
            e.printStackTrace();
        } 
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
    }
}

class Foo
{
    void display()
    {
        System.out.println("abc");
    }
}

Class类动态加载类的用法：
  Class.forName(“类的全称”); 这种写法不仅表示了类的类类型，还表示了动态加载类；
  要区分编译和运行：
    编译时刻加载类是静态加载类、运行时刻加载类是动态加载类；
    new 创建对象：是静态加载类，在编译时刻就需要加载所有可能用到的类，不管这些类在后面是否真用到了；（通过动态加载类可以解决该问题）；

静态加载类的方式：

/**
 * 静态加载类的方式：通过new创建对象
 */
package reflect.static_load;

public class Office
{
    public static void main(String[] args)
    {
        // Word类，Excel类必须都存在才能运行
        if("Word".equals(args[0]))
        {
            // 通过new创建对象，是静态加载类，在编译时刻就需要加载所有可能使用到的类，不管你需不需要用；所以下面报错了，因为没有定义Word和Execl类；
            // 现在的需求是：你想用哪个就加载哪个，哪个不用就不加载它，这就涉及到动态加载；
            // 通过动态加载类可以解决该问题
            Word word = new Word();  // 这里编译报错，因为没有Word类
            word.start();
        }
        
        if("Excel".equals(args[0]))
        {
            Excel excel = new Excel();  // 这里编译报错，因为没有Excel类
            excel.start();
        }
    }
}

动态加载类的方式：

/**
 * 动态加载类
 */
package reflect.dynamic_load;

public class OfficeBetter
{
    public static void main(String[] args)
    {
        // 实例一
        try
        {
            // 动态加载类，在运行时刻加载；就算此时没有定义Execl类，编译也没有报错；只有在运行时才会报错
            Class c1 = Class.forName("reflect.dynamic_load.Excel");
        } 
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        
        // 实例二
        // 动态加载类，在运行时刻加载
        try
        {
            Class c2 = Class.forName("reflect.dynamic_load.Excel");
            // 如下直接创建具体类的类对象不合适，如果你想要的是Office类对象，但加载的可能是Excel类对象
            Word word = (Word) c2.newInstance();  // 运行时报错，因为c2是Excel类的类类型
            word.show();
            Excel excel = (Excel) c2.newInstance();
            excel.show();
        } 
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        } 
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
        
        // 实例三
        try
        {
            // 动态加载类，在运行时刻加载
            Class c3 = Class.forName("reflect.dynamic_load.Excel");
            // 通过类类型创建具体类的实例对象
            // 统一标准，优化实例二
            OfficeAble oa = (OfficeAble)c3.newInstance();
            oa.show();
        } 
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        } 
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
    }
}

package reflect.dynamic_load;

public interface OfficeAble
{
    public void show();
}

package reflect.dynamic_load;

public class Word implements OfficeAble
{
    public void show()
    {
        System.out.println("word...work");
    }
}

package reflect.dynamic_load;

public class Excel implements OfficeAble
{
    public void show()
    {
        System.out.println("excel...work");
    }
}

基本数据类型对应的类类型：

/**
 * 基本数据类型和一些关键字都存在对应的类类型
 */
package reflect;

public class ClassTest02
{
    public static void main(String[] args)
    {
        Class c1 = int.class; // int基本类型对应的类类型
        Class c2 = double.class;
        // 打印出类类型的名称
        System.out.println(c1.getName());  // 结果：int 
        System.out.println(c2.getName());  // 结果：double
        
        Class c3 = Double.class; // Double类的类类型
        Class c4 = String.class;
        System.out.println(c3.getName());  // 结果：java.lang.Double
        System.out.println(c4.getName());  // 结果：java.lang.String
        System.out.println(c4.getSimpleName());  // 结果：String，不带包名的类名称
        
        // 只要是在类里面声明的返回值啊什么的基本都有对应的类类型
        Class c5 = void.class; // void关键字对应的类类型
        System.out.println(c5.getName());
    }
}

Class类的基本API:获取类的常用（全部）信息：

/**
 * Class类的基本API:获取类的常用信息；
 * 获取类的信息，要先获取类的类类型
 */
package reflect;

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

public class ClassTest03
{
    public static void main(String[] args)
    {
        
    }
    
    // 获取方法的信息
    public static void getMethodsMessage(Object obj)
    {
        // 先获取类的类类型
        // 因为我们有了类的对象，所以通过这种方法获取类的类类型
        // 传递的是哪个子类的对象，获取的就是那个子类的类类型
        Class c = obj.getClass();  
        
        // 获取类的完整名称
        System.out.println(c.getName());
        
        // 获取类的名称（不是完整的名称）
        System.out.println(c.getSimpleName());
        
        // 获取类的方法
        // 万事万物都是对象，方法也是对象
        // 一个成员方法就是一个java.lang.reflect.Method类的对象，Method类里面封装了关于成员方法的操作
        // getMethods()：获取所有的public修饰的函数，包括父类继承而来的
        Method[] ms = c.getMethods();
        // getDeclaredMethods()：获取所有该类自己声明的方法，不问访问权限，不包括继承来的方法
        Method[] ms2 = c.getDeclaredMethods();
        
        // 下面获取方法的信息
        for(int i=0;i<ms.length;i++)
        {
            // 获取方法的返回值类型的类类型
            Class returnType = ms[i].getReturnType();
            // 获得方法的返回值类型的类类型的名字
            System.out.println(returnType.getName());
            
            // 获取方法的名称
            System.out.println(ms[i].getName());
            
            // 获取方法的参数列表的类型的类类型
            Class[] parameterTypes = ms[i].getParameterTypes();
            for(int j=0;j<parameterTypes.length;j++)
            {
                // 获取方法的参数类型的类类型的名字
                System.out.println(parameterTypes[j].getName());
            }
        }
    }
    
    // 获取成员变量的信息
    private static void getFieldsMessage(Object obj)
    {
        // 先获取类的类类型
        Class c = obj.getClass();
        
        // 成员变量也是对象，是java.lang.reflect.Field类的对象，Field类里面封装了关于成员变量的操作
        // getFields()：获取所有的public的成员变量的信息
        Field[] fs = c.getFields();
        // getDeclaredFields()：获取该类自己声明的成员变量的信息
        Field[] fs2 = c.getDeclaredFields();
        for(Field f:fs)
        {
            // 获取成员变量的类型的类类型
            Class fieldTypes = f.getType();
            // 获取成员变量的类型的类类型的名字
            String typeName = fieldTypes.getName();
            System.out.println(typeName);
            // 获取成员变量的名字
            String fieldName = f.getName();
            System.out.println(fieldName);
        }
    }
    
    // 获取对象的构造函数的信息
    public static void getConstructorMessage(Object obj)
    {
        // 先获取类的类类型
        Class c = obj.getClass();
        
        // 构造函数也是对象，是java.lang.reflect.Constructor类的对象，Constructor类中封装了构造函数的信息
        // c.getConstructors()：获得所有的public的构造函数
        Constructor[] con = c.getConstructors();
        // getDeclaredConstructors()：获得所有的构造函数；也可以说获得所有自己声明的构造方法，因为构造方法都是必须要自己声明的；
        Constructor[] con2 = c.getDeclaredConstructors();
        for(Constructor constr:con2)
        {
            // 获取构造函数的参数列表的类型的类类型
            Class[] parametersTypes = constr.getParameterTypes();
            for(Class parametersType:parametersTypes)
            {
                // 获取构造函数的参数列表的类型的类类型的名称
                System.out.println(parametersType.getName());
            }
            
            // 获取构造函数的名字
            System.out.println(constr.getName());
        }
    }
}

方法的反射的基本操作：
1、如何获取某个方法：
  方法的名称和方法的参数列表才能唯一决定某个方法；
2、方法反射的操作：
  method.invoke(对象,参数列表);

/**
 * 方法的反射操作
 * 要获取一个方法，就是获取类的信息，获取类的信息首先要获取类的类类型
 */
package reflect;

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

public class MethodTest01
{
    public static void main(String[] args)
    {
        // 获取需要的方法:方法名+参数列表唯一决定一个方法
        
        // 先获取类类型
        A a = new A();
        Class c = a.getClass();
        
        // 再获取方法：方法名+参数列表
        try
        {
            // 获取方法
            // getMethod()：获取public方法
            // getDeclaredMethod()：获取自己声明的方法
            Method m = c.getMethod("show", new Class[]{int.class,int.class});
            // 也可以这样写
            Method m2 = c.getMethod("show", int.class,int.class);
            
            // 获取方法后，进行方法的反射操作
            // 以前调用方法是这样写的，而方法的反射操作是用n对象来进行方法调用，但两者的效果是一样的
            // a.show(1,2);
            // 方法的反射操作
            // 方法如果没有返回值，返回null，有具体的返回值就返回具体的返回值
            Object o = m.invoke(a, new Object[]{1,2});
            // 也可以这样写
            Object o2 = m2.invoke(a, 1,2);
            
            Method m3 = c.getMethod("show", new Class[]{String.class,String.class});
            Method m4 = c.getMethod("show", String.class,String.class);
            Object o3 = m3.invoke(a, new Object[]{"hello",",world"});
            Object o4 = m4.invoke(a, "hello",",world");
            
            // 方法的形参为空场景
            Method m5 = c.getMethod("show", new Class[]{});
            // 或者没有就不传
            Method m6 = c.getMethod("show");
            Object o5 = m5.invoke(a, new Object[]{});
            Object o6 = m6.invoke(a);
        } 
        catch (NoSuchMethodException e)
        {
            e.printStackTrace();
        } 
        catch (SecurityException e)
        {
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        } 
        catch (IllegalArgumentException e)
        {
            e.printStackTrace();
        } 
        catch (InvocationTargetException e)
        {
            e.printStackTrace();
        }
    }
}

class A
{
    public void show(int i,int j)
    {
        System.out.println(i + j);
    }
    
    public void show(String i,String j)
    {
        System.out.println(i.toUpperCase() + "," + j.toUpperCase());
    }
    
    public void show()
    {
        
    }
}

通过反射了解集合泛型的本质：

/**
 * 通过反射了解集合泛型的本质
 */
package reflect;

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

public class MethodTest02
{
    public static void main(String[] args)
    {
        ArrayList list = new ArrayList();
        ArrayList<String> list1 = new ArrayList<String>();
        
        list1.add("123");
        // 下面这样写是错误的，因为泛型限制的加入的对象类型
        // list1.add(23);
        
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        
        // 反射的操作都是编译之后（运行时）的操作
        // 结果为true，说明编译之后的集合的泛型是去泛型化的，就是说编译之后集合就没有泛型了
        // java中集合的泛型是防止错误输入的，只在编译时有效，绕过编译就无效了
        // 验证：通过方法的反射绕过编译
        System.out.println(c1 == c2);  // true
        
        // 验证:通过方法的反射操作绕过编译
        try
        {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(list1, 1); // 绕过编译操作就绕过了泛型，能添加int类型数据
            System.out.println(list1.size());
            System.out.println(list1);
            
            // 现在就不能用String类型遍历了，因为有了int类型
        } 
        catch (NoSuchMethodException e)
        {
            e.printStackTrace();
        } 
        catch (SecurityException e)
        {
            e.printStackTrace();
        }
        catch (IllegalArgumentException e)
        {
            e.printStackTrace();
        } 
        catch (InvocationTargetException e)
        {
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
    }
}