详解 方法的覆盖 —— toString() 与 equals()的覆盖
在学习本篇博文前，建议先学习完本人的博文——《详解 继承（上）—— 工具的抽象与分层》
在本人之前的博文中曾讲过“基类”的知识，那么，本篇博文中的主题——Object类 和 基类的知识就密切相关了，那么，我们就直接进入主题吧。
Object类 是JAVA所提供的一个类类型，且是 所有类的基类。
因为所有类都继承于 Object类，所以，Object类的方法 自然而言就成为 其他类的方法。
而在特殊情况下，子类继承父类时，对于父类的方法的实现过程可能不太满意。
为了处理这种情况，Java也提供了一个机制——覆盖（或者叫做“方法重写”）
一般我们称其为“覆盖”，因为“覆盖”相对而言比较具体形象，而“方法重写” 容易和 本人之前博文中所讲解的 “方法重载”混淆。
下面我们来验证一下上述结论：
由上图可知：我们并没有建立Object类，但是我们却可以调用它的方法，而且它提供了很多方法。
那么，本人在这里来讲解一下有关“覆盖”的 注意事项：
注意事项：
- 父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承- 子类重写父类方法时，访问权限不能更低, 最好就一致
- 父类静态方法，子类也必须通过静态方法进行重写
我们这篇博文中就主要讲解 Object类 中的 equals()方法 和 toString()方法 的覆盖：
toString()方法 的覆盖：
首先，本人来介绍一下这个方法的用途吧：
用途：
- 若我们部队这个方法进行重写（覆盖），则返回值为：包名称.类名称@这个对象的首地址
- 一般我们根据目标对象的类的成员去重写这个方法，以便我们能够得到这个对象的各成员的值
本人用一段代码 和 它的运行结果 来展示一下toString()方法：
还是用我们上一篇博文中的类，来看看这个函数的返回值：
（这里任何类都可以，本人为了缩短读者们的阅读量，所以调用上篇博文的类）
package com.mec.about_override.demo;
public class Demo {
public static void main(String[] args) {
Animal animal =new Animal("动物");
System.out.println(animal);
}
}
由上图可以看出：
而且，在一个类的对象 被输出 或者 转换为 String类型时，JVM自动调用toString()方法。
toString()方法的参数是 “一个类的对象”；
返回值是 “包名称.类名称@这个对象的首地址” 。
现在，本人来编写两个类，并且使其中一个类继承另一个类
在子类中对 toString()方法 进行覆盖：
Animal.java:
package com.mec.about_override.demo;
public class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void cry() {
System.out.println("动物的叫声！");
}
}
Dog.java:
package com.mec.about_override.demo;
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
public void cry() {
System.out.println("汪汪");
}
public void dogAction() {
System.out.println("狗子快跑！");
}
@Override
public String toString() {
return "我是" + getName();
}
}
Demo.java:
package com.mec.about_override.demo;
public class Demo {
public static void main(String[] args) {
Dog dog = new Dog("二愣子");
System.out.println(dog);
}
}
对比 上图 和 代码改动之前的测试结果，可以清晰地看到，toString()方法 被我们根据我们的用途覆盖了！
equals()方法 的覆盖：
首先，本人先来介绍一下这个方法的主要用途：
用途：
- 若我们不对这个方法覆盖，调用时将比较两个对象的地址值：
若相同，则返回true；反之，则返回false- 一般我们根据这两个对象的类的成员去重写这个方法，以便比较这两个对象的各成员的值是否相同
那么，本人用一段代码 和 它的运行结果 来展示一下equals()方法：
MecPoint.java:
package com.mec.about_equals.core;
public class MecPoint {
private int row; //private表示这个变量只能在该类中被调用。用于防止外类修改该成员
private int col;
public final int MIN_ROW = 1;
public final int MAX_ROW = 25;
public final int DEFAULT_ROW = 12;
public final int MIN_COL = 1;
public final int MAX_COL = 80; //屏幕点坐标范围：共25行、80列
public final int DEFAULT_COL = 40; //默认屏幕点坐标错误时，设为中值
public MecPoint() {
setRow(0);
setCol(0);
}
public MecPoint(int x, int y) {
setRow(x);
setCol(y);
}
public MecPoint(int x) {
setRow(x);
setCol(0);
}
public MecPoint(MecPoint point) {
setRow(point.row);
setCol(point.col);
}
public void setPoint(int x, int y) {
setRow(x);
setCol(y);
}
public void setPoint(int x) {
setPoint(x, 0);
}
public void setPoint(MecPoint source) {
setPoint(source.row, source.col);
}
public void setRow(int x) {
if(x <= MIN_ROW || x > MAX_ROW) { //对x范围进行约束
x = DEFAULT_ROW;
}
row = x;
}
public int getRow() {
return row;
}
public void setCol(int y) {
if(y <= MIN_COL || y > MAX_COL) { //对y范围进行约束
y = DEFAULT_COL;
}
col = y;
}
public int getCol() {
return col;
}
public void printPoint() {
System.out.println("(" + row + "," + col +")");
}
@Override
public String toString() {
return "(" + row + "," + col + ")";
}
}
Test.java:
package com.mec.about_equals.core;
public class Test {
public static void main(String[] args) {
MecPoint pointOne = new MecPoint(3,4);
MecPoint pointTwo = new MecPoint(3,4);
System.out.println(pointOne);
System.out.println(pointTwo);
System.out.println(pointOne == pointTwo);
}
}
现在，我们来看看运行结果：
可以看到的是，最后一句的输出是 false 。
我们明明给两个对象的成员赋的值是一样的，为什么还是false呢？
这样的结果并不奇怪，因为JAVA对于类对象的 == 比较，是对其首地址的比较，而那两个变量占用的是不同的空间，所以无论如何，结果都是false。
现在就是来介绍 equals()方法 的时候啦，现在，我们来给 Test.java 增加一行代码，看看运行结果：
哦吼，结果还是false，难道我介绍错了吗？
知道本人一贯作风的同学知道，本人现在在“故弄玄虚”。
没错，这个方法并没有错，但是，这个函数是 Object类 提供的，MecPoint类 只是继承这个方法而已，这个方法并不会自动实现对 row 和 col 成员的比较。
本人先来介绍一个关键字——instanceof：
instanceof关键字 ；
（1）左边是一个对象，右边是一个类名称；
（2）这个对象必须是 这个类 或者 这个类的子类；
（若不满足这一点，则编译不通过，无法运行）
（3）若 左边的对象 是 右边的类 或者 这个类的子类，则返回 true，
若 右边的类是 左边的对象的类 或者 这个对象的类的子类，则返回 false。
好了，我们现在来处理一下之前的问题：
我们在MecPoint.java中加入以下代码：
@Override
public boolean equals(Object obj) {
if(null == obj) {
return false;
}
if(this == obj) {
return true;
}
if(!(obj instanceof MecPoint)) {
return false;
}
MecPoint otherPoint = (MecPoint) obj;
return this.row == otherPoint.row
&& this.col == otherPoint.col;
}
但是，在这里本人还要提出的一点，就是：我们在未来编写代码时，若是想要 覆盖equals()方法，一般都会先覆盖hashcode()，关于这个操作的原因，请观看以下博文：
《覆盖equals时总要覆盖hashCode》
（至于这个知识点，我们可以先不深入了解，但是，养成良好的代码规范，在未来的工作中是很重要的！）
最后，要注意的是：
基类的用 final 修饰的方法，不能再子类中被覆盖。
