重寫equals/clone

Equals 方法通常是用來判斷兩個對象是否相等。Set集合通常要依賴這個方法，如果一個類的對象若要存入set集合，通常要重寫這個方法

一般重寫了equals方法，就要重寫hashcode方法

public class Student implements Cloneable {
    private String id;//如果兩個對象的id值相同，說明這個兩個對象是同一個學生
    private String name;

    @Override
    public Student clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return (Student) super.clone();
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this)
            return true;
        if (obj == null) return false;
        if (obj instanceof Student) {//是這個類的實例
            Student s = (Student) obj;
            if (s.id != null && s.id.equals(this.id)) {//按業務規則來判斷是否爲同一個對象
                return true;
            } else {
                return false;
            }
        } else {
        //不是這個類的實例
            return false;
        }
    }/* * 一般重寫了equals方法，就要重寫hashCode方法 */

    @Override
    public int hashCode() {
        return this.id.hashCode();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

測試

import org.junit.Test;

public class TestStudent {
	@Test
	public void test() throws CloneNotSupportedException{
		Student s = new Student();//第一次創建原生的對象
		s.setId("niit01");
		
		Student s2 = s.clone();//產生新的對象，與原生對象地址不同
		
		System.out.println(s.equals(s2));
	}
}

克隆：

一個類要重寫clone方法

1.聲明實現Cloneable接口

2.重寫object類中的clone()方法，將protected改成public，重寫clone方法時，在重寫方法的內部要調用super.clone()對象的clone分成

1).淺克隆（淺複製，淺拷貝）

2)深克隆（...）

 

深克隆與淺克隆的區別在於引用類型的屬性的處理

淺克隆

public class Computer{
	private String brand;
	public Computer() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Computer(String brand) {
		super();
		this.brand = brand;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
}
public class Student implements Cloneable{
	private String name;
	public Computer c;

	public Student(String name) {
		super();
		this.name = name;
	}
	public void setName(String name){
		this.name = name;
	}
	public void setComputer(Computer c){
		this.c = c;
	}
	
	
	public String toString(){
		return this.name+"\t 電腦的品牌"+c.getBrand();
		
	}
	public Object clone()  throws CloneNotSupportedException{
		return super.clone();
	}
	public static void main(String[] args) throws CloneNotSupportedException {
		Student stu = new Student("李三");
		Computer c = new Computer();
		c.setBrand("lenovo");
		stu.c = c;
		Student s1 = (Student) stu.clone();	//創建一個對象，這個對象與stu完全相同
		System.out.println(stu);  			//李三	 電腦的品牌lenovo
		System.out.println(s1);				//李三	 電腦的品牌lenovo
		System.out.println(s1==stu);		//這兩個變量指向兩個不同的對象，所以false
		s1.setName("李四");					//將克隆對象的name屬性設置爲李四，對原來的對象是沒有影響的
		System.out.println(s1);   			//李四	 電腦的品牌lenovo
		System.out.println(stu);			//李三	 電腦的品牌lenovo
		c.setBrand("dell");
		s1.setComputer(c);					//修改引用數據類型
		System.out.println(s1);				//李四	 電腦的品牌dell
		System.out.println(stu);			//李三	 電腦的品牌dell
		
		s1.setComputer(new Computer("mac"));					//修改引用數據類型
		System.out.println(s1);				//李四	 電腦的品牌mac
		System.out.println(stu);			//李三	 電腦的品牌dell
		
	}
}

深克隆

public class Computer implements Cloneable{
	private String brand;
	public Computer() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Computer(String brand) {
		super();
		this.brand = brand;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	@Override
	public Computer clone() throws CloneNotSupportedException {
		return (Computer)super.clone();
	}
}
public class Student implements Cloneable{
	private String name;
	public Computer c;

	public Student(String name) {
		super();
		this.name = name;
	}
	public void setName(String name){
		this.name = name;
	}
	public void setComputer(Computer c){
		this.c = c;
	}
	
	
	public String toString(){
		return this.name+"\t 電腦的品牌"+c.getBrand();
		
	}
	public Object clone()  throws CloneNotSupportedException{
		Student s = (Student) super.clone();
		if(s.c!=null)
			s.c=s.c.clone();//廠商是影響類型，需要新建一個對象
		return s;

	}
	public static void main(String[] args) throws CloneNotSupportedException {
		Student stu = new Student("李三");
		Computer c = new Computer();
		c.setBrand("lenovo");
		stu.c = c;
		Student s1 = (Student) stu.clone();	//創建一個對象，這個對象與stu完全相同
		System.out.println(stu);  			//李三	 電腦的品牌lenovo
		System.out.println(s1);				//李三	 電腦的品牌lenovo
		System.out.println(s1==stu);		//這兩個變量指向兩個不同的對象，所以false
		s1.c.setBrand("zzz");				
		System.out.println(s1);   			//李四	 電腦的品牌zzz
		System.out.println(stu);			//李三	 電腦的品牌lenovo

		
	}
}