Java 类型信息

发布时间：2020-12-14 06:32:43 所属栏目：Java 来源：网络整理

导读：《Thinking in Java 4th》第14章类型信息运行时类型信息（Run-Time Type Identification）使得你可以在程序运行时发现和使用类型信息。 14.1 为什么需要RTTI Circle,Square,Triangle三个类都继承自抽象类Shape，现有一个List 的数组，存的是Circle,Triangl

《Thinking in Java 4th》第14章类型信息

运行时类型信息（Run-Time Type Identification）使得你可以在程序运行时发现和使用类型信息。

14.1 为什么需要RTTI

Circle,Square,Triangle三个类都继承自抽象类Shape，现有一个List的数组，存的是Circle,Triangle的对象，当你拿出一个对象时，你只知道它是Shape类，但不知道它的具体类型。使用RTTI，可以查询某个Space引用所指向的对象的具体类型。

14.2 Class对象

Java使用Class对象来执行其RTTI，它包含了与类有关的信息。每一个类都有一个Class对象，被保存在同名的.class文件中。为了生成这个类的对象，运行这个程序的JVM将使用被称为“类加载器”的子系统。

所有的类都是在对其第一次使用时，动态加载到JVM中的。当程序创建第一个对类的静态成员的引用时，就会加载这个类。因此，Java程序在它开始运行之前并未被完全加载。其各部分是在必需时才加载的。

类加载器首先检查这个类的Class对象时候已经加载，如果尚未加载，默认的类加载器就会根据类名查找.class文件。一旦某个类的Class对象被载入内存，它就被用来创建这个类的所有对象。

class Candy { static { System.out.println("Loading Candy"); } }

class Gum { static { System.out.println("Loading Gum"); } }

class Cookie { static { System.out.println("Loading Cookie"); } }

public class SweetShop {
public static void main(String[] args) {
System.out.println("inside main");
new Candy();
System.out.println("After create Candy");
try {
Class.forName("typeinfo.Gum");//书上没有加包名，亲测需要加
} catch (ClassNotFoundException e) {
System.out.println("Couldn't find Gum");
}
System.out.println("After Class.forName("Gum")");
new Cookie();
System.out.println("After create Cookie");
}
}

forName()是取得Class对象引用的一种方法，包含目标类的文本名的String作为输入，返回Class对象的引用。

interface HasBatteries {}
interface Waterproof {}
interface Shoots {}

class Toy {
Toy() {}
Toy(int i) {}
}

class FancyToy extends Toy implements HasBatteries,Waterproof,Shoots {
FancyToy() { super(1); }
}

public class ToyTest {
static void printInfo(Class cc) {
System.out.println("Class name: " + cc.getName() + " is interface? [" + cc.isInterface() + "]");
System.out.println("Simple name: " + cc.getSimpleName());
System.out.println("Canonical name: " + cc.getCanonicalName());//Canonical:规范化=_=
 }
public static void main(String[] args) {
Class c = null;
try {
c = Class.forName("typeinfo.toys.FancyToy");
} catch (ClassNotFoundException e) {
System.out.println("Can't find FancyToy");
System.exit(1);
}
printInfo(c);
for (Class face: c.getInterfaces()) {
printInfo(face);
}
Class up = c.getSuperclass();
Object obj = null;
try {
// 需要默认构造函数即无参的构造函数否则会报错
obj = up.newInstance();
} catch (InstantiationException e) {
System.out.println("Cannot instantiate");
System.exit(1);
} catch (IllegalAccessException e) {
System.out.println("Cannot access");
System.exit(1);
}
printInfo(obj.getClass());
}
}

通过对象.getClass()可以直接得到Class引用。

public class Exercise10 {
public static void main(String[] args) {
char[] ch = new char[10];
Class cc = ch.getClass();
typeinfo.toys.ToyTest.printInfo(cc);
System.out.println(ch instanceof Object);
}
}
/*
Class name: [C is interface? [false]
Simple name: char[]
Canonical name: char[]
true
/

14.2.1 类字面常量

通过类名.class也可以得到Class对象的引用。当使用".class"来创建对Class对象的引用时，不会自动地初始化该Class对象。

基本类型.class = 基本类型的包装类.class

import java.util.*;

class Initable {
static final int staticFinal = 47;
static final int staticFinal2 = ClassInitialization.rand.nextInt(1000);
static { System.out.println("Initializing Initable"); }
}

class Initable2 {
static int staticNotFinal = 147;
static { System.out.println("Initializing Initable2"); }
}

class Initable3 {
static int staticNotFinal = 74;
static { System.out.println("Initializing Initable3"); }
}

public class ClassInitialization {
public static Random rand = new Random(47);
public static void main(String[] args) throws Exception {
Class initable = Initable.class;
System.out.println("After create Initable ref");
System.out.println(initable.isInterface());
System.out.println(Initable.staticFinal);
System.out.println(Initable.staticFinal2);
System.out.println(Initable2.staticNotFinal);
Class initable3 = Class.forName("typeinfo.Initable3");
System.out.println("After create Initable3 ref");
System.out.println(Initable3.staticNotFinal);
}

}

如果一个static final是“编译期常量”，那个这个值不需要对类初始化就可以读取。

14.2.2 泛化的Class引用

例：? intClass = .;?

使用Class优于Class。

向Class添加泛型是为了提供编译期类型检查。

感觉Java的泛型真神奇啊(= =)

Class 我也就忍了竟然还有 Class up = TObj.getSuperclass();

Object obj = up.newInstance(); <-- 得到的只是Object

14.2.3 新的转型语法

按作者的意思，这个并没有什么用……

class Building {}
class House extends Building {}

public class ClassCasts {
public static void main(String[] args) {
Building b = new House();
Class houseType = House.class;
House h = houseType.cast(b);
h = (House)b; // ... or just do this.
 }
}

14.3 类型转换前先做检查

如果你想向下转型，先用关键字instanceof检查

? (x ?

?//我发现作者有一种神奇的能力——把很简单的事情写成一大堆神烦的代码……就算写代码少写几行不行吗啊魂淡……一定是按字数付稿费……

?//我把那一堆代码抄完我都懒得复制过来了，头疼= =

使用 a instanceof AClass 就必须写AClass的类名。但是没有储存类名的容器呀，所以就想到改进方法，使用Class对象，然后使用它的Class对象.isInstanceof(目标对象)就可以辣！

isAssignableFrom ? 是用来判断一个类Class1和另一个类Class2是否相同或是另一个类的超类或接口。?

通常调用格式是 : ??

14.4 注册工厂

?没看懂（捂脸先过……

14.5 instanceof 与 Class 的等价性

a instanceof B 等价于 B.class.isInstance(a) 当对象a的类型与B相同或者是其派生类时，返回true

a.getClass()==B.class 等价于 a.getClass.equals(B.class) 当且仅当对象a的类型与B相同时，返回true

14.6 反射：运行时的类信息

RTTI和反射之间真正的区别只在于，对RTTI来说，编译器在编译时打开检查.class文件。而对于反射机制来说，.class文件在编译时是不可获取的，所以是在运行时打开时和检查.class文件。

Class c = Class.forName(args[0== c.getConstructors();

args[0]在编译时是不可知的，但是通过反射，你可以知道类中的方法以及构造器。

事实上反射可以获得类的所以域和方法，甚至包括private。

设计模式什么的，真的看不懂啊~~~>_<~~~

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!