66.【注解与反射】（二）

1.静态语言:
是一类与动态语言相对的，"运行的时候不可以改变的语言就是静态语言" java不是
动态语言，但是java可以称之为"准动态语言" ----->反射机制
eg:  java c c++
2.动态语言:
是一类在"运行时可以改变其结构的语言",比如新的代码、函数、对象可以引入。
eg: JavaScript

1.Reflection(反射)是java被视为动态语言的关键，反射机制允许程序在执行
期借助于Reflection API获取任何类的内部信息，并且能直接操作任意对象的
内部属性及方法.
"class c=Class.forName("java.lang.String")"
2.加载完类之后，在堆内存的方法区中就产生了一个class类型的对象(一个类只有
一个class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象
看到类的结构。"这个对象就像一面镜子，通过这个镜子看到类的结构，我们称之为"
"反射"

java反射机制提供的功能
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行的时候判断任意一个类的所具有的成员变量和方法
4.在运行时获取泛型信息
5.在运行时调用任意一个对象的成员变量和方法
6.在运行时处理注解
7.生成动态代理
.....
优点:
1.可以实现动态创建对象和编译，体现出很大的灵活性
缺点:
对性能有影响:使用反射基本上是一种解释操作。

通过反射获取对象:
1.
"class c=Class.forName("java.lang.String")"
"并且对象有且只有一个 （就是只有一个值）"
一个类被加载后，类的整个结构都会被封装在class对象中
2.
Class c=person.getClass()

package com.Kuang.reflectiom;
public class Demo5 {
    public static void main(String[] args) throws ClassCastException {
        //通过反射获取类的class对象
        try {
            Class aClass_one = Class.forName("com.Kuang.reflectiom.User");
            System.out.println(aClass_one);
            //一个类在内存中只有一个class对象
            //一个类被加载后，类的整个结构都会被封装在class对象中
            Class aClass_2 = Class.forName("com.Kuang.reflectiom.User");
            Class aClass_3 = Class.forName("com.Kuang.reflectiom.User");
            Class aClass_4 = Class.forName("com.Kuang.reflectiom.User");
            System.out.println(aClass_2.hashCode());
            System.out.println(aClass_3.hashCode());
            System.out.println(aClass_4.hashCode());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
//实体类 pojo,entity
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;
    }
}

反射:  通过class对象得出来类
非反射:   通过类得出来对象

1.对象通过反射可以得到的信息:
(1).类的属性
(2).方法 
(3).构造器。
2.详解:
(1).class 本身也是一个类
(2).class 对象只能由系统建立对象
(3).一个加载的类在jvm中只会有一个class实列
(4).每个类的实列都会记得自己是由哪个class实列所生成的
(5).通过class可以完整的得到一个类中的所有被加载的结构
(6).class是reflection的根源，针对任何你想动态加载、运行的类，唯有先
获得相应的class对象
(7).一个class对象对应的是一个加载到jvm中的一个class文件

方式1: 通过对象获得
        Class c1=person.getClass();
方式2: forName获得 
    Class<?> aClass = Class.forName("com.Kuang.reflectiom.Student"); 
方式3:通过类名.class获得
        Class studentClass = Student.class;      

package com.Kuang.reflectiom;
public class Demo6 {
    public static void main(String[] args) {
        Person person=new Student();
        System.out.println("这个人是:"+person.name);
        //方式1: 通过对象获得
        Class c1=person.getClass();
        System.out.println(c1.hashCode());
        //方式2: forName获得
        try {
            Class<?> aClass = Class.forName("com.Kuang.reflectiom.Student");
            System.out.println(aClass.hashCode());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //方式3:通过类名.class获得
        Class studentClass = Student.class;
        System.out.println(studentClass.hashCode());
        Class superclass = c1.getSuperclass();  //得到父类
        System.out.println(superclass);
    }
}
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="李老师";
    }
}

记住在一个程序中只有一个class对象，就是说一个类型不管数据怎么变化
class对象是不会变的。

package com.Kuang.reflectiom;
import java.lang.annotation.ElementType;
public class Demo7 {
    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;   //空型
        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);
    }
}