Java 反射（部分）

最新推荐文章于 2024-09-27 00:45:01 发布
麦合学长
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量355
点赞数 6
文章标签： java
本文链接：https://blog.csdn.net/rassamqi/article/details/135081393
版权
//*****************************************************  反射  *****712************************************************************//
public class Cat {

    private String name = "招财猫";
    public int age = 10; //public的

    public Cat() {} //无参构造器

    public Cat(String name) {
        this.name = name;
    }

    public void hi() { //常用方法
        //System.out.println("hi " + name);
    }
    public void cry() { //常用方法
        System.out.println(name + " 喵喵叫..");
    }

}

//****************************
//****************************
re.properties
        classfullpath=com.hspedu.Cat
        method=cry
//****************************
//****************************
/**
 * @author 韩顺平
 * @version 1.0
 * 反射问题的引入
 */
@SuppressWarnings({"all"})
public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {

        //根据配置文件 re.properties 指定信息, 创建Cat对象并调用方法hi
        //老韩回忆

        //传统的方式 new 对象 -》 调用方法
//        Cat cat = new Cat();
         cat.hi(); ===> cat.cry() 传统方法：修改源码.  反射：只需要修改配置文件：method=hi---> method=cry

        //我们尝试做一做 -> 明白反射

        //1. 使用Properties 类, 可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();//"com.hspedu.Cat"
        String methodName = properties.get("method").toString();//"hi"
        System.out.println("classfullpath=" + classfullpath);
        System.out.println("method=" + methodName);

        //2. 创建对象 , 传统的方法，行不通 =》 反射机制
        //new classfullpath();

        //3. 使用反射机制解决
        //(1) 加载类, 返回Class类型的对象cls
        Class cls = Class.forName(classfullpath);    // 通过反射类，得到反射类的对象(反射类的对象===类)
        //(2) 通过 cls 得到你加载的类 com.hspedu.Cat 的对象实例
        Object o = cls.newInstance();   //通过反射类的对象(类)，创建类的对象
        System.out.println("o的运行类型=" + o.getClass()); //运行类型
        //(3) 通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi"  的方法对象
        //    即：在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = cls.getMethod(methodName);  // 通过反射类的对象，创建方法对象
        //(4) 通过method1 调用方法: 即通过方法对象来实现调用方法
        System.out.println("=============================");
        method1.invoke(o); //传统方法 对象.方法() , 反射机制 方法.invoke(对象)    //方法对象实例化



        Class cls = Class.forName("Cat");
        Object o = cls.newInstance();
        System.out.println("o的运行类型=" + o.getClass()); //o的运行类型=class Cat
        Method method1 = cls.getMethod("cry");  // 招财猫 喵喵叫..
        method1.invoke(o);


    }
}


        引出需求：通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的 ocp原则(开闭原则)
                (这样的需求在学习框架时特别多)
                属性是对象 方法是对象 类也是对象

//*****************************************************************************************************************************//
//***********************************************************713***************************************************************//
//*****************************************************************************************************************************//
                                    Java Reflection
        1.反射机制允许程序在执行期借助于Reflection1 .API取得任何类的内部信息(比如成员变量，构造器，成员方法等等)，
                并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
        2.加载完类之后，在堆中就产生了一个Class类型的对象 (一个类只有一个class对象) ，这个对象包含了类的完整结构信息。
            通过这个对象得到类的结构。这个Class对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为:反射
        p 对象 ----> 类型：Person类           Class对象 cls --->类型：Class类
