反射、泛型
反射
反射通过字节码文件找到其类中的方法和属性。
- 获取方法：
-
通过字面量直接获取，例如XXX.class，不会触发类的初始化但XXX类已经被加载到方法区。
-
通过Object类的getClass方法，例如Object.getClass()。触发类的初始化
-
通过Class的静态方法，例如Class.forName()。触发类的初始化
// 方式一 类.class Class personClazz = Person.class; // 方式二 实例.getClass() Person person = new Person(); Class personClazz1 = person.getClass(); // 方式三 Class.forName("类的全路径") Class personClazz2 = Class.forName("com.muse.reflect.Person");
-
通过构造方法创建对象，并设置值
/** 首先：获得Person的字节码 */ Class personClazz = Class.forName("com.muse.reflect.Person"); /** 其次：通过Class对象，创建构造方法对象 */ Constructor constructor1 = personClazz.getConstructor(String.class, Integer.class, Byte.class, Boolean.class); // 初始化有参构造方法对象 Constructor constructor = personClazz.getConstructor(); // 初始化无参构造方法 /** 最后：通过构造方法创建对象 */ // 调用无参数构造方法创建Person对象 Person person = (Person) constructor.newInstance(); person.setName("muse1"); System.out.println("person=" + person); // 调用有参数构造方法创建Person对象 Person person1 = (Person) constructor1.newInstance("muse1", 10, (byte) 1, true); System.out.println("person1=" + person1); -
获得属性值
- getField 只能获取public的，包括从父类继承来的字段。
- getDeclaredField 可以获取本类所有的字段，包括private的，但是不能获取继承来的字段。 (注： 这里只能获取到private的字段，但并不能访问该private字段的值,对于其他访问修饰符，看当前类和访问的类所处的关系
- 除非加上setAccessible(true))
// 第一步：获得Class Class personClazz = Person.class; // 第二步：获得构造方法 Constructor<Person> constructor = personClazz.getConstructor(); Person person = constructor.newInstance(); // 第三步：通过Class对象，获得Field对象 Field sexField = personClazz.getDeclaredField("sex"); sexField.setAccessible(true); // 第四步：操作Field，获得属性值 System.out.println(sexField.get(person));
泛型
泛型本质是指类型参数化。
允许在定义类、接口、方法时使用类型形参，当使用时 指定具体类型。 所有使用该泛型参数的地方都被统一化，保证类型一致。 如果未指定具体类型，默认是Object类型。集合体系中 的所有类都增加了泛型，泛型也主要用在集合。
- 泛型类
class InterImpl2<T> {}
- 泛型方法
public <T> void show(T t) {}
- 泛型通配符
- List 可以接收任意类型的List,,不能调用与类型相关的方法，运行错误
- List<Object> 只能接收List<Object>
- List<?> 可以接收任意类型的List,不能调用与类型相关的方法，编译错误
- List
可以接收任意类型的List,,不能调用与类型相关的方法，运行错误
public class TypeWildcard {
private final static List<Integer> LIST_INTEGER = Arrays.asList(1, 2, 3, 4);
private final static List<Object> LIST_OBJECT = Arrays.asList(1, 2, 3, 4);
private final static List<String> LIST_STRING = Arrays.asList("a", "b", "c", "d");
public static void main(String[] args) {
TypeWildcard typeWildcard = new TypeWildcard();
typeWildcard.test1(LIST_OBJECT);
// typeWildcard.test2(LIST_STRING);
typeWildcard.test2(LIST_OBJECT);
typeWildcard.test3(LIST_INTEGER);
typeWildcard.test4(LIST_INTEGER);
/**上限通配符*/
typeWildcard.test5(LIST_INTEGER);
// typeWildcard.test5(LIST_STRING);
/**下限通配符*/
}
public void test1(List list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
public void test2(List<Object> list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
public void test3(List<?> list) {
for (int i = 0; i < list.size(); i++) {
// list.add(list.get(0)); // 编译错误
System.out.println(list.get(i));
}
}
public <T> void test4(List<T> list) {
for (int i = 0; i < list.size(); i++) {
// list.add(list.get(0)); // 编译阶段ok，但是运行时抛异常，Exception in thread "main" java.lang
// .UnsupportedOperationException
System.out.println(list.get(i));
}
}
public void test5(List<? extends Number> list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
- 泛型的上限
- 格式：类型名称 <? extends 类> 对象名称
- 意义：不能存，只能往外取，用该类接收
- 泛型的下限
- 格式：类型名称 <? super 类> 对象名称
- 意义：只能存该类或者父类，但往外取只能放在Object对象里
/**
* PECS(Producer Extends Consumer Super)
*
* https://www.cnblogs.com/huoqm/p/13931363.html
*/
public class Pecs {
/**
* 【读取】
* 如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
*/
public void testPECSextends() {
List<Dog> dogs = Lists.newArrayList();
dogs.add(new Dog());
List<? extends Animal> animals = dogs;
/**
* animals是一个Animal的子类的List,由于Dog是Animal的子类，因此将dogs赋给animals是合法的，但是编译器会阻止将new Cat()加入animals。
* 因为编译器只知道animals是Animal的某个子类的List，但并不知道究竟是哪个子类，为了类型安全，只好阻止向其中加入任何子类。那么可不可以加入
* new Animal()呢？很遗憾，也不可以。事实上，不能够往一个使用了? extends的数据结构里写入任何的值。
*/
// animals.add(new Cat()); // 编译失败
// animals.add(new Animal()); // 编译失败
// animals.add(new Dog()); // 编译失败
/**
* 由于编译器知道它总是Fruit的子类型，因此我们总可以从中读取出Animal对象：
*/
Animal animal = animals.get(0);
// Dog dog = animals.get(0); // 编译失败
}
/**
* 【写入】
* 如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
* <p>
* 如果既要存又要取，那么就不要使用任何通配符。
*/
public void testPECSsuper() {
List<Animal> animals = Lists.newArrayList();
List<? super Dog> dogs = animals;
/**
* 这里的animals是一个Animal的超类（父类,superclass）的List。同样地，出于对类型安全的考虑，
* 我们可以加入Dog对象或者其任何子类（如WhiteDog）对象，
* 但由于编译器并不知道List的内容究竟是Dog的哪个超类，因此不允许加入特定的任何超类型。
*/
dogs.add(new Dog());
dogs.add(new WhiteDog());
// dogs.add(new Animal()); // 编译失败
// dogs.add(new Cat()); // 编译失败
// dogs.add(new Object()); // 编译失败
/**
* 而当我们读取的时候，编译器在不知道是什么类型的情况下只能返回Object对象，因为Object是任何Java类的最终祖先类。
*/
Object obj = dogs.get(0);
// Dog dog = dogs.get(0); // 编译失败
// Animal animal = dogs.get(0); // 编译失败
}
}
浙公网安备 33010602011771号