java进阶02 Equals

　　Equals
     在java中 一半不用"=="来比较是否相等
     而是用equals
     equals方法属于Object类，而且不是final 类型
     这说明equals可以被任何类继承和覆盖。

　　下面看看代码

　　

package Equals;

public class Equals1 {
    public static void main(String[] args){
    /*Equals
     * 在java中 一半不用"=="来比较是否相等
     * 而是用equals
     * equals方法属于Object类，而且不是final 类型
     * 这说明equals可以被任何类继承和覆盖
     * */
    A a=new A(5);
    A b=new A(5);
    System.out.print(a==b);
    /*控制台返回的事false 说明了不能用"=="来比较两个对象
     * 因为"=="比较的是两个对象的内存地址
     * 返回结果永远是false 
     * 所以才有equals的出现
     * */    
    }
}
class A{
    int i;
    A(int i){
        this.i=i;
    }    
}

　　运行返回的是false ，说明了不能用"=="来比较两个对象
     因为"=="比较的是两个对象的内存地址，而不是对象的具体属性。
     返回结果永远是false 。

　　如果把比较代码改成equals呢？我们来看看

　　

package Equals;

public class Equals1 {
    public static void main(String[] args){
    /*Equals
     * 在java中 一半不用"=="来比较是否相等
     * 而是用equals
     * equals方法属于Object类，而且不是final 类型
     * 这说明equals可以被任何类继承和覆盖
     * */
    A a=new A(5);
    A b=new A(5);
    System.out.println(a.equals(b));
    /*控制台返回的事false 说明了不能用"=="来比较两个对象
     * 因为"=="比较的是两个对象的内存地址
     * 返回结果永远是false 
     * 所以才有equals的出现
     * */    
    }
}
class A{
    int i;
    A(int i){
        this.i=i;
    }    
}

　　返回的结果仍然是false，因为这里的equals是默认的方法，与==是一样的，都是比较内存地址。

　　如果要比较对象的具体属性的话，需要自己来覆盖该方法。

　　

package Equals;

public class Equals2 {
    public static void main(String[] args){
        B a=new B(20);
        B b=new B(20);
        System.out.print(a.equals(b));
    }
    
    
}
class B{
    int i;
    B(int i){
        this.i=i;
    }    
    public boolean equals(B a){
        if(this.i==a.i)
            return true;
        else 
            return false;
    }
}

　　如此，就得到自己想要的结果。

　　Equals方法在一般情况下都需要覆盖成自己想要的方法，而且配合多态可以实现强大的"比较"方法，可以比较类中的任何数据.

　　

package Equals;

public class Equals2 {
    public static void main(String[] args){
        B a=new B(20);
        B b=new B(20);
        //System.out.print(a.equals(b));
        
        C c1=new C(10);
        C c2=new C(10);
        System.out.print(c1.equals(c2));
    }
    
    
}
class B{
    int i;
    B(int i){
        this.i=i;
    }    
    //覆盖equals
    public boolean equals(B a){
        if(this.i==a.i)
            return true;
        else 
            return false;
    }
}
class C extends B{
    C(int j){
        super(j);
    }
}

　　这里就用多态实现了比较B类中的i是否相同，返回结果是true

　　这里比较的是B类的i ，如果要比较C类的j;又需要重新覆盖equals

　　

package Equals;

public class Equals2 {
    public static void main(String[] args){
        B a=new B(20);
        B b=new B(20);
        //System.out.print(a.equals(b));
        
        C c1=new C(10);
        C c2=new C(10);
        System.out.print(c1.equals(c2));
    }
    
    
}
class B{
    int i;
    B(int i){
        this.i=i;
    }    
    //覆盖equals
    public boolean equals(B a){
        if(this.i==a.i)
            return true;
        else 
            return false;
    }
}
class C extends B{
    int j;
    C(int j){
        super(j);
        this.j=j;
    }
    public boolean equals(B b){    
　　　　 C c=(C)b;    
        if(this.j==c.j)
            return true;
        else 
            return false;
    }
}

　　这里就比较了C类中的j,它覆盖了父类饭equals。

　　同理，要比较i,j的话，还是覆盖该方法

　　

package Equals;

public class Equals3 {
    public static void main(String[] args){
        E e1=new E(10,20);
        E e2=new E(10,20);
        System.out.print(e1.equals(e2));
    }
}
class D{
    int i;
    D(int i){
        this.i=i;
    }    
    //覆盖equals
    public boolean equals(D d){
        if(this.i==d.i)
            return true;
        else 
            return false;
    }
}
class E extends D{
    int j;
    E(int i,int j){
        super(i);
        this.j=j;
    }
    public boolean equals(D d){
        E e=(E)d;
        if(this.j==e.j&&this.i==e.i)
            return true;
        else 
            return false;
    }
}

　　java进阶笔记 Equals到此结束.