Review for Interview 反射和克隆

java创建对象之反射 见之前的文章
java创建对象之 反射

克隆见之前写的文章java创建对象方式之clone以及序列化（总）

反射：

程序运行期间，java运行时系统始终会为所有的对象维护一个被称为运行时的类型标识，虚拟机利用运行时信息 选择相应的方法执行，可以通过专门的java类访问这些信息，保存这些信息的类称为Class。

将Class类中的forName和newInstance配合使用，可以根据存储在字符串中的类名创建一个对象。

Object o=Class.forName(A).newInstance();//这样 就创建了一个A类的对象

反射 的作用：

1. 运行时检测对象的类型
2. 动态的构建某个类的对象
3. 检测某一个类的属性和方法
4. 任意调用对象的方法
5. 修改构造函数、方法、属性的可见性

Junit

JUnit就是通过反射来遍历包含@Test注解的方法，并在单元测试时调用他们。

Web框架的使用

开发人员可以在配置文件中定义对各种接口和类的实现，通过反射机制，框架能够快速的动态初始化这些类。

例如，Spring框架：

<bean id="someID" class="com.programcreek.Foo">
    <property name="someField" value="someValue" />
</bean>

根据上面的配置文件，我们可以知道，当spring容器在处理bean元素的时候，会使用Class.forName(“com.programcreek.Foo”)来初始化这个类，并且再次的使用反射获取 property元素对应的setter方法，为对象的属性赋值。
同理，Servlet也是通过反射获取到对应的class以及对应的属性、方法等的。

<servlet>
    <servlet-name>someServlet</servlet-name>
    <servlet-class>com.programcreek.WhyReflectionServlet</servlet-class>
<servlet>

反射的基本方法

java.lang.refect包中的三个重要的类：
Field 描述类的域
Method：描述类的方法
Constructor：描述类的构造器
上面三个类都有公有的getter和Setter方法。

克隆

深克隆和浅克隆的区别：

简而言之，深克隆就是还会复制被克隆对象的引用，而浅克隆就是简单的复制被克隆对象，该对象的其他引用仍指向原来的对象。

继承自java.lang.Object类的clone()方法是浅复制。

Java的clone()方法

⑴clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。

⑵Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。

class Student implements Cloneable    
{    
     String name;    
    int age;    
     Student(String name,int age)    
     {    
        this.name=name;    
        this.age=age;    
     }    
    public Object clone()    
     {    
         Object o=null;    
        try    
         {    
         o=(Student)super.clone();//Object 中的clone()识别出你要复制的是哪一个对象。    
         }    
        catch(CloneNotSupportedException e)    
         {    
             System.out.println(e.toString());    
         }    
        return o;    
     }    
}    
   
public static void main(String[] args)    
     {    
       Student s1=new Student("zhangsan",18);    
       Student s2=(Student)s1.clone();    
       s2.name="lisi";    
       s2.age=20;    
       System.out.println("name="+s1.name+","+"age="+s1.age);//修改学生2后，不影响学生1的值。    
    }   

上述代码所示，我们在派生类中要覆盖Object中的Clone方法，调用super.clone()。在运行时刻，Object的clone方法找到所需要复制的对象，并为该对象分配空间，进行复制，将原对象的内容都复制到新对象的存储空间中。

但是由于Object的clone()方法都是浅克隆，上述代码可以实现修改学生2不影响学生1，但是当Student类中引用了Professor类的时候，克隆的Student2的修改可能会影响Student1的professor。
怎么才能实现深克隆（修改Stu2的professor引用依然不影响Stu1）呢，就是Professor类也实现Cloneable接口，实现 clone方法。

class Professor implements Cloneable    
{    
     String name;    
     int age;    
     Professor(String name,int age)    
     {    
        this.name=name;    
        this.age=age;    
     }    
    public Object clone()    
     {    
         Object o=null;    
        try    
         {    
             o=super.clone();    
         }    
        catch(CloneNotSupportedException e)    
         {    
             System.out.println(e.toString());    
         }    
        return o;    
     }    
}    
class Student implements Cloneable    
{    
     String name;    
     int age;    
     Professor p;    
     Student(String name,int age,Professor p)    
     {    
        this.name=name;    
        this.age=age;    
        this.p=p;    
     }    
    public Object clone()    
     {    
         Student o=null;    
        try    
         {    
             o=(Student)super.clone();    
         }    
        catch(CloneNotSupportedException e)    
         {    
             System.out.println(e.toString());    
         }    
         o.p=(Professor)p.clone();    
        return o;    
     }    
}    
public static void main(String[] args)    
     {    
       Professor p=new Professor("wangwu",50);    
       Student s1=new Student("zhangsan",18,p);    
       Student s2=(Student)s1.clone();    
       s2.p.name="lisi";    
       s2.p.age=30;    
System.out.println("name="+s1.p.name+","+"age="+s1.p.age);//学生1的教授不 改变。    
}    

3．利用串行化来做深复制

把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做 “解冻”或者“回鲜(depicking)”过程。

应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

如下为深复制源代码。

public Object deepClone()    
{    
//将对象写到流里    
ByteArrayOutoutStream bo=new ByteArrayOutputStream();    
ObjectOutputStream oo=new ObjectOutputStream(bo);    
oo.writeObject(this);    
//从流里读出来    
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());    
ObjectInputStream oi=new ObjectInputStream(bi);    
return(oi.readObject());    
}   

这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外。上例代码改进如下。
class Teacher implements Serializable{
String name;
int age;
Teacher(String name,int age){
this.name=name;
this.age=age;
}
}
class Student implements Serializable{
String name;//常量对象
int age;
Teacher t;//学生1和学生2的引用值都是一样的。
Student(String name,int age,Teacher t){
this.name=name;
this.age=age;
this.p=p;
}
public Object deepClone() throws IOException,
OptionalDataException,ClassNotFoundException{//将对象写到流里
ByteArrayOutoutStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(this);//从流里读出来
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi=new ObjectInputStream(bi);
return(oi.readObject());
}

}
public static void main(String[] args){ 
Teacher t=new Teacher("tangliang",30);
Student s1=new Student("zhangsan",18,t);
Student s2=(Student)s1.deepClone();
s2.t.name="tony";
s2.t.age=40;
System.out.println("name="+s1.t.name+","+"age="+s1.t.age);//学生1的老师不改变
}