Java基础之重写（覆写）与重载区别

1 重写/覆写（Overriding）

1.1 定义—-标志：子承父类，对相同的方法有不同的实现。

（1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。 

（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。 

（3）子类函数的访问修饰权限不能少于父类的（public>protected>default> 

private）。 

（4）重写多态性起作用：对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。

1.2 应用场景

子类有自己特有的行为，从父类继承而不能满足自身需要时。

1.3 案例解释

1.3.1 案例

public class OverrideParent {
public void fly() {
System.out.println("Ican fly!");
}
public static void main(String[] args) {
OverrideParent parent = new OverrideChild();
parent.fly();// 重写的方法
}
}

public class OverrideChild extends OverrideParent {
@Override
public void fly() {
System.out.println("Ican't fly, but I can run!");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.3.2 结果解释

Ican't fly, but I can run!

1
1

（1）OverrideChild和OverrideParent都有一个fly方法 

（2）fly的返回值和修饰符都一样，只有方法体不一样 

（3）子类的fly方法前有一个@overwrite的注解，jdk1.5出现的，仅用于类的继承，1.6可用于接口实现。这个注解有助于编译器检查，不加也可以的。

1.4 重写规则

（1）参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。 

（2）返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。 

（3）访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected> 

default>private） 

（4）重写方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类。例如：父类的一个方法抛出了一个检查异常IOException，在重写这个方法是就不能抛出Exception，只能抛出IOException的子类异常或者非检查异常。

2 重载(Overloading)

2.1 定义—-标志：方法名相同，参数不同（个数或者类型），与返回值无关。

（1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。 

（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法,
这就是多态性。 

（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

2.2 应用场景

当方法功能相似，但需要传递不同的参数。

2.3 案例解释

public class OverloadParent{
public String getPerson(String name){// 重载
return “personA” + name;
}
public String getPerson(int age){// 重载
return “personB” ;
}
public String getPerson(String name,int age){// 重载
return “personC”;
}
public void getPerson(String name){// 返回值不一样，不构成重载，编译器不通过。
System.out.println(“我是重载的方法吗？”);
}
}

public class OverloadChildextends OverloadParent {
public void getPerson(double money){
Sytem.out.println(“我是重载的方法吗”);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.4 重写规则

（1）在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）； 

（2）不能通过访问权限、返回类型、抛出的异常进行重载； 

（3）方法的异常类型和数目不会对重载造成影响。

3 问题解释

3.1 子类不能对父类private方法重写

3.1.1 案例代码

public class OverrideParent {
private void fly(){// 父类private类型
System.out.println("Ican fly!");
}

public static void main(String[] args) {
OverrideParent parent = new OverrideChild();
parent.fly();// 父类的方法
OverrideChild child = new OverrideChild();
child.fly();// 子类的方法
}
}

public class OverrideChild extends OverrideParent {
//  @Override
public void fly() {
System.out.println("Ican't fly, but I can run!");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.1.2 案例解释

Ican fly!
Ican't fly, but I can run!

1
2
1
2

private的变量和方法对在类外是不可见的，当然更谈不上重写，OverrideChild类中看似是重写了父类OverrideParent中的fly方法，但由于父类中为private，所以OverrideChild类中的fly方法与OverrideParent类中的fly方法并无任何关系，可以认为是一个全新的方法。