JAVA面向对象-----反射机制

面试题：Java中创建对象大概有这几种方式？

思考：在讲反射之前，先思考一个问题，java中如何创建一个对象，有哪几种方式?

答：

1. 使用new关键字：这是我们最常见的也是最简单的创建对象的方式，需要使用构造器。

语法格式：类名 对象名 = new 类名()；

  //1、使用关键字new创建对象（没有参数调用无参构造、传入参数调用带参构造）
  Girlfriend girlfriend01 = new Girlfriend();
  Girlfriend girlfriend02 = new Girlfriend("y", 18);

2. 使用object类的clone方法：需要实现Cloneable接口，重写object类的clone方法。无论何时我们调用一个对象的clone方法，JVM就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。

语法格式：类名 对象名 = (类名)已创建好的类对象名.clone();

Girlfriend girlfriendClone = (Girlfriend) girlfriend03.clone();

3. 使用反序列化：通过 ObjectInputStream 的 readObject()方法反序列化类，当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象。为了反序列化一个对象，我们需要让我们的类实现Serializable接口。在反序列化时，JVM创建对象并不会调用任何构造函数。
   通过反序列化生成对象的过程主要由以下几个步骤：
   1、创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
   2、 通过对象输入流的readObject()方法读取对象。

Girlfriend clone = ObjectUtils.clone(girlfriend04);

序列化工具类：

