实例的常见操作

1. 1实例的常见操作

== 能够比较两个对象的内存地址是否一致（两个对象是否是同一个实例），当需要比较两个实例是否 逻辑意义上“相等”时， == 不能保证结果准确。

例：Employee类表示员工

public class Employee {
    public int empno;
    public String ename;
    public double salary;
    
    public Employee() {}
    public Employee(int empno,String ename,double salary){
        this.empno=empno;
        this.ename=ename;
        this.salary=salary;
    }
}

创建两个内容一样的实例

public class Test1 {
    public static void main(String[] args){
        Employee e1=new Employee(1001,"赵四",5000);
        Employee e2=new Employee(1001,"赵四",5000);

        System.out.println(e1==e2);//false
    }
}

public class Employee {
    public int empno;
    public String ename;
    public double salary;
    public Employee() {}
    public Employee(int empno, String ename, double salary) {
        this.empno = empno;
        this.ename = ename;
        this.salary = salary;
    }
    //此时需要在业务逻辑上判定额、e1与e2是相同的，==不能给出正确答案
    //可以通过重写Object类中的equals方法来实现判断Employee实例相等
    public boolean equals(Object obj){
        if (obj instanceof Employee){
            Employee temp=(Employee) obj;
            return (this.empno==temp.empno&&
                    this.ename.equals(temp.ename)&&this.salary==temp.salary);
        }
        return false;
    }
}
//在比较通过e1.equals(e2)可以进行判定

1.2字符串转换

在调用System.out.println(e1)时，默认打印出的是“类型@hashcode”的结构，这是通过调用从Object类继承来的toString（）方法实现的。

可以通过重写toString（）方法实现打印格式的实现，同时也提供了类转字符串的方法。

public String toString(){
        return "{empno:"+this.empno+",ename:'"+this.ename+"',salary:"+this.salary+"}";
    }

1.3hashcode值

hashcode（哈希码）值是通过对内存地址进行计算，得到一个数字，通常以十六进制方式显示。

它有如下特点：

（1）两个不同对象引用同一个实例，它们一定有相同的hashcode值

（2）两个对象的hashcode值相同，它们不一定是同一个实例

可以通过重写Object类的hashcode方法来重写hashcode获得（不推荐重写）

public int hashCode(){
        return this.empno;
    }

1.4对象的克隆

某些场景下，我们需要复制一个数据相同但是内存不同的新的实例，此时如果这样做会出现问题

Employee e1=new Employee(1001,"赵四");
Employee e2=e1;

此时对象e1和e2指向同一个实例，某个对象实例属性进行修改后，另一个对象也发生改变，我们需要的是两个不相关的实例。（即e1和e2分别指向内容相同的不同实例）。此时我们需要进行克隆操作。

克隆操作需要完成两个步骤：

类实现java.lang.Cloneable接口，这个接口中没有定义任何方法，仅是表明“类的实例允许克隆”

重写Object类中的clone()方法

    public class Employee implements Cloneable{

public Object clone() throws CloneNotSupportedException{
        return new Employee(this.empno,this.ename,this.salary);
    }

}

当需要获得一个克隆对象时

Employee e1=new Employee(1001,"赵四",5000);
Employee e3=(Employee)e1.clone();

e1与e3是两个不同的实例

深度克隆与浅度克隆

我们目前的克隆实现的是浅度克隆，当类中的某个属性是一个对象时，是否对属性对象进行克隆决定了克隆的深浅。

图示：游戏任务类Player中，存在着一个属性：Weaponed（武器）实例

如果没有对Weapone进行克隆，两个Player实例使用同一件武器实例，一方销毁，另一方的武器也会丢失，这种克隆被称为“浅度克隆”

深度克隆是指在Player克隆时，Weapone实例应该也进行克隆，两个Player实例应该分别持有各自的Weapone（当然，两个Weapone实例应该是具备同样的属性）

1.5比较规则

很多时候，我们需要对数组或集合进行排序操作，这样需要提供数组或集合内容的比较规则。通常来说，数字等常见类型拥有自然的比较规则。但是面向对象的类的比较规则需要我们自行设定。

比如两个Employee实例到底哪个更“大”？

比较规则的实现，需要两个步骤：

        类实现java.lang.Comparable接口，并实现compareTo方法

        在compareTo方法编写比较规则

示例

public int compareTo(Employee o){
        //逻辑上，this比o大，返回1；比o小，返回-1；相等，返回0.
        if(this.empno>o.empno){
            return 1;
        } else if (this.empno<o.empno) {
            return -1;
            
        }
        return 0;
    }

排序应用

public class Test2 {
    public static void main(String[] args) {
        Employee[] es = new Employee[3];
        es[0] = new Employee(1002, "刘能", 7000);
        es[1] = new Employee(1003, "广坤", 6000);
        es[2] = new Employee(1001, "赵四", 5000);
        System.out.println("排序前:"+Arrays.toString(es));
        Arrays.sort(es); //排序: 基于自定义的规则 Comparable
        System.out.println("排序后:"+Arrays.toString(es));
    }
}

1.6综合使用

上述的5个操作可以在类中同时设定

public class Employee implements Cloneable ,Comparable<Employee>{
    public int empno;
    public String ename;
    public double salary;
    public Employee() {}
    public Employee(int empno, String ename, double salary) {
        this.empno = empno;
        this.ename = ename;
        this.salary = salary;
    }
    //此时需要在业务逻辑上判定额、e1与e2是相同的，==不能给出正确答案
    //可以通过重写Object类中的equals方法来实现判断Employee实例相等
    public boolean equals(Object obj){
        if (obj instanceof Employee){
            Employee temp=(Employee) obj;
            return (this.empno==temp.empno&&
                    this.ename.equals(temp.ename)&&this.salary==temp.salary);
        }
        return false;
    }

    public String toString(){
        return "{empno:"+this.empno+",ename:'"+this.ename+"',salary:"+this.salary+"}";
    }

    public int hashCode(){
        return this.empno;
    }

    public Object clone() throws CloneNotSupportedException{
        return new Employee(this.empno,this.ename,this.salary);
    }

    public int compareTo(Employee o){
        //逻辑上，this比o大，返回1；比o小，返回-1；相等，返回0.
        if(this.empno>o.empno){
            return 1;
        } else if (this.empno<o.empno) {
            return -1;

        }
        return 0;
    }


}