1. Java中的clone方法

1.1 clone：有些时候需要一个和A完全相同新对象B，并且此后对B对象的任何改动都不会影响A中的值，即A与B是两个独立的对象。
Java的所有类都默认继承java.lang.Object类，在该类中有一个clone()方法返回一个拷贝对象（拷贝对象是一个新对象，而不是引用，并且该拷贝对象包含一些原来对象的信息）。
1.2 clone方法使用

 public class Student implements Cloneable {
    
    private String name;
     
   private int age;
   
   private Professor professor;

    public String getName() {
       return name;
    }

   public void setName(String name) {
       this.name = name;
   }

    public int getAge() {
       return age;
    }
 
   public void setAge(int age) {
         this.age = age;
     }
 
     public Professor getProfessor() {
         return professor;
    }
  public void setProfessor(Professor professor) {
         this.professor = professor;
     }
     @Override
   public String toString() {
       return "Student [name=" + name + ", age=" + age + ", professor="
                 + professor + "]";
  }
    
  public Object clone() throws CloneNotSupportedException{
       return super.clone();
   }
 }

Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且 这个标志也仅仅是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了super.Clone()方法），那么Object的clone()方法就会抛出 CloneNotSupportedException异常。
1.3 浅复制

class UnCloneA {
    private int i;
 
    public UnCloneA(int ii) {
        i = ii;
    }
 
    public void doublevalue() {
        i *= 2;
    }
 
    public String toString() {
        return Integer.toString(i);
    }
}
 
class CloneB implements Cloneable {
    public int aInt;
    public UnCloneA unCA = new UnCloneA(111);
 
    public Object clone()throws CloneNotSupportedException{
       return super.clone();
   }
}
 
public class CloneMain {
    public static void main(String[] a) {
        CloneB b1 = new CloneB();
        b1.aInt = 11;
        System.out.println("before clone,b1.aInt = " + b1.aInt);
        System.out.println("before clone,b1.unCA = " + b1.unCA);
 try{
        CloneB b2 = (CloneB) b1.clone();
        b2.aInt = 22;
        b2.unCA.doublevalue();
        System.out.println("=================================");
        System.out.println("after clone,b1.aInt = " + b1.aInt);
        System.out.println("after clone,b1.unCA = " + b1.unCA);
        System.out.println("=================================");
        System.out.println("after clone,b2.aInt = " + b2.aInt);
        System.out.println("after clone,b2.unCA = " + b2.unCA);
 }catch (CloneNotSupportedException e) {
           e.printStackTrace();
      }  
  }
}

• UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone()方法）
• 在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();
  关于StringBuffer：StringBuffer是一个 final类，没有重载clone()方法。如果一个类中包含有StringBuffer类型对象或和 StringBuffer相似类的对象，可以只能实现浅复制，或者在类的clone()方法中加一句o.unCA = new StringBuffer(unCA.toString())。

2. equal和hashCode

• 基本数据类型只需要用==比较值得大小即可。
• 对于对象而言，==用于判断是不是指向同一个对象，即内存地址的比较。

public boolean equals(Object obj){
        return (this==obj);
}

从源码可以看出，没有重写 equals时，是直接用==判断的，所以比较的还是两个对象的引用是否指向同一个内存地址。若想用equals()用来判断对象的值是否相等,就要重写equals()。

• hashCode 这是一个 native 本地方法，其实默认的 hashCode 方法返回的就是对象对应的内存地址。hashCode()的作用是获取hash值，也称为散列码；它实际上是返回一个int整数。这个hash值的作用是确定该对象在哈希表中的索引位置。也就是说hash值要在一些数据结构中才能显现作用。hashcode一般用在hashmap、hashset里，判断要把数据放在数组的什么位置。
  1. 调用 equals 返回 true 的两个对象必须具有相等的哈希码。
  2. 如果两个对象的 hashCode 返回值相同，调用它们 equals 方法不一返回 true。(碰撞：若两个不同的数据经过相同哈希函数运算后，得到相同的结果，那么这种现象就做碰撞)

3. getClass

反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。在Java使用类型类来表示一个类型。所有的类型类都是Class类的实例。

class B{
    public void func(){

    }
}

public class Test {

    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.getClass()+" "+B.class);//class B,class B
    }

}

getClass() 是一个类的实例所具备的方法，而class() 方法是一个类的方法。
getClass() 是在运行时才确定的，而class() 方法是在编译时就确定了。

4. toString

八种基本数据类型没有toString()方法，只能使用相应的包装类才能使用toString()。

getClass().getName() + '@' + Integer.toHexString(hashCode())

Object的toString方法返回的字符串: 对象名+@+转换为十六进制的对象的哈希值，所以当哈希冲突时，Object.toString()返回的字符串也不可避免地重复了。