java基础--2反射

1、概念

1）动态语言

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

主要的动态语言有：Object-c、C#、JavaScript、PHP、Python等

2） 静态语言

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

Java不是动态语言，但是Java可以称为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制来获取类似于动态语言的 特性，Java的动态性让编程的时候更加灵活。
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法和属性；

3）Java反射的优缺点

• 优点：可以实现动态创建对象和编译，体现出很大的灵活性
• 缺点：对性能有影响。
  使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求，这类操作总是慢于直接执行相同的操作。也就是说new创建和对象，比反射性能更高

2、Class对象

• Class本身也是一个类
• Class对象只能由系统建立对象
• 一个加载的类在JVM中只会有一个Class实例
• 一个Class对象对应的是一个加载到JVM中的一个.class文件
• 每个类的实例都会记得自己是由哪个Class实例所生成
• 通过Class可以完整地得到一个类中所有被加载的结构
• Class类是Reflection的根源，针对任何你想动态加载、运行的类、唯有先获得相应的Class对象

1）Class类常用的方法

• ClassforName(String name)：返回指定类name的Class对象
• newInstance()：调用缺省构造函数，返回Class对象的一个实例
• getName()：返回此Class对象所表示的实体（类，接口，数组或void）的名称
• getSuperClass()：返回当前Class对象的父类Class对象
• getinterfaces()：返回当前对象的接口
• getClassLoader()：返回该类的类加载器
• getConstructors()：返回一个包含某些Constructor对象的数组
• getMethod(String name, Class… T)：返回一个Method对象，此对象的形参类型为paramsType
• getDeclaredFields()：返回Field对象的一个数组

2）获取对象实例的方法

• 若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
  • Class clazz = Person.class;
• 已知某个类的实例，调用该实例的getClass()方法获取Class对象
  • Class clazz = person.getClass()
• 已经一个类的全类名，且该类在类路径下，可以通过Class类的静态方法forName()获取，HIA可能抛出ClassNotFoundException
  • Class clazz = Class.forName(“demo01.Sutdent”)
• 内置数据类型可以直接通过 类名.Type
• 还可以利用ClassLoader

/**
 * Class类创建的方式
 *
 * @author: 陌溪
 * @create: 2020-03-29-9:56
 */