//*****************************************************************************************************************************//
//*************************************************************714*************************************************************//
//*****************************************************************************************************************************//
                        反射机制
            Java反射机制可以完成：
                    1.在运行时判断任意一个对象所属的类
                    2.在运行时构造任意一个类的对象
                    3.在运行时得到任意一个类所具有的成员变量和方法
                    4.在运行时调用任意一个对象的成员变量和方法
                    5.生成动态代理

                            反射机制
                反射相关的主要类：
                    1.java.lang.Class:代表一个类Class对象表示某个类加载后在堆中的对象
                    2.java.lang.reflect.Method: 代表类的方法,Method对象表示某个类的方法
                    3.java.lang.reflect.Field: 代表类的成员变量, Field对象表示某个类的成员变量
                    4.java.lang.reflect.Constructor: 代表类的构造方法, Constructor对象表示构造器
                            这些类在java.lang.reflection


//*******************
public class Reflection01 {

    public static void main(String[] args) throws Exception {



        //1. 使用Properties 类, 可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();//"com.hspedu.Cat"
        String methodName = properties.get("method").toString();//"hi"


        //2. 使用反射机制解决
        //(1) 加载类, 返回Class类型的对象cls
        Class cls = Class.forName(classfullpath);
        //(2) 通过 cls 得到你加载的类 com.hspedu.Cat 的对象实例
        Object o = cls.newInstance();       //通过反射类的对象(类)，创建类的对象
        System.out.println("o的运行类型=" + o.getClass()); //运行类型
        //(3) 通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi"  的方法对象
        //    即：在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = cls.getMethod(methodName);
        //(4) 通过method1 调用方法: 即通过方法对象来实现调用方法
        System.out.println("=============================");
        method1.invoke(o); //传统方法 对象.方法() , 反射机制 方法.invoke(对象)

        //java.lang.reflect.Field: 代表类的成员变量, Field对象表示某个类的成员变量
        //得到name字段
        //getField不能得到私有的属性
        Field nameField = cls.getField("name"); //无法获得！！  私有的
        Field ageField = cls.getField("age"); //public 可以获得
        System.out.println(nameField.get(o)); // 传统写法 对象.成员变量 , 反射 :  成员变量对象.get(对象)

        //java.lang.reflect.Constructor: 代表类的构造方法, Constructor对象表示构造器
        Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型, 返回无参构造器
        System.out.println(constructor);//Cat()



        Constructor constructor2 = cls.getConstructor(String.class); //这里老师传入的 String.class 就是String类的Class对象
        System.out.println(constructor2);//Cat(String name)
    }
}

//*****************************************************************************************************************************//
//*************************************************************715*************************************************************//
//*****************************************************************************************************************************//
                                        反射机制
                反射优点和缺点
                    优点: 可以动态的创建和使用对象(也是框架底层核心)，使用灵活,没有反射机制，框架技术就失去底层支撑。
                    缺点: 使用反射基本是解释执行，对执行速度有影响


/**
 * @author 韩顺平
 * @version 1.0
 * 测试反射调用的性能，和优化方案
 */
public class Reflection02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

        m1();
        m2();
        m3();
    }

    //传统方法来调用hi
    public static void m1() {

        com.hspedu.Cat cat = new com.hspedu.Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 90; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("m1() 耗时=" + (end - start));
    }

    //反射机制调用方法hi
    public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        Class cls = Class.forName("com.hspedu.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);//反射调用方法
        }
        long end = System.currentTimeMillis();
        System.out.println("m2() 耗时=" + (end - start));
    }

    //反射调用优化 + 关闭访问检查

    public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        Class cls = Class.forName("com.hspedu.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        hi.setAccessible(true);//在反射调用方法时，取消访问检查
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);//反射调用方法
        }
        long end = System.currentTimeMillis();
        System.out.println("m3() 耗时=" + (end - start));
    }
}



                                反射机制
        反射调用优化-关闭访问检查
        1.Method和Field、Constructor对象都有setAccessible()方法
        2.setAccessible作用是启动和禁用访问安全检查的开关
        3.参数值为true表示 反射的对象在使用时取消访问检查，提高反射的效率。
          参数值为false则表示反射的对象执行访问检查

        Field ,  Method ,  Constructor 都继承了 setAccessible()方法 ，所以，都可以用：hi.setAccessible(true);


