［javaSE］反射机制

缺乏、安全感 2023-05-30 09:29 84阅读 0赞

# Java反射 #

没有反射就没有任何EE框架！

对象的正向处理是什么呢？就是根据类产生对象，举一个简单的日期类为例

Date date=new Date();
    
    System.out.println(date);

反射：对象的反向处理。根据对象倒推类的组成。

反射的核心处理在于Object类的方法：－－－取得类的class对象

查看Object类方法：\[Alt+7\]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA_size_16_color_FFFFFF_t_70][]

查看其源码：

@return The {@code Class} object that represents the runtime
         *         class of this object.
         * @jls 15.8.2 Class Literals
         */
        @HotSpotIntrinsicCandidate
        public final native Class<?> getClass();

public final native Class<?> getClass();也就是返回一个运行时产生的对象

class类描述各个类的组成（包括构造方法，普通方法，普通属性）

## １取得class对象 ##

任何一个类的class对象由JVM加载类后产生，该对象在JVM中全局唯一，用户只能调用指定方法来取得该对象

a.任何类的对象可以通过调用Object类的getClass()取得(要反射的)该类的Class对象

\[类对象.getClass()\]

Date date=new Date();
    System.out.println(date.getClass());

b.［类名称.Class］可以根据某个具体类来取得其Class对象

System.out.println(Date.class);

c.调用Class类的静态方法+Class.forName(String className)传入类的全名称来取得类的Class对象

System.out.println(Class.forName("java.util.Date"));

输出都为:class java.util.Date

### ２取得一个类的Class对象后通过反射来实例化对象 ###

在Class类中有如下方法：

Java9之后不推荐使用newInstance方法已经被禁用，选择其他方法

class.getDeclaredConstructor().newInstance()

1.class.newInstance():会直接调用该类的无参构造函数进行实例化

2.class.getDeclaredConstructor().newInstance()  
getDeclaredConstructor()方法会根据他的参数对该类的构造函数进行搜索并返回对应的构造函数，没有参数就返回该类的无参构造函数，然后再通过newInstance进行实例化。

举例：通过反射取得Date类的实例化对象

package se.SE.practice;
    import java.lang.reflect.InvocationTargetException;
    import java.text.DateFormat;
    import java.util.Date;
    public class reflect {
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    //        取得class对象
            Class<Date> myclass=(Class<Date>)Class.forName("java.util.Date");
    //        通过反射取得Date类实例化对象
            Date date=myclass.getDeclaredConstructor().newInstance();
            System.out.println(date);
    
        }
    }

输出结果：

![20191110144105477.png][]

### ３优化工厂模式 ###

工厂模式中每增加一个产品，就增加一条if else语句

比如：假设有水果加工工厂Factory0，子类实现水果接口（interface IFruit），有苹果Apple类，桔子Orange类为子类

现在需要增加一个子类Pear,需要在Factory0类中增加:

else if(className.equals("pear"))\{  
return new Pear;  
\}

interface IFruit{
        void eat();
    }
    class Apple implements IFruit{
        @Override
        public void eat() {
            System.out.printf("eat an apple");
        }
    }
    class Orange implements  IFruit{
        @Override
        public void eat() {
            System.out.println("eat an orange");
        }
    }
    class Pear implements IFruit{
    
        @Override
        public void eat() {
            System.out.println("eat an pear");
        }
    }
    class Factory0{
        private Factory0(){}
        public static IFruit getInstance(String className){//利用getInstance来实例化对象
            if(className.equals("apple")){
                return new Apple();
            }else if(className.equals("orange")){
                return new Orange();
            }else if(className.equals("pear")){
                return new Pear;
            }
            return null;
        }
    }
    public class Factory {
        public static void main(String[] args) {
            IFruit iFruit=Factory0.getInstance("apple");
            iFruit.eat();
        }
    }

结果：eat an apple

那么反射就可以解决工厂模式的这一弊端－－－－反射修改工厂方法

