[Java-基础]反射_Class对象_动态操作

动态性

动态语言

在程序运行时，可以改变程序结构或变量类型，典型的语言：
- Python，ruby，javascript
- 如：

function test(){
    var s = "var a=3;var b=5;alert(a+b);";
    eval(s);
}

Java的动态性

C，C++，JAVA不是动态语言，但是JAVA有一定的动态性
我们可以利用反射机制，字节码操作获得类似动态语言的特性
JAVA的动态性让编程的时候更加灵活

Class类

反射机制

指的是可以于运行时加载，探知，使用编译期间完全未知的类
程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。

、Class c=Class.forName("com.User");

"com.User"是字符串，是类的路径，可以动态的实时的加载这个类。
加载完类之后，在堆内存中，就产生一个Class类型的对象，一个类只有一个Class对象，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象像一面镜子，透过这个镜子看到类的结构。所以称之为反射、

先简单写一个com.User

public class User {
    /**
     *
     */
    private int id;
    private int age;
    private String uname;

    public User() {

    }

    public User(int id,int age,String uname){
        super();
        this.id=id;
        this.age=age;
        this.uname=uname;
    }
    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

获取Class对象的方式

获取Class对象的三种方式
1 Object ——> getClass();
2 任何数据类型（包括基本数据类型int，数组等）都有一个“静态”的class属性
3 通过Class类的静态方法：forName（String className）(常用)

public class Demo01 {

    public static void main(String []args){
        //第一种  Object ——> getClass();
        User user1 = new User();
        Class clazz1=user1.getClass();
        System.out.println(clazz1.hashCode());

        //第二种 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
        Class clazz2 = User.class;
        System.out.println(clazz2.hashCode());

        //第三种：通过Class类的静态方法：forName（String  className）(常用)
        String path="com.fanshe.User";
        try {
            Class clazz3=Class.forName(path);
            System.out.println(clazz3.hashCode());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

这三种方法得到的hashcode是一样的，这验证了一个类只有一个Class对象：一个工厂可以有很多辆车，但可能只有一张图纸。

反射机制的常见作用

反射的使用主要就是获取到了Class对象之后，通过调用Class对象的方法来操纵。

public class Demo02 {
    public static void main(String[] args) throws NoSuchMethodException {
        //第三种：通过Class类的静态方法：forName（String  className）(常用)
        String path="com.fanshe.User";
        try {
            Class clazz3=Class.forName(path);
            //获得类的名字
            System.out.println("\n获取类的名字: ");
            System.out.println(clazz3.getName());//包名加类名
            System.out.println(clazz3.getSimpleName());//类名

            //获取属性信息
            System.out.println("\n获取属性信息: ");
            Field[] field=clazz3.getFields();
            Field[] field1=clazz3.getDeclaredFields();
            System.out.println(field.length+"  "+field1.length);//前者只能读取public的
            Field field2 = clazz3.getDeclaredField("id");
            for(Field temp:field1){
                System.out.println("属性: "+temp);
            }

            //获取方法的属性
            System.out.println("\n获取方法的属性: ");
            Method[] methods = clazz3.getDeclaredMethods();
            Method method = clazz3.getMethod("setUname", String.class);//单一方法
            Method method1 = clazz3.getMethod("getUname",null);
            for(Method temp:methods){
                System.out.println("方法： "+temp);
            }

            //获得构造器的信息
            System.out.println("\n获得构造器信息: ");
            Constructor[] constructors = clazz3.getDeclaredConstructors();
            for(Constructor temp:constructors){
                System.out.println("构造器: "+temp);
            }
            Constructor constructor = clazz3.getDeclaredConstructor(int.class,int.class,String.class);
            System.out.println("有参构造器："+clazz3);
         } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
}

运行结果

获取类的名字: 
com.fanshe.User
User

获取属性信息: 
0  3
属性: private int com.fanshe.User.id
属性: private int com.fanshe.User.age
属性: private java.lang.String com.fanshe.User.uname

获取方法的属性: 
方法： public int com.fanshe.User.getId()
方法： public java.lang.String com.fanshe.User.getUname()
方法： public void com.fanshe.User.setUname(java.lang.String)
方法： public void com.fanshe.User.setId(int)
方法： public int com.fanshe.User.getAge()
方法： public void com.fanshe.User.setAge(int)

获得构造器信息: 
构造器: public com.fanshe.User()
构造器: public com.fanshe.User(int,int,java.lang.String)
有参构造器：class com.fanshe.User

通过反射API的动态操作

public class Demo03 {
    public static void main(String []args){
        //第三种：通过Class类的静态方法：forName（String  className）(常用)
        String path="com.fanshe.User";
        try {
            Class clazz3=Class.forName(path);
        /*通过反射API调用构造方法，构造对象*/

            //其实是调用了User的无参方法
            User user = (User)clazz3.newInstance();
            user.setUname("大王");
            System.out.println(user.getUname());
            //获得方法
            Constructor<User> constructor = clazz3.getDeclaredConstructor(int.class,int.class,String.class);
            //通过实际的参数来调用
            User user1 = constructor.newInstance(1001,18,"美云");
            System.out.println(user1.getUname());
        /*通过反射API调用普通方法*/
           //user1.setUname("小七");
           User user2 =(User) clazz3.newInstance();
            Method method = clazz3.getDeclaredMethod("setUname",String.class);
            method.invoke(user2,"小七");
            System.out.println(user2.getUname());

        /*通过反射API操作属性*/
            User user3 = (User)clazz3.newInstance();
            Field f =clazz3.getDeclaredField("uname");
            f.setAccessible(true);
            f.set(user3,"小赖");
            System.out.println(user3.getUname());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
}

运行结果明显