//*****************************************************************************************************************************//
//***************************************************************716***********************************************************//
//*****************************************************************************************************************************//
                1.Class也是类，因此也继承Object类[类图]
                2.Class类对象不是new出来的，而是系统创建的 [演示]
                3.对于某个类的Class类对象，在内存中只有一份，因为类只加载一
                4.每个类的实例都会记得自己是由哪个 Class 实例所生成
                5.通过Class对象可以完整地得到一个类的完整结构,通过一系列API
                6.Class对象是存放在堆的
                7.类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据(包括 方法代码送变量名，方法名，访问权限等等)
                                     " https://www.zhihu.com/question/38496907(示意图) "

/**
 * @author 韩顺平
 * @version 1.0
 * 对Class类特点的梳理
 */
public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //看看Class类图
        //1. Class也是类，因此也继承Object类
        //Class
        //2. Class类对象不是new出来的，而是系统创建的
        //(1) 传统new对象
        /*  ClassLoader类
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                return loadClass(name, false);
            }
         */
        //Cat cat = new Cat();
        //(2) 反射方式, 刚才老师没有debug到 ClassLoader类的 loadClass, 原因是，我没有注销Cat cat = new Cat();
        /*
            ClassLoader类, 仍然是通过 ClassLoader类加载Cat类的 Class对象
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                return loadClass(name, false);
            }
         */
        Class cls1 = Class.forName("com.hspedu.Cat");

        //3. 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
        Class cls2 = Class.forName("com.hspedu.Cat");
        System.out.println(cls1.hashCode());   //112233
        System.out.println(cls2.hashCode());   //112233
        Class cls3 = Class.forName("com.hspedu.Dog");
        System.out.println(cls3.hashCode());



    }
}

//*****************************************************************************************************************************//
//***************************************************************717***********************************************************//
//*****************************************************************************************************************************//
import uu.Car;

        import java.lang.reflect.Field;

public class QQ {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {

        String classAllPath = "uu.Car";
        //1 . 获取到Car类 对应的 Class对象
        //<?> 表示不确定的Java类型
        Class<?> cls = Class.forName(classAllPath);
        //2. 输出cls
        System.out.println(cls); //显示cls对象, 是哪个类的Class对象 class uu.Car
        //通过反射类的对象(类)，创建类的对象   就是类！！！
        System.out.println(cls.getClass());//输出cls运行类型  class java.lang.Class
        // 属于 Class 类
        //3. 得到包名
        System.out.println(cls.getPackage().getName());//包名  uu
        //4. 得到全类名
        System.out.println(cls.getName());   // uu.Car
        //5. 通过cls创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car);//car.toString()    Car{brand='宝马', price=500000, color='白色'}
        //6. 通过反射获取属性 brand
        Field brand = cls.getField("brand");  // 私有属性，会报错！！无法获取
        System.out.println(brand.get(car));  //宝马
        //7. 通过反射给属性赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));  //奔驰
        //8 我希望大家可以得到所有的属性(字段)
        System.out.println("=======所有的字段属性====");
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName());//名称 brand   price    color

        }


    }
}

            细节：System.out.println(cls.getPackage());//包
            // 如果没有存放在“包”里，直接存放的话  cls.getPackage()：null
            // cls.getPackage().getName() 报错！异常！毕竟 null.getName()肯定不行

//*******************************

public class Car {
    public String brand = "宝马";//品牌
    public int price = 500000;
    public String color = "白色";

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}


//*****************************************************************************************************************************//
//***************************************************************718**********************************************************//
//*****************************************************************************************************************************//
                            获取Class类对象
        GetClass java
        1.前提: 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法 forName()获取，
                                            可能抛出ClassNotFoundException，
              实例: Class cls1Class.forName( "iava.lang.Cat");
          应用场景:多用于配置文件,读取类全路径，加载类
        2.前提: 若已知具体的类，通过类的class 获取，该方式 最为安全可靠，程序性能最高
              实例: Class cls2 = Cat.class;
          应用场景:多用于参数传递，比如通过反射得到对应构造器对象

