Java学习之方法重载和方法重写（覆盖）比较

我就是我 2022-08-04 12:37 231阅读 0赞

# 方法重载和方法覆盖 #

请带着下面两点来看文章：

1.  覆盖即重写，覆盖不等于重载，即重写不等于重载。
2.  覆盖（重写）蕴含继承性，而重载只能在本类中使用，不含继承。

## 方法名和参数列表的比较 ##

### 方法覆盖中的方法名和参数 ###

首先创建基类Shape：

public class Shape { 
       
          
       
        public void draw() { 
       
        System.out.println("Shape.draw()"); 
       
        } 
       
        }

子类Circle：

public class Circle extends Shape { 
       
          
       
        public void draw() { 
       
        System.out.println("Circle.draw()"); 
       
        } 
       
        }

>注意：子类没有在方法上添加\`@Override\`注解

此时修改父类Shape的draw方法名为draw1 ：

/*public void draw() { 
       
        System.out.println("Shape.draw()"); 
       
        }*/ 
       
        
       
        public void draw1() { 
       
        System.out.println("Shape.draw()"); 
       
        }

编译器不会报错，因为子类的\`draw()\`并没有覆盖（重写）父类的\`draw()\`，现在在子类Circle的draw方法上添加注解\`@Override\`，此时子类Circle如下，**下划线表示该方法报错（下面不再说明）** ：

/*public void draw() { 
       
        System.out.println("Circle.draw()"); 
       
        }*/ 
       
        
       
        @Override 
       
        public void draw() { 
       
        System.out.println("Circle.draw()"); 
       
        }

此时，编译器报错，提示：子类Cricle的draw方法必须重写或实现父类的draw1方法。

结论： **重写父类方法时必须加\`@Override\`注解，且方法名要相同。**

再修改父类的方法如下：

/*public void draw() { 
        
         System.out.println("Shape.draw()"); 
        
         }*/ 
        
         
        
         
        
         /*public void draw1() { 
        
         System.out.println("Shape.draw()"); 
        
         }*/ 
        
         
        
         public void draw(int i) { 
        
         
        
         }

子类如下：

... 
        
         /*@Override 
        
         public void draw() { 
        
         System.out.println("Circle.draw()"); 
        
         }*/ 
        
         
        
         @Override 
        
         public void draw(float i) { 
        
         System.out.println("Circle.draw()"); 
        
         }

子类的覆盖方法报错，提示：必须实现父类的相关方法或移除\`@Override\`注解。

在修改子类draw方法如下：

@Override 
        
         public void draw(int i, int j) { 
        
         super.draw(i); 
        
         }

子类的覆盖方法也报如上错误。

结论： **重写或覆盖父类方法时，参数类型和参数列表个数必须相同。**

### **方法重载中的方法名和参数** ###

在Cricle类中添加以下方法：

... 
        
         public void erase() { 
        
         System.out.println("Circle.erase()"); 
        
         } 
        
         }

编译器报错，提示重复的erase()方法。

修改后如下：

public void erase() { 
        
         System.out.println("Circle.erase()"); 
        
         } 
        
         
        
         public void erase(int i) { 
        
         System.out.println("Circle.erase()"); 
        
         }

编译通过。

伪论（下面给出证明）： **重载的方法名相同，但参数个数必须不同。**

在修改Cricle类如下：

... 
       
        public void erase(int i, int j) { 
       
        System.out.println("Circle.erase()"); 
       
        } 
       
        
       
        public void erase(int i, String s) { 
       
        System.out.println("Circle.erase()"); 
       
        }

编译通过。

结论： **重载的方法名必须相同，参数个数可以不同，但参数类型必须不同。一句话就是，重载的方法名必须相同且参数列表必须不同。**

## 返回值类型的比较 ##

### 方法覆盖中的返回值类型 ###

父类Shape：

...  
        
         public String draw() { 
        
         return "Shape.draw()"; 
        
         }

子类Circle：

... 
        
         @Override 
        
         public int draw() { 
        
         return super.draw(); 
        
         }

编译器不同通过。提示和父类的draw方法的返回值类型不兼容。

结论： **方法覆盖的返回值类型必须和父类相兼容。**

### 方法重载中的返回值类型 ###

Cricle类：

private int erase(int i, int j) { 
        
         return 0; 
        
         } 
        
         
        
         private void erase(int i, int j) { 
        
         System.out.println("Circle.erase()"); 
        
         }

编译不通过，提示重复的 erase(int, int)方法。

修改后：

private int erase(int i, int j) { 
         
          return 0; 
         
          } 
         
          
         
          private void erase(int i, String j) { 
         
          System.out.println("Circle.erase()"); 
         
          }

编译通过。

结论： **方法重载的返回值类型可以不同，但前提是参数列表不同。**

## 访问权限的比较 ##

### 方法覆盖中的访问权限 ###

还原父类Shape：

public class Shape { 
       
          
       
        public void draw() { 
       
        System.out.println("Shape.draw()"); 
       
        } 
       
        }

此时在子类Cricle中修改draw方法的访问权限：

@Override 
        
         private void draw() { 
        
         System.out.println("Circle.draw()"); 
        
         }

编译器报错，提示： **不能降低从父类Shape继承来的方法的可见性**。

此时无论修改子类Cricle中的draw方法的访问权限为protected、private还是默认级别都提示 不能降低从父类继承来的方法的可见性。

只能将子类的draw方法的访问权限设置为public才可以编译通过 **。**

此时修改父类draw方法的访问权限为private：

private void draw() { 
        
         System.out.println("Shape.draw()"); 
        
         }

子类：

@Override 
        
         public void draw() { 
        
         System.out.println("Circle.draw()"); 
        
         }

编译器报错，提示：必须实现父类的draw方法。

此时修改父类draw方法的访问权限为*protected *或默认级别，编译器就不报错了。

结论：**父类中被private修饰的方法无法被子类覆盖，即无法被子类继承。**

### 方法重载中的访问权限 ###

Circle类代码：

public void erase() { 
        
         System.out.println("Circle.erase()"); 
        
         } 
        
         
        
         protected void erase(int i) { 
        
         System.out.println("Circle.erase()"); 
        
         } 
        
         
        
         private void erase(int i, int j) { 
        
         System.out.println("Circle.erase()"); 
        
         } 
        
         
        
         void erase(int i, String s) { 
        
         System.out.println("Circle.erase()"); 
        
         }

编译通过。

结论： **重载方法对访问权限不敏感。**

**OK， 如果有错误或遗漏的地方请评论指出，互相交流，共同进步。谢谢！**