class Factory0{
        private Factory0(){}
        public static IFruit getInstance(String className){
           IFruit iFruit=null;
           try {
               //取得类名为className类的class对象
               Class<?> myclass =Class.forName(className);
               //通过反射，来对象的实例化
               iFruit= (IFruit) myclass.getDeclaredConstructor().newInstance();
           }catch (Exception e){
                e.printStackTrace();
           }
           return iFruit;
        }
    }
    public class Factory {
        public static void main(String[] args) {
            IFruit iFruit=Factory0.getInstance("se.SE.practice.Pear");
            iFruit.eat();
        }
    }

完整代码：

package se.SE.practice;
    interface IFruit{
        void eat();
    }
    class Apple implements IFruit{
        @Override
        public void eat() {
            System.out.printf("eat an apple");
        }
    }
    class Orange implements  IFruit{
        @Override
        public void eat() {
            System.out.println("eat an orange");
        }
    }
    class Pear implements IFruit{
    
        @Override
        public void eat() {
            System.out.println("eat an pear");
        }
    }
    class Factory0{
        private Factory0(){}
        public static IFruit getInstance(String className){//利用getInstance来实例化对象
            IFruit iFruit=null;
            try{
                //取得class类
                Class<?> myclass=Class.forName(className);
                //通过反射实例化对象
                iFruit=(IFruit)myclass.getDeclaredConstructor().getInstance();
            }catch(Exception e){
                e.printStackTrace();
            }
            return iFruit;
        }
    }
    class Factory0{
        private Factory0(){}
        public static IFruit getInstance(String className){
           IFruit iFruit=null;
           try {
               //取得类名为className类的class对象
               Class<?> myclass =Class.forName(className);
               //通过反射，来对象的实例化
               iFruit= (IFruit) myclass.getDeclaredConstructor().newInstance();
           }catch (Exception e){
                e.printStackTrace();
           }
           return iFruit;
        }
    }
    public class Factory {
        public static void main(String[] args) {
            IFruit iFruit=Factory0.getInstance("se.SE.practice.Pear");
            iFruit.eat();
        }
    }

输出：eat an pear

## ２反射与类操作 ##

2.1通过反射取得父类与父接口信息：

a.取得类的包名称：

public Package getPackage()

方法一：

Class<?> myclass=Date.class;//取得Date类的class对象
    
    System.out.println(myclass.getPackage().getName);//取得myclass对象的包名称

输出：package java.util

2.2取得父类的Class对象（不理解通配符可先了解[泛型（通配符）][Link 1]相关知识点）

－－－父类为单继承，只可能有一个

public native Class<? super T> getSuperClass();//泛型下限通配符，取得父类对象

2.3实现的父接口

－－－父接口为多继承，可能有多个

public Class<?>[]　getInterfaces();

foreach循环语法：

第一个表达式是声明一个变量去接受每次循环得到的元素

第二个表达式是需要遍历的数组或集合 定义的变量类型必须跟数组的类型一致（表达式一的数据类型必须与表达式二数据类型一致）

for(Class classs:classes){
                System.out.println(classs.getName());
            }

代码实现：

package se.SE.practice;
    class Person{}//定义父类Person()
    interface INews{}
    interface IMessage{}
    class Student extends Person implements INews,IMessage{}
    //定义子类Student继承父类Person实现INews和IMessage接口
    public class reflect {
        public static void main(String[] args) {
    //        取得Student类的class对象
        Class<?> myclass=Student.class;
    //   　　 取得父类信息
            System.out.println(myclass.getSuperclass().getName());
    //        取得父接口
            Class<?>[] classes=myclass.getInterfaces();
            for(Class classs:classes){
                System.out.println(classs.getName());
            }
        }
    }

结果：

![20191110220901771.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019110921354147.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA==,size_16,color_FFFFFF,t_70
[20191110144105477.png]: https://img-blog.csdnimg.cn/20191110144105477.png
[Link 1]: https://blog.csdn.net/weixin_42645168/article/details/102768764
[20191110220901771.png]: https://img-blog.csdnimg.cn/20191110220901771.png