java基础知识11-java运行时

1：java寻找类

当我们初始化一个类的实例的时候，java虚拟机会查找并且加载这个类。当然用Class.forName("xxx"),用来查找和加载一个类，返回一个句柄来控制这个类的其他操作，比如产生一个实例。

try{
Class x = Class.forName("xx");
Object y = x.newInstance(); //newInstance 返回Object句柄，并且类的构造函数必须没有任何参数
}catch(InstantiationException e)
{
}catch(IllegalAccessException e)
{
}
catch(ClassNotFoundException e)
{
e.printStackTrace();
}

2：判断对象是否是类的实例

方法一：

TestClass x = new TestClass();

if( x instanceof TestClass)

方法二：

if（TestClass.class.isInstance（x））

毫无疑问方法2是一种优势，可以避免修改代码

3：类Class

public final class Class<T>

extends Object

implements Serializable, GenericDeclaration, Type, AnnotatedElement

之前用到的Class.forName("xx"); 其中的Class就是一个类，很奇怪吧，Class的实例表示正在运行的类或者接口。Class没有公共构造函数，Class的对象是被java虚拟机自动的构造当类被加载并且调用。

java 中并不是一开始就加载所有的类，而是用到什么就加载什么，所以一个类在第一次调用时时候会产生这个类的Class 对象，记住是Class对象，而不是类的实例，当我们再次实例化这个类的时候，用的就是这个Class的object。

Class x =Class.forName("Cookie");
Object yy = x.newInstance();
System.out.println("the class name is:"+x.getName());
Class z = Cookie.class;
System.out.println(x);
System.out.println(z);
System.out.println( x == z);

结果：

class Cookie

class Cookie

true

例子2：

