14.8 Class
每个类和接口都有Class对象，用于基本查询，并可创建新对象。
指定类型对象的创建和使用特殊方法的类加载，如通过网络。
(1) 方法
static Class forName(String className) throws ClassNotFoundException: 根据calssName提供的类全名返回class对象
ClassLoader getClassLoader ()：若没有，返回null
Class[] getInterfaces()：返回当前类/接口所实现/继承的若干接口。若没有，返回数组的长度为0。
String getName()：返回当前类的全名。
Class getSuperclass()：返回父类。若当前类为Object类或接口，返回null
boolean isInterface()：
Object newInstance() throws InstantiationException, IllegalAccessException： 为当前类创建实例.
String toString()：class/interface开头。
(2) 例1: 输出特定类型所属的层次(递归)。
public class TypeDesc {
public java.io.PrintStream out = System.out;
private static String[]
basic = { "class", "interface" },
extended = { "extends", "implements" };

public void printType(Class type, int depth) {
if (type == null) return // Object's supertype is null
for (int i = 0; i < depth; i++)
out.print(" ");
String[] labels = (depth == 0 ? basic : extended);
out.print(labels[type.isInterface() ? 1 : 0] + " ");
out.println(type.getName());
// print out an interfaces this class implements
Class[] interfaces = type.getInterfaces();
for (int i = 0; i < interfaces.length; i++)
printType(interfaces, depth + 1);
// recurse on the superclass
printType(type.getSuperclass(), depth + 1);
}

public static void main(String[] args) {
TypeDesc desc = new TypeDesc();
for (int i = 0; i < args.length; i++) {
try { desc.printType(Class.forName(args), 0);
} catch (ClassNotFoundException e) {
System.err.print(e); // report the error
}
}
}
}
SampleOutput: class java.util.Hashtable
implements java.lang.Cloneable
extends java.lang.Object
extends java.util.Dictionary
extends java.lang.Object

(3) 例2: 动态选择排序算法
static double[] testData = { 0.3, 1.3e-2, 7.9, 3.17, };
public static void main(String[] args) {
try {
for (int arg = 0; arg < args.length; arg++) {
String name = args[arg];
Class classFor = Class.forName(name);
SortDouble sorter
= (SortDouble)classFor.newInstance();
SortMetrics metrics
= sorter.sort(testData);
System.out.println(name + ": " + metrics);
for (int i = 0; i < testData.length; i++)
System.out.println("" + testData);
}
} catch (Exception e)
System.err.print(e); // report the error
}
}

14.9 Class的加载
(1) 类的加载：装入程序运行时需要的代码。
通常做法：用“类路径”机制搜索。
问题：运行时动态加载编译后的类文件？如果代码不是文件又如何？
(2) 方法
protected final Class defineClass(byte data[], int offset, int length): data转换成Class的一个实例。
protected final Class findSystemClass(String name)： 根据name在需要时加载系统类（无需加载器）
protected abstract Class loadClass(String name, boolean resolve)：根据name对类进行解析。若resolve为true，则该方法将调用方法resolveClass。
protected final void resolveClass(Class c)：在创建实例前用来解释它，使得所有该类引用的类也都被加载。
(3) 例1: 网络下载后加载
ClassLoader loader = new NetworkClassLoader(host,port);
Object main = loader.loadClass(“main”,true).newInstance();
……
public class NetworkClassLoader {
String host; int Port;
Hashtable cache = new Hashable();
private byte loadClassData(String name)[] {
// load the class data from the connection,…
}
public synchronized Class loadClass(String name, boolean resolve){
Class c = cache.get(name);
if (c==null) {
byte data[]=loadClassData(name);
c=defineClass(data,0,data.length);
cache.put(name,c);
}
if (resolve) resolveClass( c );
return c;
}
}

(4) 例2: 动态加载类文件
编制游戏能让游戏者写类并使用任何他们所选择的策略来玩游戏。提供一个抽象的Player类，游戏者将扩展该类实现他们的策略。



















public class Game {
static public void main(String[] args) {
String name; // the class name
while((name = getNextPlayer()) != nulll) {
try {
PlayerLoader loader = new PlayerLoader();
Class
classOf = loader.loadClass(name,true);
Player
player = (Player)classOf.newInstance();
Game game = new Game();
player.play(game);
game.reportScore(name);
} catch (Exception e) {
reportException(name,e);
}
}
}
}
//PlayerLoader类扩展了ClasssLoader以实现loadClass
class PlayerLoader extends ClassLoader {
private Hashtable Classes = new Hashtable();
public Class loadClass(String name, loolean resolve)
throws ClassNotFoundException
{ try {
Class newClass = (Class)Classes.get(name);
if (newClass == null) { // not yet defined
try { // check if system class
newClass = findSystemClass(name);
if (newClass != null)
return newClass;
} catch (ClassNotFoundException e) {
; // keep on looking
}

// class not found -- need to load it
byte[] buf = bytesForClass(name);
newClass = defineClass(buf, 0, buf.length);
Classes.put(name, newClass);
}
if (resolve)
resolveClass(newClass);
return newClass;
} catch (IOException e) {
throw new ClassNotFoundException(e.toString());
}
}
// ... byteForClass() and any other methods ...
protectd byte[] bytesForClass(String name) //undefined
throws IOException, ClassNotFoundException
{
FileInputStream in = streamFor(name);
int length = in.available(); // get byte count
if (length == 0)
throws new ClassNotFoundException(name);
byte[] buf = new byte[length];
in.read(buf); // read the bytes
return buf;
}
}