class Person {
    public String name;
    public Person() {
    }
    public Person(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person{
    public Student() {
        this.name = "学生";
    }
}

class Teacher extends Person {
    public Teacher() {
        this.name = "老师";
    }
}


public class ClassCreateDemo {
    public static void main(String[] args) throws ClassNotFoundException {

        Person person = new Student();
        System.out.println("这个人是：" + person.name);

        // 方式1：通过对象获得
        Class c1 = person.getClass();
        System.out.println("c1:" + c1.hashCode());

        //方式2：通过forName获得
        Class c2 = Class.forName("com.moxi.interview.study.annotation.Student");
        System.out.println("c2:" + c2.hashCode());

        // 方式3：通过类名获取（最为高效）
        Class c3 = Student.class;
        System.out.println("c3:" + c3.hashCode());

        // 方式4：基本内置类型的包装类，都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4.getName());

        // 方式5：获取父类类型
        Class c5 = c1.getSuperclass();
    }
}

3）哪些类型可以有Class对象

class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类

interface：接口

[]：数组

enum：枚举

annotation：注解@interface

primitive type：基本数据类型

void

/**
 * 获取Class的方式
 *
 * @author: 陌溪
 * @create: 2020-03-29-10:16
 */
public class GetClassDemo {
    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 java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class

同时需要注意，只要类型和维度一样，那就是同一个Class对象

int [] a = new int[10];
int [] b = new int[10];
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());

这两个的hashcode是一样的

3、使用方法

1）获取类的 Class 对象实例
·Class clz = Class.forName("com.zhenai.api.Apple");
2）根据 Class 对象实例获取 Constructor 对象
·Constructor appleConstructor = clz.getConstructor();
3）使用 Constructor 对象的 newInstance 方法获取反射类对象
·Object appleObj = appleConstructor.newInstance();
4）获取方法的 Method 对象
·Method setPriceMethod = clz.getMethod("setPrice", int.class);
5）利用 invoke 方法调用方法
·setPriceMethod.invoke(appleObj, 14);

完整代码：

/**
 * 通过反射获取对象
 *
 * @author: 陌溪
 * @create: 2020-03-29-12:43
 */
public class GetObjectByReflectionDemo {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {

        // 获取Class
        Class clazz = Class.forName("com.moxi.interview.study.annotation.User");

        // 构造一个对象，newInstance调用的是无参构造器，如果没有无参构造器的话，本方法会出错
//        User user = (User)clazz.newInstance();

        // 获取class的有参构造器
        Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class, int.class);
        User user2 = (User) constructor.newInstance("小溪", 10, 10);
        System.out.println(user2);


        // 通过反射调用普通构造方法
        User user3 = (User)clazz.newInstance();
        // 获取setName 方法
        Method setName = clazz.getDeclaredMethod("setName", String.class);
        // 执行setName方法，传入对象 和 参数
        setName.invoke(user3, "小白");
        System.out.println(user3);

        System.out.println("============");
        Field age = clazz.getDeclaredField("age");
        // 关闭权限检测,这样才能直接修改字段，因为 set方法不能直接操作私有变量
        age.setAccessible(true);
        age.set(user3, 10);
        System.out.println(user3);

    }
}

运行结果

User{name='小溪', id=10, age=10}
User{name='小白', id=0, age=0}
============
User{name='小白', id=0, age=10}

4、反射的应用

4.1反射操作注解

通过反射能够获取到 类、方法、字段。。。等上的注解

• getAnnotation
• getAnnotations

4.2框架生成对象

1）spring框架生成bean

2）ORM对象关系映射

ORM即为：Object relationship Mapping，对象关系映射

• 类和表结构对应
• 属性和字段对应
• 对象和记录对应

5、反射的原理

ava反射的原理:java类的执行需要经历以下过程，

0）编译:.java文件编译后生成.class字节码文件
**1）加载：**类加载器负责根据一个类的全限定名来读取此类的二进制字节流到JVM内部，并存储在运行时内存区的方法区，然后将其转换为一个与目标类型对应的java.lang.Class对象实例
2）连接：细分三步
验证：格式（class文件规范） 语义（final类是否有子类） 操作
准备：静态变量赋初值和内存空间，final修饰的内存空间直接赋原值，此处不是用户指定的初值。
解析：符号引用转化为直接引用，分配地址
3）初始化:有父类先初始化父类，然后初始化自己；将static修饰代码执行一遍，如果是静态变量，则用用户指定值覆盖原有初值；如果是代码块，则执行一遍操作。

Java的反射就是利用加载到jvm中的.class文件来进行操作的。
.class文件中包含java类的所有信息，可以使用反射获取class，然后进行各种操作。

6、反射和注解

注解的实现原理就是反射

1）什么是注解

• Annotation是JDK5.0开始引入的新技术
• Annotation的作用
  • 不是程序本身，可以对程序做出解释（这一点和注释没有什么区别）
  • 可以被其它程序，比如编译器读取
• Annotation的格式
  • 注解以 @注释名 在代码中存在的，还可以添加一些参数值
  • 例如：@SuppressWarnings(value = "unchecked")
• Annotation在那里使用？
  • 可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息
  • 通过反射机制变成实现对这些元数据的控制

2）内置注解

• @Override：定义在 java.lang.Override中，此注释只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明
• @Deprecated：定义在java.lang.Deprecated中，此注释可以用于修饰方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为它很危险，或者存在更好的选择
• @SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，与前面的两个注释不同，你需要额外添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择性的使用就好了。
  • @SuppressWarnings(“all”)
  • @SuppressWarnings(“unchecked”)
  • @SuppressWarnings(value={“unchecked”, “deprecation”})
  • …

3）元注解

元注解的作用就是负责注解其它注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其它annotation类型作说明。

这些类型和它们所支持的类在 java.lang.annotation包可以找到 @Target 、@Retention、@Documented、@Inherited

• @Target：用于描述注解的使用范围，即：被描述的注解可以在什么地方使用
• @Retention：表示需要什么保存该注释信息，用于描述注解的生命周期
  • 级别范围：Source < Class < Runtime
• @Document：说明该注解被包含在java doc中
• @Inherited：说明子类可以集成父类中的注解

示例

/**
 * 元注解
 *
 * @author: 陌溪
 * @create: 2020-03-28-22:57
 */
@MyAnnotation
public class MateAnnotationDemo {

}

/**
 * 定义一个注解
 */
@Target(value={ElementType.METHOD, ElementType.TYPE})  // target表示我们注解应用的范围，在方法上，和类上有效
@Retention(RetentionPolicy.RUNTIME)   // Retention：表示我们的注解在什么时候还有效，运行时候有效
@Documented   // 表示说我们的注解是否生成在java doc中
@Inherited   // 表示子类可以继承父类的注解
@interface MyAnnotation {

}

4）自定义注解

使用 @interface自定义注解时，自动继承了 java.lang.annotation.Annotation接口

• @interface 用来声明一个注解，格式：public @interface 注解名 {定义内容
• 其中的每个方法实际上是申明了一个配置参数
• 方法的名称j就是参数的类型
• 返回值类型就是参数的类型（返回值只能是基本数据类型，Class，String，enum）
• 通过default来申明参数的默认值
• 如果只有一个参数成员，一般参数名为 value
• 注解元素必须要有值，我们定义元素时，经常使用空字符串或者0作为默认值

/**
 * 自定义注解
 *
 * @author: 陌溪
 * @create: 2020-03-28-22:57
 */
public class MateAnnotationDemo {

    // 注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation(schools = {"大学"})
    public void test(){

    }

}

/**
 * 定义一个注解
 */
@Target(value={ElementType.METHOD, ElementType.TYPE})  // target表示我们注解应用的范围，在方法上，和类上有效
@Retention(RetentionPolicy.RUNTIME)   // Retention：表示我们的注解在什么时候还有效，运行时候有效
@Documented   // 表示说我们的注解是否生成在java doc中
@Inherited   // 表示子类可以继承父类的注解
@interface MyAnnotation {

    // 注解的参数：参数类型 + 参数名()
    String name() default "";

    int age() default 0;

    // 如果默认值为-1，代表不存在
    int id() default -1;

    String[] schools();
}