class TestX
{}
interface faceX
{}
interface faceY
{}
class TestY extends TestX implements faceX,faceY
{}
public class ClassAndInterface {
public static void main(String[] args)
{
Class Obj = null;
try
{
Obj = Class.forName("TestY");
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
Class[] faces = Obj.getInterfaces();
for(int i =0;i<faces.length;i++)
System.out.println(faces[i]);
Class cf = Obj.getSuperclass();
Object Osu = null;
try{
Osu = cf.newInstance();
}catch(InstantiationException ie)
{
}catch(IllegalAccessException ie)
{}
System.out.println(Osu);
}
}

从这个例子可以看出我们可以利用Class类来知道类的祖宗十八代的信息。

4:类的标记

Class X{}；

X.class代表的就是Class的object。

5:java的反射机制

java的反射机制就是在运行时获取一个类的各种信息，包括字段，函数，构造函数。可对一个编译期完全未知的对象进行实际的设置以及发出方法调用。

6：java 函数参数的传递

java中函数中传递的是句柄，在函数内部对句柄是复制的，但是即便复制了句柄，不同的句柄所指向的内存还是一样的，所以这个时候就相当于C++ 的传引用调用，这个时候传递参数的话，那么就会对函数外部的对象产生一些额外的影响。

public class CObject {
int i;
CObject(int i)
{
this.i = i;
}
public static void main(String[] args)
{
CObject x = new CObject(2);
CObject y = x;
x.i++;
System.out.println("X's i ="+x.i);
System.out.println("Y's i ="+y.i);
System.out.println(x);
System.out.println(y);
}
}

7：java的clone

为了解决参数句柄传递时发生的类似C++中的传引用的副作用，我们引入了对象的Clone概念。所谓的对象Clone就是把对象完全复制，然后只针对这个对象进行操作。Clone是Object类的protected函数

protected Object clone（）throws CloneNotSupportException 

因此要在类的外部调用clone函数，必须重载Object的clone函数，并且将其设为public函数，并且在重载的时候要注意调用super.clone().

其次就是实现java.lang 中的Cloneable接口，这个接口是奇怪的，因为它是空的，interface Cloneable{}，我们实现它，其实就可以在原理上利用 if myHanble instanceof Cloneable，这样的判断，去判断一个类是否可以被clone。

8：clone中的浅clone 和深 clone

当我们进行clone的时候，如果对象中包含类对象，那么在进行clone的时候，一定要记得将成员类实例进行clone。例如下面的例子：

public class Snake implements Cloneable{
private Snake next;
private char c;
Snake(int i,char x)
{
c = x;
if(--i > 0)
next = new Snake( i,(char)(x+1) );
}

void increment()
{
c++;
if(next != null)
next.increment();
}

public String toString()
{
String s = ":" + c;
if(next!=null)
s += next.toString();
return s;
}

public Object clone()
{
Object Obj = null;
try
{
Obj = super.clone();
}catch(CloneNotSupportedException ce)
{
System.out.println("Cann't clone this object");
}
return Obj;
}

public static void main(String[] args)
{
Snake s1 = new Snake(5,'a');
System.out.println("s1 is:" + s1);
Snake s2 = (Snake)s1.clone();
System.out.println("s2 is:" + s2);
s1.increment();
System.out.println("Now after s1 increace s2 is:" + s2);

}
}

运行结果如下所示：

s1 is::a:b:c:d:e

s2 is::a:b:c:d:e

Now after s1 increace s2 is::a:c:d:e:f

从以上运行结构可以看出，我们的clone函数仅仅clone了Snake对象的第一个部分，所以s1运行increament后，s2的只有第一节a不变，后面的节数还是跟随着s1的变化产生了变化，所以进行clone的时候一定要注意其他类实例成员的clone，现在修改clone函数，如下所示：

public Object clone()
{
Snake Obj = null;
try
{
Obj = (Snake)super.clone();
if(Obj.next != null)
Obj.next = (Snake)Obj.next.clone();
}catch(CloneNotSupportedException ce)
{
System.out.println("doesn't support clone");
}
return Obj;
}

通过上面的代码的修改，程序的运行结果如下所示：

s1 is::a:b:c:d:e

s2 is::a:b:c:d:e

Now after s1 increace s2 is::a:b:c:d:e

可以看到s2没有随着s1的变换而发生变化，从而达到了我们的预期目标。

9：继承类的clone

当一个继承类的父类有可以调用的clone函数时候我，我们并不需要重新改写clone函数即便我们在继承函数中增加了新的字段，这是因为Object.clone会自动识别是继承类调用的clone函数，那么就会自动复制继承类中新增加的字段。如下程序所示：

import java.util.*;
class Int2 implements Cloneable {
private int i;
public Int2(int ii) { i = ii; }
public void increment() { i++; }
public String toString() {
return Integer.toString(i);
}
public Object clone() {
Object o = null;
try {
o = super.clone();
} catch (CloneNotSupportedException e) {
System.out.println("Int2 can't clone");
}
return o;
}
}
class Int3 extends Int2 {
private int j; // Automatically duplicated
public Int3(int i) { super(i); }
public Int3(int i,int j){super(i);this.j = j;}
public String toString()
{
return Integer.toString(j);
}
}

public class AddingClone {
public static void main(String[] args) {
Int3 x3 = new Int3(1,7);
Int3 x4 = (Int3)x3.clone();
System.out.println("x3.j = "+x3 +"x4.j = "+x4);
}
}

结果：

x3.j = 7x4.j = 7

说明继承类Int3中自动完成了新增加字段j的复制，即便Int3中，没有改写父类Int2的clone函数

10：clone 和对象的序列化

java对象序列化就是把对象在内存中的状态转变成字节序列保存起来，反序列化就是把对象从保存的字节中恢复出来，通过Inputstream，OutputStream，ObjectInputStream,ObjectInputStream流对象来操作。

其实对象的反序列化经历的就是一个clone的过程，但是它用的 时间比clone长并且不稳定。

11：clone的关闭

当一个类具有clone功能的时候，其子类都会继承这种clone功能，但是有时候处于安全我们想关闭clone功能时，可以采用一些方法：
重新改写clone，使其为空；
使clone抛出CloneNotSupportedException等方法

12：关于java的复制构造函数，java的复制构造函数，thinking in java的作者用了这样的一个例子来说明，但是感觉说的太模糊了，总体上我认为java不适合采用复制构造函数的原因有：
java中包含多个类成员的时候，复制构造函数需要调用每个类的复制构造函数，这个是比较麻烦的；
java中传递的是句柄，当把子对象的句柄传入父级时，会造成切片问题，丢失子类信息，但是这个在C++中也是存在的，所以这个不是java不要用复制构造函数的理由
C++中的复制构造函数时C++自身机制的一部分(即便我们没用写复制构造函数，系统也会为我们生成一个)，所以我们可以方便的调用复制构造函数去创建本地对象的一个副本（传值调用+其他类的复制构造函数），但是java中对象都是用句柄表示，不能通过简单的赋值来解决问题。