类加载器，，，，，反射，，，，，泛型擦除，，，，， 反射配置文件

1.1 类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

l 加载

就是指将class文件读入内存，并为之创建一个Class对象。

任何类被使用时系统都会建立一个Class对象

l 连接

验证 是否有正确的内部结构，并和其他类协调一致

准备 负责为类的静态成员分配内存，并设置默认初始化值

解析 将类的二进制数据中的符号引用替换为直接引用

l 初始化

就是我们以前讲过的初始化步骤

1.1 类初始化时机

1. 创建类的实例

2. 类的静态变量，或者为静态变量赋值

3. 类的静态方法

4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

5. 初始化某个类的子类

6. 直接使用java.exe命令来运行某个主类

1.1 反射

1.1 Class类

l 获取Class对象的三种方式

方式一: 通过Object类中的getObject()方法

Person p = new Person();

Class c = p.getClass();

方式二: 通过 类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性,看上去要比第一种方式简单）。

Class c2 = Person.class;

方式三: 通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）。

Class c3 = Class.forName("Person");

l 注意：第三种和前两种的区别

前两种你必须明确Person类型.

后面是指定这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了。

l 代码演示

 * 获取.class字节码文件对象的方式
 *         1：通过Object类中的getObject()方法
 *         2: 通过 类名.class 获取到字节码文件对象
 *         3: 反射中的方法,
 *             public static Class<?> forName(String className) throws ClassNotFoundException
 *             返回与带有给定字符串名的类或接口相关联的 Class 对象 
 */
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1： 通过Object类中的getObject()方法
        // Person p1 = new Person();
        // Class c1 = p1.getClass();
        // System.out.println("c1 = "+ c1);

        // 2: 通过 类名.class 获取到字节码文件对象
        // Class c2 = Person.class;
        // System.out.println("c2 = "+ c2);

        // 3: 反射中的方法
        Class c3 = Class.forName("cn.oracle_01_Reflect.Person");// 包名.类名
        System.out.println("c3 = " + c3);
    }
}

l Person类

package cn.oracle_01_Reflect;
public class Person {
    //成员变量
    public String name;
    public int age;
    private String address;

    //构造方法
    public Person() {
        System.out.println("空参数构造方法");
    }
    
    public Person(String name) {
        this.name = name;
        System.out.println("带有String的构造方法");
    }
    //私有的构造方法
    private Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("带有String，int的构造方法");
    }
    
    public Person(String name, int age, String address){
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("带有String, int, String的构造方法");
    }
    
    //成员方法
    //没有返回值没有参数的方法
    public void method1(){
        System.out.println("没有返回值没有参数的方法");
    }
    //没有返回值，有参数的方法
    public void method2(String name){
        System.out.println("没有返回值，有参数的方法 name= "+ name);
    }
    //有返回值，没有参数
    public int method3(){
        System.out.println("有返回值，没有参数的方法");
        return 123;
    }
    //有返回值，有参数的方法
    public String method4(String name){
        System.out.println("有返回值，有参数的方法");
        return "哈哈" + name;
    }
    //私有方法
    private void method5(){
        System.out.println("私有方法");
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
    }
}

在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示。可通过Class类中提供的方法获取构造方法

l 返回一个构造方法

n public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取public修饰, 指定参数类型所对应的构造方法

n public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定参数类型所对应的构造方法(包含私有的)

l 返回多个构造方法

n public Constructor<?>[] getConstructors() 获取所有的public 修饰的构造方法

n public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法(包含私有的)

 

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
        //获取Class对象
        Class c = Class.forName("cn.oracle_01_Reflect.Person");//包名.类名
        
        //获取所有的构造方法
        //Constructor[] cons = c.getConstructors();
        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
        
        System.out.println("------------------------");
        //获取一个构造方法
        //public Person() 
        Constructor con1 = c.getConstructor(null);
        System.out.println(con1);
        
        //public Person(String name)
        Constructor con2 = c.getConstructor(String.class);
        System.out.println(con2);
        
        //private Person(String name, int age)
        Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(con3);
        
        //public Person(String name, int age, String address)
        Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
        System.out.println(con4);
    }
}

 通过反射获取成员变量并使用

在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量：

l  返回一个成员变量

  public Field getField(String name) 获取指定的 public修饰的变量

  public Field getDeclaredField(String name) 获取指定的任意变量

l  返回多个成员变量

  public Field[] getFields() 获取所有public 修饰的变量

  public Field[] getDeclaredFields() 获取所有的 变量 (包含私有)

 

//通过反射获取成员变量并使用
public class Demo01 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
    //获取Person类的字节码文件
    Class c=Class.forName("com.oracle.demo06.Person");
    //获取成员变量对象
    Field fl=c.getField("name");
    //System.out.println(fl);
    //快速创建对象，只能调用空参构造
    Person p=(Person)c.newInstance();
    fl.set(p,"小红帽");
    System.out.println(p.name);//获得成员变量
}
}

泛型擦除

程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除

//泛型擦除,泛型不进class文件
public class Demo03 {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    ArrayList<String> arr=new ArrayList<String>();
    arr.add("abc");
    //获取arr的字节码文件对象
    Class c=arr.getClass();
    //获取add的方法对象
    Method method=c.getMethod("add", Object.class);
    //调用方法:执行add()方法
    method.invoke(arr, 123);
    System.out.println(arr);
}
}

反射配置文件

通过反射配置文件，运行配置文件中指定类的对应方法

读取Peoperties.txt文件中的数据，通过反射技术，来完成Person对象的创建

package com.oracle.demo08;

public class Worker {

    public void work(){
        System.out.println("工人工作");
    
}
}
 

public class Student {
public void study(){
    System.out.println("学生学习");
}
}
public class Doctor {

    public void job(){
        System.out.println("医生工作");
    
}
}
 

public class Demo01 {
public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    //创建Properties集合对象
    Properties pro=new Properties();
    //创建输入流读取
    FileInputStream fis=new FileInputStream("src/com/oracle/demo08/pro.properties");
    pro.load(fis);//读到集合中
    //获取类名
    String className=pro.getProperty("className");
    String methodName=pro.getProperty("methodName");
    //反射获取字节码文件
    Class c=Class.forName(className);
    //获取方法对象
    Method m=c.getMethod(methodName);
    //快速创建对象
    Object obj=c.newInstance();
    //调用方法
    m.invoke(obj);
    
}
}

创建对象的三种方法：new，反序列，反射

 

 

 

package cn.oracle_01_Reflect;

public class Person {

//成员变量

public String name;

public int age;

private String address;

 

//构造方法

public Person() {

System.out.println("空参数构造方法");

}

 

public Person(String name) {

this.name = name;

System.out.println("带有String的构造方法");

}

//私有的构造方法

private Person(String name, int age){

this.name = name;

this.age = age;

System.out.println("带有String，int的构造方法");

}

 

public Person(String name, int age, String address){

this.name = name;

this.age = age;

this.address = address;

System.out.println("带有String, int, String的构造方法");

}

 

//成员方法

//没有返回值没有参数的方法

public void method1(){

System.out.println("没有返回值没有参数的方法");

}

//没有返回值，有参数的方法

public void method2(String name){

System.out.println("没有返回值，有参数的方法 name= "+ name);

}

//有返回值，没有参数

public int method3(){

System.out.println("有返回值，没有参数的方法");

return 123;

}

//有返回值，有参数的方法

public String method4(String name){

System.out.println("有返回值，有参数的方法");

return "哈哈" + name;

}

//私有方法

private void method5(){

System.out.println("私有方法");

}

 

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";

}

}