RTTI

 

1,class对象
  Class对象包含了与类有关的信息，Class对象就是用来创建类的所有普通对象的。生成相关的对象前JVM会首先载入Class对象即该.class文件。可以看到.class文件的载入时在需要时才被载入的，这与许多传统语言不同。
package com.biaoflying;

class Candy{
    //对于static对象，或者static语句是在类被首次加载时运行的。
    //并且只会加载一次。
    static{
        System.out.println("Loading Candy");
    }
}
class Gum{
    static{
        System.out.println("Loading Gum");
    }
}
class Coo_kie{
    static{
        System.out.println("Loading cookie");
    }
}
public class SweetShop {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("inside main");
        new Candy();
        System.out.println("After creating Candy");
        //若去掉这里的注释，可以发现static加载的方式。
        //new Gum();
        try{
            //?这里无法找到Gum.class文件
            //class.forName("Gum");
            //这里又可以找到Gum.class文件,但只会生成Class对象而            //不加载
            Class clazz=Gum.class
            Class.forName("com.biaoflying.Gum");
        }catch(ClassNotFoundException e){
            System.out.println("Couldn't find Gum");
        }
        new Coo_kie();
        System.out.println("After creating Coo_kie");
    }
}

#输出：
inside main
Loading Candy
After creating Candy
Loading Gum
Loading cookie
After creating Coo_kie

  另外类字面常量不仅可以用于普通的类，还可以用于基本数据类型：
  boolean.class 等价于Boolean.TYPE
  int.class     等价于Integer.TYPE
  ....

2,instanceof关键字
 

#Pets.java
package com.biaoflying; 
class Pet{} 
class Dog extends Pet{} 
class Pug extends Dog{} 
class Cat extends Pet{} 
class Rodent extends Pet{} 
class Gerbil extends Rodent{} 
class Hamster extends Rodent{} 
public class Pets{   
  public static void main(String[] args){        Pug pug=new Pug();       
    //注意instanceof           
    System.out.println(pug instanceof Dog);
    System.out.println(pug instanceof Pet);
  }
}

 

#Counter.java
package com.biaoflying;

public class Counter {
    private int i;
    public void plus(){
        i++;
    }
    public String toString(){
        return Integer.toString(i);
    }
}

#PetCount.java
package com.biaoflying;

import java.util.Random;
import java.util.Map;
import java.util.HashMap;
public class PetCount {
    private Random rand=new Random();
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map map=new HashMap();
        Random rand=new Random();
        String[] typeNames=new String[]{
            "Pet","Dog","Pug","Cat","Rodent","Gerbil",
            "Hamster",
        };
        Object[] pets=new Object[15];
        try{
            Class[] petTypes={
                    /*Class.forName("com.biaoflying.Dog"),
                    Class.forName("com.biaoflying.Pug"),
                    Class.forName("com.biaoflying.Cat"),
                    Class.forName("com.biaoflying.Rodent"),
                    Class.forName("com.biaoflying.Gerbil"),
                    Class.forName("com.biaoflying.Hamster"),*/
                    Dog.class,Pug.class,Cat.class,Rodent.class,
                    Gerbil.class,Hamster.class,
            };
            for(int i=0;i                pets[i]=petTypes[rand.nextInt(petTypes.length)].
                  newInstance();
            }
        }   catch(InstantiationException e){
                System.out.println("Cannot instantiate");
                System.exit(1);
            }catch(IllegalAccessException e){
                System.out.println("Cannot access");
                System.exit(1);
            }/*catch(ClassNotFoundException e){
                System.out.println("Class not found");
                System.exit(1);
            }*/
        for(int i=0;i            map.put(typeNames[i],new Counter());
        }
        for(int i=0;i            Object o=pets[i];
            if(o instanceof Pet)
                ((Counter)map.get("Pet")).plus();
            if(o instanceof Dog)
                ((Counter)map.get("Dog")).plus();
            if(o instanceof Pug)
                ((Counter)map.get("Pug")).plus();
            if(o instanceof Cat)
                ((Counter)map.get("Cat")).plus();
            if(o instanceof Rodent)
                ((Counter)map.get("Rodent")).plus();
            if(o instanceof Gerbil)
                ((Counter)map.get("Gerbil")).plus();
            if(o instanceof Hamster)
                ((Counter)map.get("Hamster")).plus();           
        }
        System.out.println(map);
    }

}
  Tip:
  1，使用Class.forName方法时必须捕捉ClassNotFoundException，另外还必须指定包名。而使用字面常量时两者都是不需要的。
  2，使用Class.isInstance方法
  for(int j=0;j                if(petTypes[j].isInstance(o)){
                    String s=petTypes[j].toString();
                    //System.out.println(s);
                    int index=s.lastIndexOf(".");
                    String sub=s.substring(index+1);
                    ((Counter)map.get(sub)).plus();
                }
            }

 
  除了使用instanceof方式(包含isIntance方法)还可以对Class对象进行比较，但两者存在不同之处：
 

package com.biaoflying;

class Base{
    
}
class Derived extends Base{
    
}
public class NoName {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //Base base=new Base();
        Derived derived=new Derived();
        System.out.println(derived instanceof Base);
        System.out.println(derived instanceof Derived);
        System.out.println(derived.getClass()==Base.class);
        System.out.println(derived.getClass()==Derived.class);
    }

}
  #输出：
  true
  true
  false
  true

  3，常用的方法
  Class.getName()
  Class.toString()这两个方法得到的结果是一样的
  Class.newInstance()
  Class.getInterfaces()
  Class.getSuperclass()