java RTTI笔记 之Class学习笔记（摘自java编程思想）

1、java 使用Class对象来执行其RTTI。java 中每个类在编译后都会对应产生一个Class对象（更恰当地说是被保存在一个同名的.class文件中），甚至void和基本类型也都对应一个class对象。

jvm使用类加载器来将所需要的类动态的加载到JVM。所有的都是在第一次使用时动态加载到JVM中。当程序创建第一个对类的静态成员引用时，就加载这个类。构造器也是类的静态方法，即使没有static关键字，因此在使用new操作符创建新对象时也会被当做对类的静态成员的引用。

类加载其首先加载这个类的Class对象是否加载，未加载则查找相应.class文件。当然需要做一些验证。

　　在加载Class时会执行其静态代码块。为了使用类而做的准备工作实际包含三个步骤：

　　（1）加载，这是由类的加载器执行的。该步骤查找字节码，从字节码中创建一个Class对象。

　　（2）连接，在连接阶段将验证类中的字节码，为静态域分配存储空间，解析这个类创建的对其他类的所有引用。

　　（3）初始化，如果该类具有超类，则对其初始化，执行静态初始化器和静态代码块。

2、Class类有许多静态方法，例如forName(),在调用时，如果没有相应的类，也会加载。Class.forName(“ClassName”)也会返回一个名为ClassName的Class对象的引用。Class的newInstance()用于创建该类型的一个实例。

3、java 提供了另一种方法来产生对Class对象的引用，即使用类字面常量。例如MyClass.class。使用这个方法不仅安全而且更高效。但是该方法Class的初始化被延迟到了对静态方法或者非常数静态域的首次引用时才执行。

4、泛化的Class引用，直接的Class对象可以指向不同类型的Class对象，比如

Class intclass = int.class;
Class<Integer> genericIntClass = int.class;
genericIntClass=double.class;//ERROR

书中建议使用Class<? extends MyClass>

5、使用 instanceof 关键字判断实例的类型的代码。虽然Rat、Mutt等类型被保存在了Pet的list中但是仍然可以作为其自己的类型使用。java也提供了isInstance()方法来判断类的类型。

　　

class Pet
{
protected String name;
public Pet()
{
name="this is Pet";
}
public Pet(String name)
{
this.name=name;
}
public String toString()
{
return "Pet";
}

public String hehePet()
{
return name;
}
}

class Dog extends Pet
{

public Dog()
{
super();
name="this is Dog";
}
public Dog(String name) {
super(name);
// TODO Auto-generated constructor stub
}
public String toString()
{
return "Dog";
}

public String heheDog()
{
return name;
}
}

class Mutt extends Pet
{
public Mutt()
{
super();
name="this is Mutt";
}
public Mutt(String name) {
super(name);
// TODO Auto-generated constructor stub
}
public String toString()
{
return "Mutt";
}
public String heheMutt()
{
return name;
}
}

class Rat extends Pet
{
public Rat()
{
super();
name="this is Rat";
}
public Rat(String name)
{
super(name);
}
public String toString()
{
return "Rat";
}
public String heheRat()
{
return name;
}
}

public class Main{

public static Pet getPet(Class<?extends Pet> type) throws InstantiationException, IllegalAccessException
{
return type.newInstance();
}
public static void main(String[] args)
{
List<Class<? extends Pet>> types = new ArrayList<Class<? extends Pet>>();
List<Pet> petlists = new ArrayList<Pet>();
/* try {
types.add((Class<? extends Pet>) Class.forName("com.Rat"));
types.add((Class<? extends Pet>) Class.forName("com.Mutt"));
types.add((Class<? extends Pet>) Class.forName("com.Dog"));
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(types!=null&&!types.isEmpty())
{
for(Class<?extends Pet> type:types)
{
try {
petlists.add(getPet(type));
} catch (InstantiationException | IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}*/
petlists.add(new Pet());
petlists.add(new Rat());
petlists.add(new Mutt());
petlists.add(new Dog());
((Dog) petlists.get(2)).heheDog();
if(petlists!=null&&!petlists.isEmpty())
{
for(Pet pet:petlists)
{
if(pet instanceof Pet)
{
System.out.println("Pet "+pet.toString());
System.out.println(pet.hehePet());
}
if(pet instanceof Dog)
{
System.out.println("Dog "+pet.toString());
System.out.println(((Dog) pet).heheDog());
}
if(pet instanceof Rat)
{
System.out.println("Rat "+pet.toString());
System.out.println(((Rat) pet).heheRat());
}
if(pet instanceof Mutt)
{
System.out.println("Mutt "+pet.toString());
System.out.println(((Mutt) pet).heheMutt());
}
}
}
}
}