JAVA--反射Reflection | 泛型

1. 应用场景

通过外部文件配置，在不修改源码情况下，来控制程序，符合设计模式的ocp原则（开闭原则：不修改源码，开扩容功能）

2. 允许程序在执行期借助于ReflectionAPI取得任何类的内部信息，并能操作对象的属性及方法。

3. 实现：

加载完类之后，堆中产生一个Class类型对象，此对象包含了类的完整结构信息，通过这个对象得到类的结构，从而实现调用类。

4.

5. 反射机制的功能：

5.1 运行时判断任意一个对象所属的类

5.2 运行时构造任意一个类的对象

5.3 运行时得到任意一个类所具有的成员变量和方法

5.4 运行时调用任意一个对象的成员变量和方法

5.5 生成动态代理

6. 反射相关类

java.lang.Class
//代表一个类，Class对象表示某个类加载后在堆中的对象
java.lang.reflect.Method
//代表类的方法
java.lang.reflect.Field
//代表类的成员变量
java.lang.reflect.Constructor
//代表类的构造方法

7.反射优缺点

7.1 优：灵活

7.2 缺：运行时间太长

优化：在反射调用方法时，取消访问检查(效果不明显)

---

class类

1.静态加载和动态加载

静态加载在编译阶段就会加载类，如类对象实例化，依赖性强

动态加载 反射是动态加载类，在具体需要执行时才会加载类

1.1 类加载的四个时机：

创建对象、子类被加载、调用类的静态成员、通过反射

1.2 对于某个类的Class对象，在内存中只有一份，因为类只加载一次。可通过加载HashCode验证。

Class cls1 = Class.forName("com.alan.Dog");
Class cls2 = Class.forName("com.alan.Dog");
System.out.println(cls1.hashCode());
System.out.println(cls2.hashCode());

2. Class类方法

public class Class01 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        //Dog dog = new Dog();
        Class cls = Class.forName("com.alan.Dog");
        System.out.println(cls);  //得到对象所属类,class com.alan.Dog
        System.out.println(cls.getClass());  //得到运行类型，class.java.lang.Class
        System.out.println(cls.getPackage().getName());  //得到包名
        System.out.println(cls.getName());  //得到全类名
        Dog dog = (Dog)cls.newInstance();
        //通过反射获取属性,必须是public属性
        Field name = cls.getField("name");
        System.out.println(name.get(dog));
        //通过反射给属性赋值,必须是public属性
        name.set(dog, "xiaodudu");
        System.out.println(name.get(dog));
        //得到所有的属性，即属性列表
        Field[] fields = cls.getFields();
        for(Field f : fields) {
            System.out.println(f.getName());
        }
    }
}

---

泛型

1.泛型的应用

1.1 泛型可以保证加入集合中的元素类型为指定类型(只能是引用类型)

1.2 默认给定的泛型是Object

1.3 静态方法中不能使用类的泛型

1.4 使用泛型的数组不能初始化，因为不确定类型无法分配内存空间

public class demo {
    public static void main(String[] args) {
        Person<String> a = new Person<String>("alan");
        //指定s的类型为String
        a.show();
        //class java.lang.String
        Person<Integer> b = new Person<Integer>(100);
        b.show();
        //class java.lang.Integer
    }
}
class Person<T> {
    private T s;
    //属性s的类型为泛型
    //可以指定多个泛型<T,P,Q>
    public Person(T s) {
        this.s = s;
    }
    public void show() {
        System.out.println(s.getClass());
    }
}

2. 泛型类

2.1泛型可以在编译阶段为一个实例化的类指定属性类型，对数据类型进行约束

2.2 若实例化类时泛型指定后只能按指定的类型设置实例的属性，若不指定（一个都不可以指定），则泛型默认为Object类，任何类型都可以设置为属性。

3. 自定义泛型接口

4.泛型方法：分为普通类的泛型方法和泛型类的泛型方法

注：区分使用（类）泛型的方法和类的泛型方法

5. 泛型不具有继承性

List<Object> list_ = new ArrayList<String>();
//错误，虽然String是Object的子类，但泛型不能继承 
List<Object> list = new ArrayList<Object>();
//通过编译，泛型不能继承，但类可以

6. 泛型的通配符

List<? extends A> a = new List<? extends A>();
//接受A以及A的所有子类
//extends表示类的上限
List<? super B> b = new List<? super B>();
//接受B以及B的所有父类，包括间接父类
//super表示类的下限