第12章反射与内省-1、什么是反射与Class类

第12章反射与内省

课程大纲
1、什么是反射
2、Class类
3、通过Class类取得类信息
4、通过Class类调用属性或方法
5、动态代理
6、JavaBean的概念
7、内省基本概念
8、 Introspector 相关API
9、单例模式优化

1、什么是反射

反射： Reflection

2、Class类

Class类是一切的反射根源。
Class类表示什么？
很多的人——可以定义一个Person类（有年龄，性别，姓名等）
很多的车——可以定义一个Car类（有发动机，颜色，车轮等）
很多的类——Class类（类名，构造方法，属性，方法）
得到Class类的对象有三种方式：
第一种形式：Object类中的getClass()方法
第二种形式：类.class
第三种形式：通过Class类的forName方法

使用Class类进行对象的实例化操作
调用无参构造进行实例化
public T newInstance() throws InstantiationException,IllegalAccessException
调用有参构造进行实例化
public Constructor<?>[] getConstructors() throws SecurityException

package com.vince;

import org.junit.Test;

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

public class ReflectionDemo {


    /*
    获取Class对象的三种形式
     */
    @Test
    public void test1(){
        //通过对象的getClass()方法
        Dog dog=new Dog("WANGWANG",9);
        Class aClass=dog.getClass();

        ///通过类.class
        Class dogClass=Dog.class;

        //通过Class.forName方法
       try {
           Class aClasss = Class.forName("com.vince.Dog");
       }catch (ClassNotFoundException e){
           e.printStackTrace();
       }
    }


    /*
    通过反射来实例化对象
     */

    public  void test2(){
       Class dogClass=Dog.class;
        try {
            //通过Class对象来实例化对象，调用默认无参的构造方法
            Dog dog = (Dog)dogClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }


    @Test
    public void test3(){
        Class dogClass=Dog.class;
        Constructor[] constructors = dogClass.getConstructors();
        for (int i = 0; i <constructors.length ; i++) {
            System.out.println(constructors[i].getName());
            System.out.println(constructors[i].getParameterCount());

        }
        try {
            //获取一个指定的构造方法
            Constructor constructor = dogClass.getConstructor(String.class, int.class);
            //调用带参数的构造器来实例化对象
            Dog dog= (Dog) constructor.newInstance("小白",7);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
        }catch (NoSuchMethodException e){
            e.printStackTrace();
        }
    }


    @Test
    public void test4(){
        Class dogClass=Dog.class;
        //获取属性Field
        Field[] fields=dogClass.getFields();
        //私有属性不可打印
        //System.out.println(fields.length);

        //获取所以有属性，包括私有属性
        Field[] declaredFields = dogClass.getDeclaredFields();
        //System.out.println(declaredFields.length);
        for (int i = 0; i <declaredFields.length ; i++) {
            int modifiers=declaredFields[i].getModifiers();
            System.out.println(Modifier.toString(modifiers)+" "+declaredFields[i].getName());

        }



    }
}


class Dog{
    private  String name;
    private  int age;
    public String tepy;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

test3:
com.vince.Dog
2

test4:
private name
private age
public tepy