public class ObjectUtils {
    public static <T extends Serializable> T clone(Girlfriend obj) {
        T cloneObj = null;
        try {
            //写入字节流
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream obs = new ObjectOutputStream(out);
            obs.writeObject(obj);
            obs.close();
            //分配内存，写入原始对象，生成新对象
            ByteArrayInputStream bis = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            //返回新生成的对象
            cloneObj = (T) ois.readObject();
            bis.close();
            out.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}

上边是Java中常见的创建对象的三种方式，其实除了上边的三种还有另外一种方式，就是接下来我们要讨论的 “反射”。使用反射机制创建对象，用Class类或Constructor类的newInstance()方法。

语法格式：
java.lang.Class Class 类对象名称=java.lang.Class.forName(要实例化的类全称);

类名 对象名=(类名)Class类对象名称.newInstance();

当使用Class类里的newInstance()方法，调用的是无参构造方法。

当使用 java.lang.reflect.Constructor 类里的 newInstance() 方法，调用的是有参构造方法。

        //使用反射机制创建对象，使用Class的newInstance()调用默认的无参构造
        Girlfriend girlfriend03 = Girlfriend.class.newInstance();

        //反射机制2，调用带参
        Class<?> p1 = Class.forName("com.yky.Girlfriend");
        Constructor<?> constructor = p1.getConstructor(String.class, Integer.class);
        Girlfriend girlfriend04 = (Girlfriend) constructor.newInstance("k", 18);
        System.out.println(girlfriend04);

静态语言 / 动态语言

动态语言:

➢是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

➢主要动态语言: Object-C、 C#、 JavaScript、 PHP、 Python等。

静态语言：

➢与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。

注意：
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一 定的动态性,我们可以利用反射机制获得类似动态语言的特性。Java的动态性上编程的时候更加灵活!

什么是反射机制？

Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

反射机制的原理

我们可能听过，Java编写的程序，一次编译，到处运行。这也是Java程序为什么是无关平台的所在，原因在于，java的源代码会被编译成.class文件字节码，只要装有Java虚拟机JVM的地方（Java提供了各种不同平台上的虚拟机制。）.class文件才可以在运行加载。其流程如下：

• 第一步：由Java编译器进行源代码编译，得到相应类的字节码.class文件。
• 第二步：生成class文件之后，通过ClassLoader类加载器加载进内存，Java字节码由JVM执行解释给目标计算机。
• 第三步，目标计算机将结果呈现给我们计算机用户；因此，Java并不是编译机制，而是解释机制.class文件才可以在不同平台上运行加载。

Java的反射机制，操作的就是这个.class文件，首先加载相应类的字节码（运行编译器idea的时候，.class文件的字节码会加载到内存中），随后解剖（反射 reflect）出字节码中的构造函数、方法以及变量（字段）。

反射的优缺点

优点：

在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。

缺点：

• 反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
• 反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。

反射的用途

1、反编译：.class文件 --> .java文件；

2、通过反射机制访问java对象的属性，方法，构造方法等；

3、当我们在使用IDE,比如Ecplise时，当我们输入一个对象或者类，并想调用他的属性和方法是，一按点号，编译器就会自动列出他的属性或者方法，这里就是用到反射；

4、反射最重要的用途就是开发各种通用框架。比如很多框架（Spring）都是配置化的（比如通过XML文件配置Bean），为了保证框架的通用性，他们可能需要根据配置文件加载不同的类或者对象，调用不同的方法，这个时候就必须使用到反射了，运行时动态加载需要的加载的对象。

5、例如，在使用Strut2框架的开发过程中，我们一般会在struts.xml里去配置Action，比如

<action name="login" class="org.ScZyhSoft.test.action.SimpleLoginAction" method="execute">   
    <result>/shop/shop-index.jsp</result>           
    <result name="error">login.jsp</result>       
</action>

比如我们请求login.action时，那么StrutsPrepareAndExecuteFilter就会去解析struts.xml文件，从action中查找出name为login的Action，并根据class属性创建SimpleLoginAction实例，并用Invoke方法来调用execute方法，这个过程离不开反射。配置文件与Action建立了一种映射关系，当View层发出请求时，请求会被StrutsPrepareAndExecuteFilter拦截，然后StrutsPrepareAndExecuteFilter会去动态地创建Action实例。

比如，加载数据库驱动的，用到的也是反射。

Class.forName("com.mysql.jdbc.Driver"); // 动态加载mysql驱动

JAVA中基本数据类型的Class是什么？

import java.lang.annotation.ElementType;
//所有类型的Class
public class test2 {
    public static void main(String[] args) {
        Class c1 = Object.class; //类
        Class c2 = Comparable.class; //接口
        Class c3 = String[].class; //一维数组
        Class c4 = int[][].class; //二维数组
        Class c5 = Override.class; //注解
        Class c6 = ElementType.class; //枚举
        Class c7 = Integer .class; //基本数据类型
        Class c8 = void.class; //void
        Class c9 = Class.class; //Class

        System. out. println(c1);
        System. out. println(c2);
        System. out. println(c3);
        System. out. println(c4);
        System. out. println(c5);
        System. out. println(c6);
        System. out. println(c7);
        System. out. println(c8);
        System. out. println(c9);
        
        //只要元素类型与维度一样，就是同一个Class.
        int[] a = new int[10] ;
        int[] b = new int [100] ;
        System.out.println(a. getClass().hashCode()) ;
        System.out.println(b. getClass().hashCode()) ;

    }
}

运行结果：

反射机制常用的API

Java.lang.Class;

Java.lang.reflect.Constructor;

Java.lang.reflect.Field;

Java.lang.reflect.Method;

Java.lang.reflect.Modifier;

反射机制获取类的方法

java文件经过编译后生成一个或多个字节码文件(.class文件)，当我们对.class文件解释运行时。相当于将某个字节码文件加载到内存，此过程就称为类的加载。加载到内存中的类，就称为运行时类，此运行时类也就是Class的一个实例。

//通过反射获取类的方式
public class test1 {
    public static void main(String[] args) throws ClassNotFoundException{
        User user = new user1();
        System.out.println("这个角色是："+user.getName());

        //方式1：通过对象获得
        Class class1 = user.getClass();
        System.out.println(class1.hashCode());

        //方式2：使用forName获取
        Class class2 = Class.forName("testReflection.user1");
        System.out.println(class2.hashCode());

        //方式3:通过类名.class获得
        Class class3 = user1.class;
        System.out.println(class3.hashCode());

        //方式4：基本内置类型的包装类都有一个type属性（该方法有局限性）
        Class class4 = Integer.TYPE;
        System.out.println(class4);

        //获取class1的父类类型
        Class class5 = class1.getSuperclass();
        System.out.println(class5);
    }
}

//实体类
class User {
    private String name;
    private int id;
    private int age;

    public User() {
    }

    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

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

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

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

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


class user1 extends User {
    public user1() {
        this.setName("甲");
        this.setId(001);
        this.setAge(18);
    }
}

class user2 extends User {
    public user2() {
        this.setName("乙");
        this.setId(002);
        this.setAge(28);
    }
}

运行结果：
Class对象提供了如下常用方法：

通过反射获取运行时类的完整结构

public class test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName ("testReflection.User") ;
        //获得类的名字
        System.out.println(c1.getName()); //获得包名 +类名.
        System.out.println(c1 . getSimpleName()); //获得类名
        System.out.println("==============================");

        // 获得类的属性
        Field[] fields = c1.getFields();//只能找到public修饰的属性
        for (Field field : fields) {
            System. out . println(field);
        }
        System.out.println("==============================");
        fields = c1.getDeclaredFields();//获取全部的属性
        for (Field field : fields) {
            System. out . println(field);
        }
        System.out.println("==============================");

        //获得指定属性的值
        Field name = c1. getDeclaredField("name") ;
        System.out.println(name) ;
        System.out.println("============================");

        //获得类的方法
        Method[] methods = c1. getMethods(); // 获得本类及其父类的全部public方法
        for (Method method : methods) {
            System.out.println("正常的:" + method);
        }
        System.out.println("============================");
        methods = c1. getDeclaredMethods(); // 获得本类的所有方法
        for (Method method : methods) {
             System.out.println("getDeclaredMethods : "+method) ;
        }
        System.out.println("============================");
         //获得指定方法
        // 为什么要添加参数？因为JAVA中的重载，如果方法名一样没有添加参数就会出错
        Method getName = c1. getMethod("getName",null) ;
        Method setName = c1. getMethod("setName",String.class);
        System.out.println(getName);
        System.out.println(setName) ;
        System.out.println("============================");


        //获得指定的构造器
        Constructor[] constructors = c1. getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("public修饰："+constructor);
        }
        System.out.println("============================");
        constructors = c1. getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("全部：" + constructor);
        }
        System.out.println("============================");
        //获得指定的构造器
        Constructor declaredConstructor = c1. getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定构造器:"+declaredConstructor);
        }
}

