Java：重写和重载的详细区别

我不是女神ヾ 2024-03-25 13:20 164阅读 0赞

> 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

#### Java：重写和重载的详细区别 ####

*  前言
 *  一、重写
 *  二、重载
 *  三、综合比较
 *  总结

--------------------

## 前言 ##

很多朋友在开发过程中其实经常碰到Java的重写与重载，但是很多时候关注的是如何使用，没有考虑过他们的具体差别和各自的含义。

本文的目的在于尽可能详细的对重写和重载进行比较分析。

--------------------

## 一、重写 ##

从字面上看，重写就是重新写一遍的意思。**其实就是在子类中把父类本身有的方法重新写一遍。**

**子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(或者子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。**

**拓展：访问修饰符权限大小**

public > protected > default > private

**代码示例**

public class Father {
        
     public static void main(String[] args) {
        
     // TODO Auto-generated method stub
     	Son s = new Son();
     	s.sayHello();
     }
     public void sayHello() {
        
     	System.out.println("Hello");
     }
    }
    class Son extends Father{
        
     @Override
     public void sayHello() {
        
     	// TODO Auto-generated method stub
     	System.out.println("hello by ");
     }
    }

总结：

1.发生在父类与子类之间

2.方法名，参数列表，返回类型（户这话子类中方法的返回类型是父类中返回类型的子类）必须相同

3.访问修饰符的限制一定要大于或等于被重写方法的访问修饰符  
（public>protected>default>private)

4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

5.构造方法不能被重写

**拓展：重写的“陷阱”分析**

**在子类重写父类的方法的时候，经常会出现一个“陷阱”，即自己认为的和系统输出的不相符。**

**陷阱的代码示例：**

public class Person {
        
        String name;
        int age;
    
        //test:重写
        public Person overRide() {
        
            Person per = new Person();
            per.name = "liu";
    
            return per;
        }
    }
    
    public class Student extends Person {
        
        String stuNumber;
        int score;
    
        //test:重写
        public Student overRide() {
        
            Student stu = new Student();
            stu.name = "li";
    
            return stu;
        }
    }
    
    public class TestMain {
        
    
        public static void main(String[] args) {
        
            Student stu = new Student();
            Person per = new Person();
    
            per = stu.overRide();
            System.out.println(per.name);
            per = per.overRide();
            System.out.println(per.name);
    }

**很多朋友认为输出的内容如下所示：**

li liu

**但实际上输出的内容是：**

li li

**原因在于：per = stu.overRide();返回的是一个stu对象，再调用per.overRide()方法的时候，实际上调用的就是stu.overRide()，因此两次输出的内容一致！**

**更多内容可以参考**：[Java学习笔记13—如何理解“子类重写父类方法时，返回值若为类类型，则必须与父类返回值类型相同或为其子类”][Java_13]

## 二、重载 ##

**在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。**

**重载的典型例子：不同参数列表的构造方法。**

**代码示例**

public class Father {
        
    	 public static void main(String[] args) {
        
    		 // TODO Auto-generated method stub
    		 Father s = new Father();
    		 s.sayHello();
    		 s.sayHello("wintershii");
    	 }
    	 public void sayHello() {
        
    	 	System.out.println("Hello");
    	 }
    	 public void sayHello(String name) {
        
    	 	System.out.println("Hello" + " " + name);
    	 }
    }

总结：

1.重载Overload是一个类中多态性的一种表现

2.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)

3.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

**更多内容可以参考**：[重写与重载的区别][Link 1]

## 三、综合比较 ##

<table> 
 <thead> 
  <tr> 
   <th>重写</th> 
   <th>重载</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>发生在子类和父类中</td> 
   <td>发生在同一个类中</td> 
  </tr> 
  <tr> 
   <td>对返回值有要求：必须相同或者是子类</td> 
   <td>对返回值无要求</td> 
  </tr> 
  <tr> 
   <td>参数列表必须相同</td> 
   <td>参数列表必须不同</td> 
  </tr> 
  <tr> 
   <td>访问修饰符的限制一定要大于或等于被重写方法的访问修饰符</td> 
   <td>对访问修饰符没有要求</td> 
  </tr> 
 </tbody> 
</table>

--------------------

## 总结 ##

本文对重写和重载做了尽可能的分析和比较。

希望对大家有用！

[Java_13]: https://www.cnblogs.com/chanchan/p/7796472.html
[Link 1]: https://blog.csdn.net/luoro/article/details/118307852