反射

Class类的使用：

　　在面向对象的世界里，万事万物皆对象

　　java语言中，静态成员，普通数据类型不是对象

　　类也是对象，是java.lang.Class类的实例对象

　基本的数据类型 void关键字都存在类类型

　　获取类类型的三种方式：

　　　　01.类名.class

　　　　02.对象名.getClass();

　　　　03.Class.forName("完整的限定名"); =》常用

package com.ltc;
/**
 * Class类的使用
 */
public class ClassDemo1 {

　　class Foo{
    void print(){
        System.out.println("foo");
    }

    public static void main(String[] args) {
        //Foo的实例对象如何表示
        Foo foo1 = new Foo();
        
        //Foo这个类 也是一个实例对象，Class类的实例对象，如何表示出来
        //任何一个类都是Class的实例对象，这个实例对象有三种表达方式
        
        //第一种表示方式==》实际再告诉我们任何一个类都有一个隐含的静态成员变量class
        Class c1 = Foo.class;
        
        //第二种表达方式 已经知道该类的对象通过getClass方法
        Class c2 = foo1.getClass();
        
        /**
         * 官网c1和c2表示了Foo类的类类型（class type）
         * 万事万物皆对象
         * 类也是对象，是Class类的实例对象
         * 这个对象我们称之为该类的类类型
         */
        
        //不管c1 or c2都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
        System.out.println(c1==c2);
        
        //第三种表达方式
        Class c3 = null;
        try {
            c3 = Class.forName("com.ltc.Foo");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
                
        System.out.println(c2==c3);
        
        //我们完全可以通过类的类类型创建该类的对象示例==》通过c1 or c2 or c3创建Foo的实例对象
        Foo foo;
        try {
            foo = (Foo)c1.newInstance();
            foo.print();
        } catch (InstantiationException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

Java动态加载类

　　Class.forName("类的全称");

　　不仅表示了类类型，还代表了动态加载类

　　区分编译、运行

　　编译时刻加载类是静态加载类，运行时刻加载类是动态加载类

　　new 创建对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类

　　通过动态加载类可以解决该问题，有效防止一个类对象加载错误导致整个程序不能运行

　　功能性的类最好是进行动态加载类

反射：

　　在运行期间，对于任意一个类，我们都能知道这类中所有的属性和方法（包括私有的）！

　　这种动态获取类的信息和动态调用对象的方法或者属性的功能====》java反射机制

　　但是破坏了封装的安全性！

创建一个对象Student

package com.ltc;

import java.util.Date;

public class Student {

    public int age; // 年龄
    protected String name; // 姓名
    private char sex = '男'; // 性别
    Date birthday = new Date();// 出生日期

    static {
        System.out.println("这是Student类中的静态代码块！");
    }

    {
        System.out.println("这是Student类中的普通代码块！");
    }

    public Student() {
        System.out.println("这是Student类中的无参构造！");
    }

    // 私有的方法
    private double getSum(double num) {
        return num + 10;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

01.利用反射获取该类的包名、限定名和修饰符

@org.junit.Test
    public void test01(){
        
        try {
　　　　　　　//动态加载类
            Class c = Class.forName("com.ltc.Student");
            
            System.out.println("所在的包名："+c.getPackage().getName());
            System.out.println("完整限定名:"+c.getName());
            System.out.println("简写的类名："+c.getSimpleName());
            
　　　　　　　//获取修饰符会返回一个int类型的数字，Modifier.toString(int num);方法把数字解析成对应的修饰符
            int num = c.getModifiers();
            String result = Modifier.toString(num);
            System.out.println("获取该类的修饰符："+result);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }

02.获取类的属性

/**
     * getFileds():只能获取public修饰的属性
     * getDeclaredFields():所有属性字段的集合
     */
    @org.junit.Test
    public void test02(){
        try {
            Class c = Class.forName("com.ltc.Student");
            Field[] fields = c.getFields();
            for (int i = 0; i < fields.length; i++) {
                System.out.println(fields[i].getName());
                System.out.println("对应的修饰符是==》"+Modifier.toString(fields[i].getModifiers()));
            }
            System.out.println("**********************************************************");
            Field[] fields2 = c.getDeclaredFields();
            for (int i = 0; i < fields2.length; i++) {
                System.out.println(fields2[i].getName());
                System.out.println("对应的修饰符是==》"+Modifier.toString(fields2[i].getModifiers()));
            }
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

03.获取类的方法

/**
     *  c.getMethods()  :获取所有public修饰的方法
     *  c.getDeclaredMethods():获取所有的方法
     */
    @org.junit.Test
    public void test03(){
        try {
            Class c = Class.forName("com.ltc.Student");
            Method[] methods = c.getDeclaredMethods();
            for (int i = 0; i < methods.length; i++) {
                System.out.println("方法的名称==》"+methods[i].getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

04.获取类的私有属性值

@org.junit.Test
    public void test04(){
        try {
            Class c = Class.forName("com.ltc.Student");
            Student stu = (Student)c.newInstance();
            //stu.sex 获取不到私有的属性和私有方法
            Field field = c.getDeclaredField("sex");
            //打开访问私有属性或者方法的开关
            field.setAccessible(true);
            System.out.println(field.get(stu));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

05.获取类的私有方法

方法反射的操作
method.invoke(对象，参数列表)

@org.junit.Test
    public void test05(){
        
        try {
            Class c = Class.forName("com.ltc.Student");
            Student stu = (Student)c.newInstance();
            Method methods = c.getDeclaredMethod("getSum", double.class);
            methods.setAccessible(true);
            double result = (double) methods.invoke(stu, 50.0);
            System.out.println(result);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

升华

@org.junit.Test
    public void test06(){
        ArrayList list = new ArrayList();
        
        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("hello");
        //list1.add(20);错误的
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1 == c2);
        //反射的操作都是编译之后的操作
        
        /*
         * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
         * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
         * 绕过编译就无效了
         * 验证：我们可以通过方法的反射来操作，绕过编译
         */
        try {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(list1, 20);//绕过编译操作就绕过了泛型
            System.out.println(list1.size());
            System.out.println(list1);
            /*for (String string : list1) {
                System.out.println(string);
            }*///现在不能这样遍历
        } catch (Exception e) {
          e.printStackTrace();
        }
    }