/**
 * @author 韩顺平
 * @version 1.0
 * 演示得到Class对象的各种方式(6)
 */
public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {

        //1. Class.forName
        String classAllPath = "com.hspedu.Car"; //通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2. 类名.class , 应用场景: 用于参数传递
        Class cls2 = com.hspedu.Car.class;
        System.out.println(cls2);

        //3. 对象.getClass(), 应用场景，有对象实例
        com.hspedu.Car car = new com.hspedu.Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);

        //4. 通过类加载器【4种】来获取到类的Class对象
        //(1)先得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        //cls1 , cls2 , cls3 , cls4 其实是同一个对象
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);//int  先自动“装箱”成 Integer，再自动“拆箱”成 int

        //6. 基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE; //其它包装类BOOLEAN, DOUBLE, LONG,BYTE等待
        System.out.println(type1);

        System.out.println(integerClass.hashCode());// 1111111
        System.out.println(type1.hashCode());//1111111


        细节：
        其实这就是动态绑定机制，new Cat是重点，这才是实例化，而Cat可以找到他自己的class对象，里面就存储相关方法

    }
}

//*****************************************************************************************************************************//
//****************************************************************719*********************************************************//
//*****************************************************************************************************************************//
/**
 * @author 韩顺平
 * @version 1.0
 * 演示哪些类型有Class对象
 */
public class AllTypeClass {
    public static void main(String[] args) {

        Class<String> cls1 = String.class;//外部类
        Class<Serializable> cls2 = Serializable.class;//接口
        Class<Integer[]> cls3 = Integer[].class;//数组
        Class<float[][]> cls4 = float[][].class;//二维数组
        Class<Deprecated> cls5 = Deprecated.class;//注解
        //枚举
        Class<Thread.State> cls6 = Thread.State.class;
        Class<Long> cls7 = long.class;//基本数据类型
        Class<Void> cls8 = void.class;//void数据类型
        Class<Class> cls9 = Class.class;//

        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println(cls3);
        System.out.println(cls4);
        System.out.println(cls5);
        System.out.println(cls6);
        System.out.println(cls7);
        System.out.println(cls8);
        System.out.println(cls9);
    }
}

//*****************************************************************************************************************************//
//****************************************************************720*********************************************************//
//*****************************************************************************************************************************//
                            类加载
        基本说明:
            反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。
            1.静态加载:编译时加载相关的类，如果没有则报错，依赖性太强
            2.动态加载:运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不报错，降低了依赖性

        类加载时机
        1.当创建对象时 (new) //静态加载
        2.当子类被加载时，父类也加载 //静态加载
        3.调用类中的静态成员时 //静态加载
        4.通过反射 //动态加载


                                    
        import java.util.*;
        import java. lang.relfect.*;
        public class ClassLoad_ {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                System.out.println("请输入key");
                String key = scanner.next();
                switch (key) {
                    case "1"
                        Dog dog = new Dog();//静态加载
                        dog.cry();
                        break;
                    case "2":
                        CLass cls = CLass.forName("Person");//加载Person类
                        Object o = cls.newInstance();
                        Method m = cls.getMethod("hi");
                        m.invoke(o);
                        System.out.println("ok");
                        break;
                    default:
                        System.out.println("do nothing...");
                }
            }
        }

                    1.new Dog() 是静态加载，因此必须编写Dog
                    2.Person类是动态加载，所以，没有编写Person类也不会报错，只有当动态加载该类时，才会报错。


class Dog {
            public void cry() {
                System.out.printIn("小狗汪汪叫");
    }
}

class Person {
    public void hi() {
        System.out.printIn("小孩 hi");
    }
}