java-Equals方法

1.1Equals方法

• Equals方法
  java中一般情况下,不可以再用==来比较是否相等的情况,而是要用Equals方法来比较,
  Equals方法属于Object类并且不是final类型,所以任何类都可以继承并且覆盖该方法.
  • 例子

/**
*包名
*/
package Epuals;
/**
 * 类
 * @author Lenovo
 */
public class MetHod {
/**私有属性*/
    private int rather;
    //构造器
    MetHod(int rather){
    //初始化
        this.rather=rather;
    }
    //主函数
    public static void main(String[] args) {
        //调用类  并传参
        MetHod rather=new MetHod(20);
        //调用类  并传参
        MetHod rather1=new MetHod(20);
        //打印比较是否相等
        System.out.println(rather==rather1);

    }
}  

• 这里我们先用等于来看看是什么就结果
• 
• 可以看到为false 因为在Java语言里双等于号是比较内存地址 而不是对象的任何一个值 无论如何 只要内存地址不一样就一直为false
  *注意! 对象之间不可以再用"=="来进行比较,因为这样比较的是对象的内存地址,而不是对象中的具体属性
• 在用用Equals方法来比较

package Epuals;
/**
 * 类
 * @author Lenovo
 */
public class MetHod {
    /**私有属性*/
    private int rather;
    //构造器
    MetHod(int rather){
        //初始化
        this.rather=rather;
    }
    //主函数
    public static void main(String[] args) {
        //调用类  并传参
        MetHod rather=new MetHod(20);
        //调用类  并传参
        MetHod rather1=new MetHod(20);
        //打印比较是否相等
        System.out.println(rather.equals(rather1));

    }
}

• 运行结果
• 
• 还是false 为什么呢?
• 因为Equals方法在默认Object类的默认的方法 和双等于一样的 都是比较内存地址 虽然语句不同了但实质上 和刚才的功能一样的
• 那么怎么办呢?
• 这时候我们要使用覆盖

package Epuals;
/**
 * 类
 * @author Lenovo
 */
public class MetHod {
    /**私有属性*/
    private int rather;
    //构造器
    MetHod(int rather){
        //初始化
        this.rather=rather;
    }
    /**覆盖equals方法*/   /**MetHod为类名   rather1为对象名*/
    public boolean equals(MetHod rather1){
        //if条件判断是否相等
        //this.rather为谁调用它那么this.rather就是谁
        //rather1.rather就是行参传进来的rather1就是  传进来什么就是什么
        if(this.rather==rather1.rather){
        //返回值
            return true;
        }else{
        //返回值
            return false;
        }
    }
    //主函数
    public static void main(String[] args) {
        //调用类  并传参
        MetHod rather=new MetHod(20);
        //调用类  并传参
        MetHod rather1=new MetHod(20);
        //打印比较是否相等
        System.out.println(rather.equals(rather1));

    }
}

• 运行结果
• 
• 这时候就为true了 为什么呢?
• 因为覆盖后的equals方法比较的不再是二个对象的内存地址,而是根据自己的要求来决定.本例中比较的是变量rather的值,当二个对象的rather都等于20,此时二个对象的比较结果返回true

1.2Equals方法

• Equals方法在一般情况下都需要覆盖成自己想要的方法.而且配合多态可以实现强大的"比较"功能,可以比较类中的任何数据,可以根据自己的需求来定义二个对象是否相等的条件
• 代码如下

* package Epuals;
/**
 * 类
 * @author Lenovo
 */
public class MetHod {
    /**
     * 私有属性
     */
    private int rather;

    //构造器
    MetHod(int rather) {
        //初始化
        this.rather = rather;
    }
    //创建类并继承父类所有属性
    static class MetHod2 extends MetHod {
        /**
         * 私有属性
         */
        private int fairly;

        //有参构造器
        MetHod2(int fairly) {
            //初始化
            super(fairly);
            this.fairly = fairly;
        }
    }
    /**覆盖equals方法*/
    /**
     * MetHod为类名   rather1为对象名
     */
    public boolean equals(MetHod rather1) {
        //if条件判断是否相等
        //this.rather为谁调用它那么this.rather就是谁
        //rather1.rather就是行参传进来的rather1就是  传进来什么就是什么
        if (this.rather == rather1.rather) {
            return true;
        } else {
            return false;
        }
    }
    //主函数
    public static void main(String[] args) {
        //new对象
        MetHod rather=new MetHod(20);
        //new对象
        MetHod rather1=new MetHod(20);
        //打印比较是否相等
        System.out.println(rather.equals(rather1));
        //new对象
        MetHod2 fairly=new MetHod2(100);
        //new对象
        MetHod2 fairly1=new MetHod2(20);
        //打印比较是否相等
        System.out.println(fairly.equals(fairly1));

    }
}

• 这里我新建了一个类MetHod2并继承的MetHod的所有属性与方法然后在进行打印输出看看结果
• 
• 可以看到第一个打印为true20等于20对的 而100等于20为false也是对的了
• 但是MetHod类中的方法是接收的形参是MetHod类的对象 而传进来的是MetHod2的对象 这说明这里使用了多态!
• 想用MetHod2里面的fairly来进行比较呢?
• 这样就不可以用继承过来的方法 因为继承过来的方法通过多态只可以访问从父类继承过来的变量 子类所特有的变量是不可以使用的 这样的话我们需要在子类自己写方法 覆盖
• 代码如下

* package Epuals;
/**
 * 类
 * @author Lenovo
 */
public class MetHod {
    /**
     * 私有属性
     */
    private int rather;

    //构造器
    MetHod(int rather) {
        //初始化
        this.rather = rather;
    }
    //创建类并继承父类所有属性
    static class MetHod2 extends MetHod {
        /**
         * 私有属性
         */
        private int fairly;

        //有参构造器
        MetHod2(int fairly) {
            //初始化
            super(fairly);
            this.fairly = fairly;
        }

   @Override
        //创建方法
        //这里就用多态  但更加java的语法要求就必须在下面加一个强制转换否则会报错
        //不然就用子类如  public boolean equals(MetHod2 fairly1) {  这样就不需要强制转换了
        public boolean equals(MetHod rather1) {

            //强行转换   把MetHod  rather1转换为 MetHod2 传给了metHod2
            MetHod2 metHod2 = (MetHod2) rather1;
            //if判断
            if (this.fairly == metHod2.fairly) {
                return true;
            } else {
                return false;
            }
        }
    }
    /**覆盖equals方法*/
    /**
     * MetHod为类名   rather1为对象名
     */
    public boolean equals(MetHod rather1) {
        //if条件判断是否相等
        //this.rather为谁调用它那么this.rather就是谁
        //rather1.rather就是形参传进来的rather1传进来什么就是什么
        if (this.rather == rather1.rather) {
            return true;
        } else {
            return false;
        }
    }
    //主函数
    public static void main(String[] args) {
        //new对象
        MetHod rather=new MetHod(20);
        //new对象
        MetHod rather1=new MetHod(20);
        //打印比较是否相等
        System.out.println(rather.equals(rather1));
        //new对象
        MetHod2 fairly=new MetHod2(100);
        //new对象
        MetHod2 fairly1=new MetHod2(20);
        //打印比较是否相等
        System.out.println(fairly.equals(fairly1));

    }
}

• 运行结果
• 

2.注意事项

• 1.Equals方法要把它改写如果不改写和双等于是一样的没有意义
• 2.如果要访问子类所特有的就必须要在子类再次改写