equals

class A{
    public int i;
    public A(int i){   // 构造函数
        this.i = i;
    }    
}
public class TestEq{
    public static void main(String[] args){
        A aa1 = new A(2);
        B aa2 = new A(2);
        
        System.out.println(aa1.equlas(aa2)); //false        
    }
}

为何是这样？

    若是咱们单独

 System.out.println(aa1);   -> 前面A表示类 @后面跟着的是这个对象在内存中地址16进制的表示
 System.out.println(aa2);

很明显不是同一个对象，若是是同一个对象那么地址也能够说指针吧，确定是同样的，不同是由于

    在内存中咱们开辟了4个内存，aa1,aa2 在栈中，分别指向了堆中一个new A(2) ， 一个new A(2)

这样两个对象不相等那是理所固然的了

那之后咱们可能会写一些容器之类的东西，把一些类丢进去，重复的就不要了，那咱们能够

class A{
    public int i; 
    public A(int i){
        this.i = i;
    }
    public boolean equals(Object obj){
        A aa = (A)obj;
        if(aa.i == this.i)
            return true;
        else
            return false;
     }
}
public class testB{
    public static void main(String[] args){
        A aa1 = new A(2);
        A aa2 = new A(2);
        System.out.println(aa1.equals(aa2));  //true
    }
}

   那为何重写父类的equlas的时候加上

 A aa = (A)obj //这句 就能够了？

举个简单例子

class A{     //父类
    void f(){
        System.out.printf("AAAAA\n");
    }
}
class B extends A{   子类继承父类A
    void f(){
        System.out.printf("BBBBB\n");
    }

    void g(){}
}

public class testPloy{
    public static void main(String[] args){
        A aa = new A();
        B bb = new B();  
        aa.f()//success, 由于父类能够调用子类继承本身的东西
        aa.g()//error ,由于父类没法调用子类所特有的东西
        //假如把子类bb的指针发送给父类aa呢
        aa = bb
        aa.g()//error
        //那惟有经过强制转换
        B bb2 = (B)aa;
        bb2.g() //success
        //强制转换必须有个先确条件就是 aa=bb，必须是父类已经指向了子类才行
    }
}

因此回头在看这个重写的equals

 aa1.equals(aa2);

咱们把aa2发送给父类 Object obj 就至关于

obj = aa2

因此能够经过强制转换

A aa = (A)obj

达到访问子类因此特有的属性方法

若是把

if(aa.i == this.i)
//改为
if(obj.i == this.i)

答案是会报错，由于前面说了，父类的对象是不能够直接访问子类对象所特有的属性方法~！