类型信息（4）：类型转换前检查（下）

布满荆棘的人生 2023-07-12 05:16 6阅读 0赞

### 一、使用类字面常量 ###

如果我们用类字面常量重新实现PetCount，那么改写后的结果在许多方面都会显得更加清晰：

import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    
    public class LiteralPetCreator extends PetCreator {
    
    	public static final List<Class<? extends Pet>> allTypes = Collections
    			.unmodifiableList(Arrays.asList(Pet.class, Dog.class, Cat.class, Rodent.class, Mutt.class, Pug.class,
    					EgyptianMau.class, Manx.class, Cymric.class, Rat.class, Mouse.class, Hamster.class));
    	private static final List<Class<? extends Pet>> types = allTypes.subList(allTypes.indexOf(Mutt.class),
    			allTypes.size());
    
    	@Override
    	public List<Class<? extends Pet>> types() {
    		return types;
    	}
    
    	public static void main(String[] args) {
    		System.out.println(types);
    	}
    }

在即将出现的PetCount3.java示例中，我们需要先用所有的Pet类型来预加载一个Map（而仅仅只是那些将要随机生成的类型），因此allTypes List是必需的。types列表是allTypes的一部分（通过使用List.subList()创建的），它包含了确切的宠物类型，因此它被用于随机Pet生成。

这一次，生成types的代码不需要放在try块内，因为它会在编译时得到检查，因此，它不会抛出任何异常，这与Class.forName()不一样。

我们现在在typeinfo.pets类库中有了两种PetCreator的实现。为了将第二种实现作为默认实现，我们可以创建一个使用了LiteralPetCreator的外观：

import java.util.ArrayList;
    
    public class Pets {
    	public static final PetCreator creator = new LiteralPetCreator();
    
    	public static Pet randomPet() {
    		return creator.randomPet();
    	}
    
    	public static Pet[] createArray(int size) {
    		return creator.createArray(size);
    	}
    
    	public static ArrayList<Pet> arrayList(int size) {
    		return creator.arrayList(size);
    	}
    }

这个类还提供了对randomPet()、createArray()和arrayList()的间接调用。

因为PetCount.countPets()接受的是一个PetCreator参数，我们可以很容易地测试LiteralPetCreator（通过上面的外观）：

import typeinfo.pets.Pets;
    
    public class PetCount2 {
    	public static void main(String[] args) {
    		PetCount.countPets(Pets.creator);
    	}
    }

该示例的输出与PetCount.java相同。

### 二、动态的instanceof ###

Class.isInstance方法提供了一种动态地测试对象的途径。于是所有那些单调的instanceof语句都可以从PetCount.java的例子中移除了。如下所示：

import java.util.LinkedHashMap;
    import java.util.Map;
    
    import typeinfo.pets.LiteralPetCreator;
    import typeinfo.pets.Pet;
    import typeinfo.pets.Pets;
    
    public class PetCount3 {
    	static class PetCounter extends LinkedHashMap<Class<? extends Pet>, Integer> {
    		public PetCounter() {
    			super(MapData.map(LiteralPetCreator.allTypes, 0));
    		}
    
    		public void count(Pet pet) {
    			for (Map.Entry<Class<? extends Pet>, Integer> pair : entrySet())
    				if (pair.getKey().isInstance(pet))
    					put(pair.getKey(), pair.getValue() + 1);
    		}
    
    		public String toString() {
    			StringBuilder result = new StringBuilder("{");
    			for (Map.Entry<Class<? extends Pet>, Integer> pair : entrySet()) {
    				result.append(pair.getKey().getSimpleName());
    				result.append("=");
    				result.append(pair.getValue());
    				result.append(",");
    			}
    			result.delete(result.length() - 2, result.length());
    			result.append("}");
    			return result.toString();
    		}
    	}
    
    	public static void main(String[] args) {
    		PetCounter petCount = new PetCounter();
    		for (Pet pet : Pets.createArray(20)) {
    			System.out.print(pet.getClass().getSimpleName() + " ");
    			petCount.count(pet);
    		}
    		System.out.println();
    		System.out.println(petCount);
    	}
    }

为了对所有不同类型的Pet进行计数，PetCounter Map预加载了LiteralPetCreator.allTypes中的类型。这使用了MapData类，这个类接受一个Iteralbe(allTypes List)和一个常数类型（本例中是0），然后用allTypes中元素作为键，用0作为值，来填充Map。如果不预加载这个Map，那么你最终将只能对随机生成的类型进行计数，而不包括诸如Pet和Cat这样的基类型。

可以看到，isInstance()方法使我们不再需要instanceof表达式。此外，这意味着如果要求添加新类型的Pet，只需简单地改变LiteralPetCreator.java数组即可；而无需改动程序其他部分（但是在使用instanceof时这是不可能的）。

toString()方法已经被重载，使得输出更容易被读取，而该输出与打印Map时所看到典型输出仍然是匹配的。

### 三、递归计数 ###

在PetCount3.PetCounter中的Map预加载了所有不同的Pet类。与预加载映射表不同的是，我们可以使用Class.isAssignableFrom()，并创建一个不局限于对Pet计数的通用工具。

import java.util.HashMap;
    import java.util.Map;
    
    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 + "incorrect type: " + type + ", should be type or subtype of" + 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);
    	}
    
    	public String toString() {
    		StringBuilder result = new StringBuilder("{");
    		for (Map.Entry<Class<?>, Integer> pair : entrySet()) {
    			result.append(pair.getKey().getSimpleName());
    			result.append("=");
    			result.append(pair.getValue());
    			result.append(", ");
    		}
    		result.delete(result.length() - 2, result.length());
    		result.append("}");
    		return result.toString();
    	}
    }

count()方法获取其参数的Class，然后使用isAssignableFrom()来执行运行时检查，已校验你传递的对象确实属于我们感兴趣的继承结构。countClass()首先对该类的确切类型计数，然后，如果其超类可以赋值给baseType，countClass()将其超类上递归计数。

import typeinfo.pets.Pet;
    import typeinfo.pets.Pets;
    
    public class PetCount4 {
    	public static void main(String[] args) {
    		TypeCounter counter = new TypeCounter(Pet.class);
    		for (Pet pet : Pets.createArray(20)) {
    			System.out.print(pet.getClass().getSimpleName() + " ");
    			counter.count(pet);
    		}
    		System.out.println();
    		System.out.println(counter);
    	}
    }

正如在输出中看到的那样，对基类型和确切类型都进行了计数。

**如果本文对您有很大的帮助，还请点赞关注一下。**