Javase学习04-类的重写

JavaseLearn04-类的重写

1. 思考问题：

在以后敲代码的过程中，常常会需要比较两个对象的值，那么该如何实现呢？

/**
 * @author: TSCCG
 * @date: 2021/4/25
 */
public class Sson {
    private String age;
    public Sson(String age) {
        this.age = age;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
    /**
    *程序入口
    */
    public static void main(String[] args) {
        Sson sson1 = new Sson("30");
        Sson sson2 = new Sson("30");
        System.out.println("结果1：" + (sson1 == sson2));
        System.out.println("结果2：" + (sson1.equals(sson2)));
    }
}

运行结果：

结果1：false
结果2：false

为什么会出现上述结果？

结果1：

​ 当使用Sson类创建一个对象时，会在堆中加载一块内存空间存储数据并指向这块内存，每创建一个对象就加载一块新的内存空间，创建的对象就指向一个新的地址。如下图所示：

结果1进行" == "比较时，比较的是两个引用，而引用存储的是两个对象在堆内存中的地址，故结果为false.

结果2：

子类可以调用父类中非私有的方法，顶级父类Object中equals方法的代码为：

public boolean equals(Object obj) {
        return (this == obj);
    }

而Sson类并未重写equals方法，所以和结果1一致，为false

2. 如何比较两个对象？

父类方法无法满足子类需求，那么就在子类中重写该方法：

public class Sson {
    private int age;
    public Ffather(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    /**
     * 重写equals方法，使Sson对象可以比较值
     * @param obj
     * @return
     */
    @Override
    public boolean equals(Object obj) { //对象会以Object类型传过来
        Sson sson;
        if(obj instanceof Sson) { //判断传入的obj是否是Sson类型
            sson = (Sson)obj; //强转回Sson类型
            if(this.getAge().equals(sson.getAge()) ){ //比较对象的值
                return true;
            }

        }
        return false;
    }
    /**
    *程序入口
    */
    public static void main(String[] args) {
        Sson sson1 = new Sson("30");
        Sson sson2 = new Sson("30");
        System.out.println("结果1：" + (sson1 == sson2));
        System.out.println("结果2：" + (sson1.equals(sson2)));
    }
}

运行结果：

结果1：false
结果2：true

3. 重写toString

toString方法是Object类里的方法，作用是返回对象的字符串表示形式。

我们看下面例子：

先创建一个Name类，然后创建一个Name对象，赋值为"张三"。

接着输出两次：

• 第一次：直接输出该对象的引用name
• 第二次：通过name调用toString()方法后输出

/**
 * @Author: TSCCG
 * @Date: 2021/07/02 20:01
 */
public class ToDemo01 {
    public static void main(String[] args) {
        Name name = new Name("张三");
        System.out.println(name);
        System.out.println(name.toString());
        /*
          public String toString() {
                  return getClass().getName() + "@" + Integer.toHexString(hashCode());
              }
         */
    }
}
class Name {
    private String name;

    public Name(String  name) {
        this.name = name;
    }
}

结果：

Name@28d93b30
Name@28d93b30

由结果可见，直接输出对象引用和通过name调用toString方法后再输出的结果是一样的。

这说明在直接输出对象引用时会自动调用toString方法。

而我们现在想把"张三"打印出来，就必须重写Object类中的toString方法：

/**
 * @Author: TSCCG
 * @Date: 2021/07/02 20:01
 */
public class ToDemo01 {
    public static void main(String[] args) {
        Name name = new Name("张三");
        System.out.println(name);
        System.out.println(name.toString());
    }
}
class Name {
    private String name;

    public Name(String  name) {
        this.name = name;
    }

    /**
    * 该方法返回值为String类型，当name为其他类型的元素时，需要将一段字符串与name拼接起来
    * 如：return name + " ";
    */
    @Override
    public String toString() {
        return name;
    }
}

结果：

张三
张三

4. 总结：

当父类中的方法无法满足子类需求时，就要重写父类的方法