Java编程思想——类型信息（RTTI）
一、概念
编译时已知的到所有的类型：就是在写代码阶段就确定是这个类型了，当运行程序的时候，类型是不可改变的
举例：List<String> str = new ArrayList(); //运行时就无法改变其类型
运行时使用其他类型：就是运行程序的时候，可以根据代码改变其类型
Class c = Class.fromName(String className);//传入不同的className获取不同的对象
二、RTTI
定义：
RTTI（Run-Time Type Identification，通过运行时类型识别）的含义
就是在运行时识别一个对象的类型，其对应的类是Class对象，每个java里面的类都对应一个Class对象(在编写并且编译后)，这个对象被保存在这个类的同名class文件里。
2、支持向上转型和向下转型：如“(Apple)Fruit”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个 ClassCastException异常。
3、判定是否为同一类别：通过关键字instanceof。
所以说：在编译时必须知道一个非常重要的东西：类名(甚至是全类名)
举例：
//假设Shape类，含有子类Circle类、Rectange类 List<Shape> list = new ArrayList(); list.add(new Circle()); list.add(new Rectange()); //根据RTTI会先识别Circle类，然后寻找对应的Class,进行编译 //因为容器都是将类型当做Object类持有，当取出对象的时候RTTI会将Object转换为泛型的类，也就是Shape，而不是转换为更彻底的Cirlcle类
类加载器在类被第一次static调用(比如一个静态方法，一个静态代码块或者new关键字调用构造器，注意构造器contructors其实都是静态的)时会把那个对应的Class对象加载到内存中。（运行时创建对象，而不是在编译时创建对象，这是和其他语言不一样的地方——比如说PHP就是先将类创建完成之后再运行的，所以类是先创建还是后创建的不影响逻辑顺序）
三、Class对象
JAVA可以使用Class对象执行RTTI，Class拥有大量使用RTTI的其他方法：
通过Class对象来获取对象的类型。如
Class c = Class.forName(“Apple”);
Object o = c.newInstance();
3.通过关键字instanceof或Class.isInstance()方法来确定对象是否属于某个特定类型的实例
1、java编译顺序详解
①、当编译了一个新类的时候，就会创建.class文件，为了生成这个类的对象，就运行程序的“JVM”(Java虚拟机)称为类加载器的子系统
②、程序中那么如何生成这个类的对象：
所有的类都是第一次被使用的时候，就会动态加载到JVM上，类加载器在类被第一次static调用的时候就会被加载（构造方法也是一个静态方法 所以 new A()就是调用static）
所以说，java程序是在需要的时候，才会加载，而不是在运行前完全加载。
③、类加载器的操作：类加载器首先会检查这个类是否被加载，如果未被加载就根据类名查找.class文件，然后经Class对象载入内存，之后就创建这个类中的所有对象。
注：
public class A{ static { //static 初始化 是在类加载时进行的 } }
2、Class类的使用
主要类：
public class UseClass { static void printfIn(Class cc){ String name = cc.getName();//获取Class类加包的名字 Boolean isInterface = cc.isInterface(); String simplyName = cc.getSimpleName();//获取类的名字 } public static void main(String [] args){ try { Class newClass = Class.forName("ClassLoaderTest");//获取相应对象 //获取该类继承的接口 for(Class face : newClass.getInterfaces()){ System.out.println(face.getName()); } Class classSuper = newClass.getSuperclass();//获取该类父类 Object object = newClass.newInstance(); //将Class对象创建为其所对应的对象(这里为ClassLoaderTest)，不过返回的是Object类型，需要向下转型为ClassLoaderTest类型 //原理：调用ClassLoader的默认的构造器，创建ClassLoaderTest对象。 printfIn(newClass); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); }//加载类 catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
创建类：
public class ClassLoaderTest { static { //当被加载的时候调用 System.out.println("My name is ClassLoader"); } }
根据得到的结果，当调用Class.forName("ClassLoaderTest");，会调用ClassLoaderTest的static{}域。
四、类字面常量
第三种生成Class对象的方法，举例：Class c = ClassLoaderTest.class;
与其他生成方法的区别：不会自动初始化该class对象。
延生（使用类而做的准备工作）：
①、加载。类加载器创建Class对象 ②、链接。分配存储空间 ③、初始化：初始化其父类，静态初始化块。
所以说：不会自动初始化意思就是，不会执行上诉的初始化工作，当只有第一次调用该类的静态域的时候才会被调用。
执行类：
public static void main(String [] args){ System.out.println(ClassLoaderTest.DATA+"");//没有进行初始化 System.out.println(ClassLoaderTest.TEST+"");//强制进行了初始化 //说明了加上了final表示，直接调用不会进行初始化。但也有例外比如说 System.out.println(ClassLoaderTest.DATA_ONE+"");//强制初始化，因为值不是编译期常量（是运行时的） try { Class c = ClassLoaderTest.class;//没有进行初始化 Class c1 = Class.forName("ClassLoaderTest");//强制进行初始化 new ClassLoaderTest();//调用默认构造器，强制进行初始化 } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); }
辅助类：
public class ClassLoaderTest { static final int DATA= 333; static final int DATA_ONE = new Random().nextInt(3); static int TEST = 333; static { //当被加载的时候调用 System.out.println("My name is ClassLoader"); } }
五、泛型的Class引用
使用：Class<?> class = int.class;
作用：在编译器进行类型检查。
注：？代表通配符，表示使用一个非具体的类型，Class<?>等价于Class，那么他的作用在哪里呢，需要加上extends才能体现的出来
public class ClassReferences { public static void main(String[]args){ //Integer继承自Number Class<? extends Number> bound = int.class;//这样就能够声明放入的是Number的子类 //但是错误的是:该泛型不支持向上转型，不像List那样。 Class<Number> intClass = int.class;//这种方式是会报错的 } }
第二个作用：class.newInstance()返回的是具体的类型，而不是Object类
public static void main(String[]args){ Class<ClassLoader> loader = ClassLoader.class;//类字面常量才能这么用 try { ClassLoader cl = loader.newInstance();//返回的是具体类型，而不是Object } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
六、RTTI的第三种用法：instanceof
使用 :if (xx instanceof Dog){
((Dog)x).bark();
}
实例，动态创建不同类型的宠物
假设：所有父类为Pet,所有动物为其子类
步骤：①、获取所有子类的Class对象放在List数组中，注意最好使用泛型，判定该动物是否继承Pet类 ②、通过Random随机获取List中的Class对象，然后通过newInstance()方法生成具体动物的对象。 ③、再放入新的List数组中。
实例：
模型类：
ublic abstract class PetCreator { //这里用到的模型模式，利用重写抽象方法获取种类的类型 public abstract List<Class<? extends Pet >> type () throws ClassNotFoundException; //随机取出List中的Class对象，初始化成具体类 public Pet randomPet() throws InstantiationException, IllegalAccessException, ClassNotFoundException{ Random random = new Random(); int index = random.nextInt(type().size()); return type().get(index).newInstance(); } //输入具体生成多少个动物，然后将random生成的对象，装入数组中 public Pet[] createPets(int size){ Pet[] pets = new Pet[size]; try { for (int i=0; i<size; ++i){ pets[i] = randomPet(); } } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } return pets; } //将数组中的东西，转换成List public ArrayList<Pet> getPetsList(int size){ ArrayList<Pet> arrList = new ArrayList(); Collections.addAll(arrList, createPets(size)); return arrList; } }
实现类：
public class ForNameCreator extends PetCreator{ private String[] forName = {"1","2","3","4"}; private List<Class<? extends Pet>> types; @Override public List<Class<? extends Pet>> type() throws ClassNotFoundException { // TODO Auto-generated method stub types = new ArrayList(); for (int i=0; i<forName.length; ++i){ types.add((Class<? extends Pet>)Class.forName(forName[i])); } return types; } }
创建计数器，计算生成的Pet的具体种类多少
步骤：①、获取装有Pet对象的容器 ②、获取容器中的数据，并使用instanceof判断其属于的具体类型 ③、如果匹配，创建Map，将该类型的名字作为键，每当有一个匹配，就让该键所对应的值加一。
public class PetCount { private Map<String,Integer> petCounts; private List<Pet> petsList; public PetCount(List<Pet> list){ petCounts = new HashMap(); petsList = list; } //将动物分类 private void classify(){ for(int i=0; i<petsList.size();++i){ Pet pet = petsList.get(i); if (pet instanceof Dog){ count("Dog"); } else if (pet instanceof Cat){ count("Cat"); } else if (pet instanceof Bird){ count("Bird"); } else if (pet instanceof Chicken){ count("Chicken"); } } } //计数 private void count(String className){ //应该使用Integer，不应该使用int类型 Integer count = petCounts.get(className); if(count != null){ petCounts.replace(className, count+1); } else{ petCounts.put(className,1); } } }
动态的instanceof重写计数器：
步骤：①、创建PetCount1类，在初始化前获取全部子类的对象，存入Map<Pet,Integer>中(与静态的instanceof相比，将所有的子类不用数组形式展现，以放入map的形式出现) ②、获取Pet对象的容器 ③、获取map中的对象，调用isInstance()与pet容器中的对象进行比较，一致则加一。
public class PetCount1 { private Map<Pet,Integer> allType;//获取所有Pet的子类并初始化。 public void count(Pet pet){ for (Map.Entry<Pet, Integer> map:allType.entrySet()){ Pet newPet = map.getKey();//获取键 Class c = newPet.getClass();//获取class //动态使用instanceof if (c.isInstance(pet)){ map.setValue(map.getValue()+1);//如果相等就坐加法 } } } }
小知识：Class.isAssignableFrom()是用来判断一个类Class1和另一个类Class2是否相同或是另一个类的子类或接口。
获取该对象的继承结构（核心 Class.getSuperClass()，递归）
public class PetCount3 { public static void main(String[]args){ Dog dog = new Dog(); Class c = dog.getClass(); getConstruct(c); } public static void getConstruct(Class c){ Class superClass = c.getSuperclass();//获取该类的父类 if (superClass != null){ System.out.println(superClass.toString()); getConstruct(superClass);//进行递归 superClass = null; } } }
七、注册工厂
在继承结构中的问题是：当我向Pet结构中添加了一个新的类的时候，就需要需改ForNameCreator.java中的项，那么这样就很可能出问题。
所以采用工厂方法，使用一个接口，继承这个接口就表示成为了Pet的一个结构，然后由工厂创建该类。
八、instanceof与Class的关系
1、instanceof与isInstanceof()生成的结果完全一样
2、equal与==结果也一样。
3、但是意义不同：instanceof表示：你是这个类型的吗，或者你是这个类的派生类吗
equal只是表示，你是这个了性吗，不考虑继承。
