Java 方法重写与重载的区别 示例 重载多数相加求和 重写toString()和equals()

Java 方法重写与重载的区别

• 重载：在同一个类中，当方法名相同，形参列表不同的时候 多个方法构成了重载
• 重写：在不同的类中，子类对父类提供的方法不满意的时候，要对父类的方法进行重写。

名称\属性	English	位置	修饰符	返回值	方法名	参数	异常	方法体
重载	overload	同一类中	---	---	必须相同	不同	无关	必须不同
重写	override	父类子类中	父类<子类	父类>子类		相同	<=

重载

• 重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
• 每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
• 最常用的地方就是构造器的重载。

条件

• 形参类型、形参个数、形参顺序不同

// 类型不同
add(int num1)   add(double num1)
// 个数不同
add()   add(int num1)   add(int num1,int num2)
// 顺序不同
add(int num1,double num2)   add(double num1,int num2)

• 只有返回值不同不构成方法的重载

// 返回值不同,不构成方法重载
int a(String str)    void a(String str)

• 只有形参的名称不同，不构成方法的重载

// 形参的名称不同,不构成方法重载
int a(String str)    int a(String s)

代码示例

public class Test001 {
    public static void main(String[] args) {

        System.out.println(add(10, 20));

        //System.out.println(add(add(20,40),80));
        System.out.println(add(20, 40, 80));

        //System.out.println(add(add(30,60),add(90,120)));
        System.out.println(add(30, 60, 90, 120));

        //System.out.println(add(9.8,4.7));
        System.out.println(add(9.8, 4.7));
    }

    public static int add(int num1, int num2) {
        return num1 + num2;
    }

    public static int add(int num1, int num2, int num3) {
        return num1 + num2 + num3;
    }

    public static int add(int num1, int num2, int num3, int num4) {
        return num1 + num2 + num3 + num4;
    }

    public static double add(double num1, double num2) {
        return num1 + num2;
    }
}

30
140
300
14.5

重写

• 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

• 重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

• 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

  • 例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception异常，因为 Exception是 IOException的父类，只能抛出 IOException的子类异常。

条件

• 子类的方法名字和父类必须一致，参数列表（个数，类型，顺序）也要和父类一致。

例如对toString 和equals重写

重写示例

首先我们创建简易的Person类

public class Person {
    String name;
    int age;
    double height;

    public Person() {  //空构造器
    }

    //全参构造器
    public Person(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
}

创建Test类来调用

public class Test {
    public static void main(String[] args) {
        Person fyz = new Person("fyz", 18, 178);
        Person zc = new Person("fyz", 18, 178);

        System.out.println(fyz);
        System.out.println(zc);
        System.out.println(fyz.equals(zc));
    }
}

运行结果

com.skprimin.demo2.Person@1b6d3586
com.skprimin.demo2.Person@4554617c
false

众所周知Java所有类均默认继承自Object类，我们查阅Object源码得知

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
public boolean equals(Object obj) {
    return (this == obj);
}

重写toString()和equals()

显然我们对这个默认方法并不满意，故而重写这两个方法，IDEA中可以使用快捷键Alt + Insert

@Override
public String toString() {
    return "Person{" +
            "name='" + name + '\'' +
            ", age=" + age +
            ", height=" + height +
            '}';
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return age == person.age &&
            Double.compare(person.height, height) == 0 &&
            Objects.equals(name, person.name);
}

再次运行Test测试类

得到了我们想要的运行结果

Person{name='fyz', age=18, height=178.0}
Person{name='fyz', age=18, height=178.0}
true