JAVA类型信息——Class对象（转载）

JAVA类型信息——Class对象

一、RTTI概要

1、类型信息RTTI ：即对象和类的信息，例如类的名字、继承的基类、实现的接口等。

2、类型信息的作用：程序员可以在程序运行时发现和使用类型信息。

3、RTTI真正含义：运行时，识别一个对象的类型。

4、如何在程序运行时识别对象和类的信息？

1）传统RTTI：即在编译时已知道了所有的类型。

2）反射机制：在程序运行时发现和使用类的信息。

5、RTTI的使用

import java.util.*;      //List支持泛型

//import java.awt.List;  不支持泛型

import java.util.Arrays;

abstract class Shapes{

void draw() {System.out.println(this + ".draw()");}

abstract public String toString();

}

class Circle extends Shapes{

public String toString() {return "Circle";}

}

class Triangle extends Shapes{

public String toString() {return "Triangle";}

}

class Square extends Shapes{

public String toString() {return "Square";}

}

class Test{

public static List<Shapes> getList(){

List<Shapes> list_aShapes = Arrays.asList(new Circle() , new Square(), new Triangle());

return list_aShapes;

}

}

public class Shape {

public static void main(String[] args) {

List<Shapes> list_aShapes = Test.getList();

for(Shapes ob_aShapes : list_aShapes) {

ob_aShapes.draw();

}

}

}

运行结果：Circle.draw()

Square.draw()

Triangle.draw()

结果分析：（1）toString()都继承Object类的toSting()，派生类的toString()都会覆盖基类的该方法。

（2）Shapes.draw()中的this间接调用toString()。

（3）假设Test类是服务器端提供给客户端使用的一个类，客户端调用该类的方法(这里main()调用)获得一个泛化引用，显然，客户端并不知道泛化引用中的确切类型，而程序员需要使用到某一个确切类型对象，这时，我们就需要到RTTI。在上面的例子中，我们只是打印出泛化引用的所有类型。

二、Class对象

import java.lang.Class;

import java.lang.reflect.Constructor;

interface Iterface1{}

interface Iterface2{}

abstract class SuperClass{

SuperClass(){};

SuperClass(int i){}

static {System.out.println("creating SuperClass");}

}

class SunClass extends SuperClass implements  Iterface1, Iterface2{

SunClass(){super(1);}

static {System.out.println("creating SunClass");}

}

class SunClass1 extends SuperClass implements  Iterface1, Iterface2{

SunClass1(){super(1);}

static {System.out.println("creating SunClass1");}

}

public class ClassObject {

static void printInfo(Class cc) {

System.out.println("Class name:" + cc.getName()

+ "      is Interface : " + cc.isInterface()

+"       Simple name : " + cc.getSimpleName()

+ "      Canonical name : " + cc.getCanonicalName());

}

public static void main(String[] args) {

System.out.println("/////forName()与类字面常量////////");

Class ob_aClass = null;

//对类的引用不引发初始化

Class ob_cClass = SuperClass.class;

System.out.println("After creating SuperClass");

try {

//立即初始化类

ob_aClass = Class.forName("rtti.SunClass");

System.out.println("After creating SunClass");

System.out.println("///////////////////////////////////");

}catch(ClassNotFoundException e){

System.out.println("Can‘t find SunClass.");

System.exit(1);

}

printInfo(ob_aClass);

System.out.println("///////Class引用实现的接口///////");

for(Class face : ob_aClass.getInterfaces())

printInfo(face);

System.out.println("//////Class引用的基类////////");

Class ob_bClass = ob_aClass.getSuperclass();

printInfo(ob_bClass);

System.out.println("///////newInstance()///////");

Object ob_aObject = null;

try {

ob_aObject = ob_aClass.newInstance();

//运行剖出异常   newInstance()该法必须由Class.forName()调用

//ob_aObject = ob_bClass.newInstance();

}catch(InstantiationException e){

System.out.println("Can‘t instante.");

System.exit(1);

}catch(IllegalAccessException e){

System.out.println("Can‘t access.");

System.exit(1);

}

printInfo(ob_aObject.getClass());

System.out.println("//////Class引用的泛型////////");

Class <? extends SuperClass>  ob_dClass = SunClass.class;

printInfo(ob_dClass);

Class <? extends SuperClass>  ob_eClass = SunClass1.class;

printInfo(ob_eClass);

//没有类型转换(Class<? super SunClass>)，会出错，上位知道原因？

Class<? super SunClass>  ob_fClass = (Class<? super SunClass>)

ob_dClass.getSuperclass();

printInfo( ob_fClass);

}

}

运行结果:

creating SuperClass

creating SunClass

After creating SunClass

///////////////////////////////////

Class name:rtti.SunClass      is Interface : false       Simple name : SunClass      Canonical name : rtti.SunClass

///////Class引用实现的接口///////

Class name:rtti.Iterface1      is Interface : true       Simple name : Iterface1      Canonical name : rtti.Iterface1

Class name:rtti.Iterface2      is Interface : true       Simple name : Iterface2      Canonical name : rtti.Iterface2

//////Class引用的基类////////

Class name:rtti.SuperClass      is Interface : false       Simple name : SuperClass      Canonical name : rtti.SuperClass

///////newInstance()///////

Class name:rtti.SunClass      is Interface : false       Simple name : SunClass      Canonical name : rtti.SunClass

//////Class引用的泛型////////

Class name:rtti.SunClass      is Interface : false       Simple name : SunClass      Canonical name : rtti.SunClass

Class name:rtti.SunClass1      is Interface : false       Simple name : SunClass1      Canonical name : rtti.SunClass1

Class name:rtti.SuperClass      is Interface : false       Simple name : SuperClass      Canonical name : rtti.SuperClass

来源： <http://www.cnblogs.com/xuemaxiongfeng/archive/2013/08/24/3278859.html>

来自为知笔记(Wiz)