获取Class对象后能做什么?

创建类的对象

方式一：调用Class对象的newInstance()方法。

➢1) 类必须有一个无参数的构造器。
➢2) 类的构造器的访问权限需要足够。

public class test09  {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //获得Class对象
        Class c1 = Class.forName ("testReflection.User");

        //构造一个对象
        User user = (User)c1. newInstance(); // 本质是调用了类的无参构造器
        System. out. println(user);
    }
}

运行结果：

试操作，如果我们把User类里面的无参构造器删除后，在运行代码，会报错~~

思考：难道没有无参的构造器就不能创建对象了吗?

不然，其实只要在操作的时候明确的调用User类中的构造器,并将参数传递进去之后，就可以实例化操作。

方式二:

• （1) 通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器；
• （2) 向构造器的形参中传递一个对象数组进去， 里面包含了构造器中所需的各个参数；
• （3) 通过Constructor实例化对象。

public class test09  {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //获得Class对象
        Class c1 = Class.forName ("testReflection.User");

        //通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String. class, int.class, int.class);
        User user2 = (User)constructor.newInstance("SKY",001,18);
        System.out.println(user2);
    }
}

运行结果：

通过反射调用对象的方法

public class test09  {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //获得Class对象
        Class c1 = Class.forName ("testReflection.User");
        
