目录
转型前检查
构建例子：生成层次结构
优化Creator：使用类字面量
优化PetCounter：动态验证类型
更通用的递归计数
注册工厂
本笔记参考自： 《On Java 中文版》
转型前检查
当我们使用传统的类型转换，例如：
Object x = new Shape();
Shape s = (Shape)x; // 传统的类型转换此时Java就会执行反射，这种转型通常被称为“类型安全向下转型”。不同于向上转型，编译器不会知道这个Object实际的类型是什么。因此在向下转型时，我们需要声明对象的确切类型。
C++在这种强制类型转换时不会进行反射，而是进行“运行时类型识别”。告诉编译器，这是一个新的类型。
而除了这种类型转换和Class对象外，Java还提供了其他反射的方式：instanceof关键字。这一关键字可以用于判断对象是否是特定类型的实例，例如：
【例子：instanceof关键字的使用】
public class ClassInstanceof {
public static void main(String[] args) {
Object obj = new Circle();
if (obj instanceof Shape)
System.out.println("这个实例是一个Shape");
if (obj instanceof Circle)
System.out.println("这个实例是一个Circle");
if (obj instanceof Square)
System.out.println("这个实例是一个Square");
else
System.out.println("这个实例的类型不是Square");
}
}程序执行的结果是：
instanceof的存在使得程序员可以使用Java轻松识别出对象的正确类型。
---
构建例子：生成层次结构
为了方便后续的示例，这里先创建一个比较复杂的层次结构（人和宠物）：
在这一章的笔记中，只会使用到Pet类及其子类。但为了结构的完整性，这里展示的是整个继承结构。Individual作为所有类的基类，会被用到的部分只有其重写的toString()：
@Override
public String toString() {
return getClass().getSimpleName() +
(name == null ? "" : " " + name);
}
Pet及其子类的实现都较为简单，这里只选取其中一条分支进行展示（其他均与该分支相同）：
这些类都有一个无参构造器，这样我们就可以调用newInstacnce()来生成实例。下面的例子是一个用于随机生成Pet对象的工具类：
【例子：随机生成Pet对象】
package reflection.pets;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public abstract class Creator
implements Supplier<Pet> {
private Random random = new Random(47);
// types()方法用于创建不同的Pet对象，
// 我们要求这个方法必须在子类中进行实现
// （一般，这个方法只需要返回一个静态的List引用即可）
public abstract List<Class<? extends Pet>> types();
// 创建一个随机的Pet对象：
@Override
public Pet get() {
int n = random.nextInt(types().size());
try {
return types().get(n)
.getConstructor().newInstance();
// 调用newInstance()，会得到四个异常：
} catch (InstantiationException |
NoSuchMethodException |
InvocationTargetException |
IllegalAccessException e) {
throw new RuntimeException(e);
}
}
public Stream<Pet> stream() {
return Stream.generate(this);
}
public Pet[] array(int size) { // 调用上面的stream()方法
return stream().limit(size).toArray(Pet[]::new);
}
public List<Pet> list(int size) {
return stream().limit(size) // 将元素收集到一个ArrayList中
.collect(Collectors.toCollection(ArrayList::new));
}
}Creator是一个生成器的基类，它的types()是一个抽象方法，这样我们就可以要求Creator的基类去实现这个方法。这是一个模板方法模式的例子。值得一提的是，types()的返回类型被规定成一个包含Class对象的List，这个List可以接受Pet及其的任意子类。
接下来尝试为Creator实现一个子类：
【例子：使用forName()的生成器】
package reflection.pets;
import java.util.ArrayList;
import java.util.List;
public class ForNamePetCreator extends Creator {
// 应该确保：在类被初始化时，就向manyTypes列表中加载数据
// （也就是说，在类被加载时就应该调用loader()方法）
private static List<Class<? extends Pet>> manyTypes =
new ArrayList<>();
// 设置我们需要生成的类型：
private static String[] typeNames = {
// Dog的子类：
"reflection.pets.Mutt",
"reflection.pets.Pug",
// Cat的子类：
"reflection.pets.Chero",
"reflection.pets.Manx",
"reflection.pets.Cymric",
// Rodent的子类：
"reflection.pets.Rat",
"reflection.pets.Mouse",
"reflection.pets.Hamster"
};
@SuppressWarnings("unchecked")
private static void loader() {
try {
for (String name : typeNames)
manyTypes.add(
(Class<? extends Pet>) Class.forName(name));
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
static {
loader();
}
// types()方法只需要用于返回静态的List引用即可
@Override
public List<Class<? extends Pet>> types() {
return manyTypes;
}
}通过Class.forName()，我们就设置好的类的完全限定名全部录入到manyTypes列表中。因为我们放入forName()中的是在编译时无法被验证的字符串，因此它可以会报错。
需要提一下这里的静态初始化块：
static {
loader();
}由于@SuppressWarnings()不允许被直接用于静态初始化块，因此我们需要将loader()放入一个静态初始化块中。这样当类第一次被使用时，loader()就会被唯一一次调用，保证manyTypes()被正确初始化。
instanceof关键字可用于检测对象的类型，下面的例子会通过这一关键字完成对各种Pet类型的数量监控。因为需要反映各个类型与其数量之间的对应关系，所以我们可以使用Map：
【例子：监控各个Pet类型的数量】
package reflection;
import java.util.HashMap;
import reflection.pets.*;
// 用于跟踪各种类的Pet数量
public class PetCounter {
static class Counter extends HashMap<String, Integer> {
public void count(String type) {
// get()返回type映射的值，若type不在Map中，返回null
Integer quantity = get(type);
if (quantity == null) {
// 将键和值进行绑定
put(type, 1);
} else
put(type, quantity + 1);
}
}
private Counter counter = new Counter();
private void countPet(Pet pet) {
System.out.print(
pet.getClass().getSimpleName() + " ");
// 注意：instanceof只能与命名类型比较
if (pet instanceof Pet)
counter.count("Pet");
// 属于Dog的：
if (pet instanceof Dog)
counter.count("Dog");
if (pet instanceof Mutt)
counter.count("Mutt");
if (pet instanceof Pug)
counter.count("Pug");
// 属于Cat的：
if (pet instanceof Cat)
counter.count("Cat");
if (pet instanceof Chero)
counter.count("Chero");
if (pet instanceof Manx)
counter.count("Manx");
if (pet instanceof Cymric)
counter.count("Cymric");
// 属于Rodent的：
if (pet instanceof Rodent)
counter.count("Rodent");
if (pet instanceof Rat)
counter.count("Rat");
if (pet instanceof Mouse)
counter.count("Mouse");
if (pet instanceof Hamster)
counter.count("Hamster");
}
public void count(Creator creator) {
creator.stream().limit(20)
.forEach(pet -> countPet(pet));
System.out.println();
System.out.println(counter);
}
public static void main(String[] args) {
new PetCounter().count(new ForNamePetCreator());
}
}程序执行的结果是：
这个例子体现了instanceof的局限性：通过这一关键字，一个对象只能与命名类型进行比较，而不能与一个Class对象进行比较。这意味着，我们不能将我们需要比对的类型放入一个Class数组中，再通过循环等方式实现instanceof的自动化。
不过，若代码中存在很多instanceof，这个代码可能也是存在问题的。
优化Creator：使用类字面量
可以使用类字面量的方式优化Creator，通过这种方式实现的Creator会更加清晰：
【例子：重新实现Creator】
package reflection.pets;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
// 使用字类面量重新实现Creator
public class PetCreator extends Creator {
// 因为使用的是字面量，所以不需要生成实例
public static final
List<Class<? extends Pet>> ALL_TYPES =
Collections.unmodifiableList(Arrays.asList(
Pet.class, Dog.class, Cat.class, Rodent.class,
Mutt.class, Pug.class,
Chero.class, Manx.class, Cymric.class,
Rat.class, Mouse.class, Hamster.class
));
// 进行类型的随机生成（限定：只生成子类）
private static final
List<Class<? extends Pet>> TYPES =
ALL_TYPES.subList(
ALL_TYPES.indexOf(Mutt.class),
ALL_TYPES.size());
@Override
public List<Class<? extends Pet>> types() {
return TYPES;
}
public static void main(String[] args) {
System.out.println(TYPES);
List<Pet> pets = new PetCreator().list(7);
System.out.println(pets);
}
}程序执行的结果是：
因为使用的是字面量的缘故，不会用到newInstance()进行实例生成。也因此省去了处理异常的功夫。
ALL_TYPES包含了所有的Pet类型，方便任何继承了这个类的子类进行使用。而types()返回的TYPES则包含了所有确切的宠物类型，因此可用于生成随机的Pet。
Collections.unmodifiableList()会根据传入的原始列表返回一个只读视图，其空间开辟在堆上。Java 9还加入了一个List.of()方法，这个方式生成的视图存在于内存中，因此速度会更快一点。
因为之前的PetCounter.count()接受的是一个Creator参数，因此我们也可以使用它来测试这个新的PetCreator：
【例子：测试PetCreator】
package reflection;
import reflection.pets.PetCreator;
public class PetCounter2 {
public static void main(String[] args) {
new PetCounter().count(new PetCreator());
}
}程序执行的结果是：
优化PetCounter：动态验证类型
很显然，PetCounter中的instanceof过于冗长，而Class.isInstance()提供了一种更好的方式动态验证对象的类型，可以用它替代PetCounter中的instanceof：
【例子：使用isInstance()】
package reflection;
import onjava.Pair;
import reflection.pets.Pet;
import reflection.pets.PetCreator;
import java.util.HashMap;
import java.util.stream.Collectors;
public class PetCounter3 {
static class Counter
extends HashMap<Class<? extends Pet>, Integer> {
Counter() {
super(PetCreator.ALL_TYPES.stream()
.map(type -> Pair.make(type, 0)) // 将所有的Pet类型的计数初始化为0
.collect(
Collectors.toMap(Pair::key, Pair::value)));
}
public void count(Pet pet) {
// 使用Cass.isInstance()消除instanceof
entrySet().stream() // entrySet()：返回由包含在这个Map视图中的元素决定的Set视图
.filter(pair -> pair.getKey().isInstance(pet))
.forEach(pair ->
put(pair.getKey(), pair.getValue() + 1));
}
@Override
public String toString() {
String result = entrySet().stream()
.map(pair -> String.format("%s=%s",
pair.getKey().getSimpleName(),
pair.getValue()))
.collect(Collectors.joining(", "));
return "{" + result + "}";
}
}
public static void main(String[] args) {
Counter petCount = new Counter();
new PetCreator().stream()
.limit(20)
.peek(petCount::count) // 对每个流元素进行计数
.forEach(p -> System.out.print(
p.getClass().getSimpleName() + " "));
System.out.println("\n" + petCount);
}
}程序执行的结果是：
isInstance()的使用使得我们不再需要使用instanceof。
为了能够为所有的Pet类型计数，就需要在创建类的时候预加载所有的Pet类。因此内部类Counter就需要在其创建的时候将所有类型进行加载，这就用到了之前设置的ALL_TYPES。也因此，只需要修改ALL_TYPES就可以增删类型。
更通用的递归计数
上一个例子需要在使用前加载所有的Pet类型，但我们也可以使用isAssignableFrom()方法来替代这一预加载过程，在方法执行时对每一个将要计数的对象进行类型判断。这样，我们就可以获得一个更加通用的计数方法：
【例子：对某一类型的实例进行计数】
package onjava;
import java.util.HashMap;
import java.util.stream.Collectors;
public class TypeCounter
extends HashMap<Class<?>, Integer> {
private Class<?> baseType;
public TypeCounter(Class<?> baseType) {
this.baseType = baseType;
}
public void count(Object obj) {
Class<?> type = obj.getClass();
if (!baseType.isAssignableFrom(type))
throw new RuntimeException(
obj + "是一个错误的类型：" + type +
"，应该传入" + baseType + "或其的子类");
countClass(type);
}
// 先对基类进行计数。若存在父类，则递归调用自身，对父类进行计数。
private void countClass(Class<?> type) {
Integer quantity = get(type);
put(type, quantity == null ? 1 : quantity + 1);
Class<?> superClass = type.getSuperclass();
if (superClass != null &&
baseType.isAssignableFrom(superClass)) {
countClass(superClass);
}
}
@Override
public String toString() {
String result = entrySet().stream()
.map(pair -> String.format("%s=%s",
pair.getKey().getSimpleName(),
pair.getValue()))
.collect(Collectors.joining(", "));
return "{" + result + "}";
}
}isAssignableFrom()方法用于验证传递的对象是否存在于要求的层次结构中。
在上述的类中，countClass()方法就是用于递归计数的，它在完成子类的计数后会进行判断，若存在父类，则对父类进行计数。
现在，可以使用上面的类了：
【例子：使用TypeCounter】
package reflection;
import onjava.TypeCounter;
import reflection.pets.Pet;
import reflection.pets.PetCreator;
public class PetCounter4 {
public static void main(String[] args) {
TypeCounter counter = new TypeCounter(Pet.class);
new PetCreator().stream()
.limit(20)
.peek(counter::count)
.forEach(pet -> System.out.print(
pet.getClass().getSimpleName() + " "));
System.out.println("\n" + counter);
}
}程序执行的结果如下：
注册工厂
在上述例子实现Creator的时候，还存在一个问题：
若需要为Pet添加一个新的子类，就需要在Creator的实现（PetCreator等）中添加对应的类型。若我们需要较为频繁地添加子类，这就会给我们造成一定的麻烦。
对于这种情况，一般有两种做法：
- 手动创建列表，并将这个列表放在较为核心的代码部分，例如基类之中。
- 使用工厂方法设计模式推迟对象的创建，将创建交付给类自己去完成。工厂方法可以被多态地调用，来创建恰当类型的对象。
java.util.function.Supplier的T get()方法就是一个工厂方法的原型。这一方法可以通过协变返回类型（基类方法返回值的子类型）完成对象的返回。
下面的示例包含一个工厂对象（Supplier<Part>）的静态List：
【例子：使用工厂方法进行注册】
package reflection;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Stream;
class Part implements Supplier<Part> {
@Override
public String toString() {
return getClass().getSimpleName();
}
static List<Supplier<? extends Part>> prototypes =
Arrays.asList( // 将类型的工厂类添加到列表中，完成“注册”
new FuelFilter(),
new AirFilter(),
new CabinAirFilter(),
new OilFilter(),
new FanBelt(),
new PowerSteeringBelt(),
new GeneratorBelt());
private static Random rand = new Random(47);
@Override
public Part get() {
int n = rand.nextInt(prototypes.size());
// 第一个get(n)调用自Arrays
// 第二个get()才是Supplier的
return prototypes.get(n).get();
}
}
// 分类器，不存在实现
class Filter extends Part {
}
class FuelFilter extends Filter {
@Override
public FuelFilter get() {
return new FuelFilter();
}
}
class AirFilter extends Filter {
@Override
public AirFilter get() {
return new AirFilter();
}
}
class CabinAirFilter extends Filter {
@Override
public CabinAirFilter get() {
return new CabinAirFilter();
}
}
class OilFilter extends Filter {
@Override
public OilFilter get() {
return new OilFilter();
}
}
// 分类器，不存在实现
class Belt extends Part {
}
class FanBelt extends Belt {
@Override
public FanBelt get() {
return new FanBelt();
}
}
class GeneratorBelt extends Belt {
@Override
public GeneratorBelt get() {
return new GeneratorBelt();
}
}
class PowerSteeringBelt extends Belt {
@Override
public PowerSteeringBelt get() {
return new PowerSteeringBelt();
}
}
public class RegisteredFactories {
public static void main(String[] args) {
Stream.generate(new Part())
.limit(10)
.forEach(System.out::println);
}
}程序执行的结果是：
先观察列表prototypes：
这些子类原本都应该由get()方法进行生成，它们的工厂类都被添加到了列表中，通过这种方式，我们完成了“注册”。这些工厂是对象本身的实例，在实际操作中，它们会作为生成其他对象的模板进行使用。
这些对象就好比一个一个的工厂，它们会分别生产不同的“零件”。通过调用这些类的方法，我们就可以进行“零件”的生产。
上述的Filter和Belt用于对不同的“零件”进行分类，因此它们不需要具体的实现。
这种做法的好处可以在main()方法中看见：由于Part类的get()方法可以生成各种各样的零件，我们仅需创建Part对象就可以控制各个“零件”的生产。