        //通过反射调用普通方法
        User user3 = (User)c1 . newInstance();
        //通过反射获取一个方法
        Method setName = c1. getDeclaredMethod( "setName", String.class) ;
        //invoke :激活的意思,(对象，“方法的值")
        setName.invoke (user3, "AAA") ;
        System.out.println(user3. getName());
    }
}

运行结果：

调用指定的方法：Object invoke(Object obj, Object args[])

1. Object 对应原方法的返回值，若原方法无返回值，此时返回null;
2. 若原方法若为静态方法,此时形参Object obj可为null;
3. 若原方法形参列表为空，则Object[] args为null;
4. 若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

通过反射操作属性

public class test09  {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName ("testReflection.User");
        //通过反射操作属性
        User user4 = (User)c1.newInstance();
        Field name = c1. getDeclaredField( "name") ;
        //在User类中，name属性是private修饰，不能直接操作私有属性
        //我们需要关闭程序的安全检测，将属性或者方法的setAccessible(true)，设置成公有性质.
        name.setAccessible(true);
        name.set(user4,"BBB") ;
        System.out.println(user4.getName());
    }
}

运行结果：

setAccessible介绍：

1. Method和Field、Constructor对象都有setAccessible()方法。setAccessible作用是启动和禁用访问安全检查的开关。
2. 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。参数值为false则指示反射的对象应该实施Java语言访问检查
3. 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。使得原本无法访问的私有成员也可以访问

反射操作泛型

Java采用泛型擦除的机制来引入泛型, Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题,但是,一旦编译完成,所有和泛型有关的类型全部擦除。
为了通过反射操作这些类型, Java新增了ParameterizedType , GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。

1. ParameterizedType :表示一种参数化类型,比如Collection< String>；
2. GenericArrayType :表示一种元素类型是参数化类型或者类型变量的数组类型；
3. TypeVariable : 是各种类型变量的公共父接口；
4. WildcardType :代表一种通配符类型表达式。

//通过反射获取泛型
public class test11 {
    public void test01 (Map<String,User> map, List<User> list){
        System. out. println("test01");
    }
    public Map<String,User> test02(){
        System. out . println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        //首先，获取方法，通过该方法获取泛型的参数化类型
        Method method = test11.class.getMethod("test01", Map.class, List.class) ;
        Type[] genericParameterTypes = method.getGenericParameterTypes() ;
        for (Type genericParameterType : genericParameterTypes){
            System.out.println("test01泛型参数类型："+ genericParameterType);
            //判断是不是一个参数化类型，是，就进行强转成参数化类型
            if (genericParameterType instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments){
                    System.out.println("test01泛型参数信息："+actualTypeArgument);
                }
            }
        }

        method = test11.class.getMethod("test02", null);
        Type genericParameterType = method.getGenericReturnType();
        if (genericParameterType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments){
                System.out.println("test02泛型参数信息："+actualTypeArgument);
            }
        }
    }
 }

运行结果：

反射操作注解

//反射操作注解
public class test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("testReflection.Student2");

        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations){
            System.out.println(annotation);
        }
        System.out.println("===========================================");

        //获得注解的value值
        TableSky tableSky = (TableSky)c1.getAnnotation(TableSky.class);
        String value = tableSky.value();
        System.out.println(value);
        System.out.println("===========================================");

        //获得类指定的注解
        Field field = c1.getDeclaredField("id");
        FieldSky annotation =field.getAnnotation(FieldSky.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
@TableSky("db_SKY")
class Student2{
    @FieldSky(columnName = "db_id",type="int",length=10)
    private int id;
    @FieldSky(columnName = "db_age",type="int",length=10)
    private int age;
    @FieldSky(columnName = "db_name",type="varchar",length=5)
    private String name;

    public Student2() {
    }

    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    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;
    }

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

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableSky{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldSky{
    String columnName();
    String type();
    int length();
}

运行结果：