Java方法重写与重载的区别

た入场券 2022-05-15 01:54 251阅读 0赞

# Java方法重写与重载 #

## 一、方法重写(0veriding) ##

在Java程序中，类的继承关系可以产生一个子类，子类继承父类，它具备了父类所有的特征，继承了父类所有的方法和变量。

子类可以定义新的特征，当子类需要修改父类的一些方法进行扩展，增大功能，程序设计者常常把这样的一种操作方法称为重写，也叫称为覆写或覆盖。

重写体现了Java优越性，重写是建立在继承关系上，它使语言结构更加丰富。在Java中的继承中，子类既可以隐藏和访问父类的方法，也可以覆盖继承父类的方法。

在Java中覆盖继承父类的方法就是通过方法的重写来实现的。所谓方法的重写是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型。

这样，就可以实现对父类方法的覆盖。如果子类将父类中的方法重写了，调用的时候肯定是调用被重写过的方法，那么如果现在一定要调用父类中的方法该怎么办呢?

此时，通过使用super关键就可以实现这个功能，super关键字可以从子类访问父类中的内容，如果要访问被重写过的方法，使用“super.方法名(参数列表)”的形式调用。

如果要使用super关键字不一定非要在方法重写之后使用，也可以明确地表示某个方法是从父类中继承而来的。使用super只是更加明确的说，要从父类中查找，就不在子类查找了。

重写的好处在于子类可以根据需要，定义特定于自己的行为。  
也就是说子类能够根据需要实现父类的方法。  
在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
        
     public void move(){
      System.out.println("动物可以移动");
     }
    }
    class Dog extends Animal{
        
     public void move(){
      System.out.println("狗可以跑和走");
     }
    }
    public class TestDog{
        
     public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
     }
    }
    
    //运行结果
    动物可以移动
    狗可以跑和走

在上面的例子中可以看到，尽管b属于Animal类型，但是它运行的是Dog类的move方法。

这是由于在编译阶段，只是检查参数的引用类型。

然而在运行时，Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。  
因此在上面的例子中，之所以能编译成功，是因为Animal类中存在move方法，然而运行时，运行的是特定对象的方法。  
思考以下例子：

class Animal{
        
     public void move(){
      System.out.println("动物可以移动");
     }
    }
    class Dog extends Animal{
        
     public void move(){
      System.out.println("狗可以跑和走");
     }
     public void bark(){
      System.out.println("狗可以吠叫");
     }
    }
    public class TestDog{
        
     public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
     }
    }
    //以上实例编译运行结果如下：
    TestDog.java:30: cannot find symbol
    symbol : method bark()
    location: class Animal
        b.bark();

该程序将抛出一个编译错误，因为b的引用类型Animal没有bark方法。

## 二、重写规则 ##

在重写方法时，需要遵循以下的规则：  
(一) 父类方法的参数列表必须完全与被子类重写的方法的参数列表相同，否则不能称其为重写而是重载。

(二) 父类的返回类型必须与被子类重写的方法返回类型相同，否则不能称其为重写而是重载。

(三) Java中规定，被子类重写的方法不能拥有比父类方法更加严格的访问权限。编写过Java程序的人就知道，父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错。

(四) 由于父类的访问权限修饰符的限制一定要大于被子类重写方法的访问权限修饰符，而private权限最小。所以如果某一个方法在父类中的访问权限是private，那么就不能在子类中对其进行重写。如果重新定义，也只是定义了一个新的方法，不会达到重写的效果。

(五) 在继承过程中如果父类当中的方法抛出异常，那么在子类中重写父类的该方法时，也要抛出异常，而且抛出的异常不能多于父类中抛出的异常(可以等于父类中抛出的异常)。换句话说，重写方法一定不能抛出新的检查异常，或者比被重写方法声明更加宽泛的检查型异常。例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法时就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常。同样的道理，如果子类中创建了一个成员变量，而该变量和父类中的一个变量名称相同，称作变量重写或属性覆盖。但是此概念一般很少有人去研究它，因为意义不大。

**Super关键字的使用**  
当需要在子类中调用父类的被重写方法时，要使用super关键字。

class Animal{
        
     public void move(){
      System.out.println("动物可以移动");
     }
    }
    class Dog extends Animal{
        
     public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
     }
    }
    public class TestDog{
        
     public static void main(String args[]){
      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法
     }
    }
    
    //以上实例编译运行结果如下：
    动物可以移动
    狗可以跑和走

## 三、方法重载(Overloading) ##

方法重载是让类以统一的方式处理不同类型数据的一种手段。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。

所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。

方法的重载在实际应用中也会经常用到。不仅是一般的方法，构造方法也可以重载。

在方法重载时，方法之间需要存在一定的联系，因为这样可以提高程序的可读性，一般只重载功能相似的方法。

重载是指我们可以定义一些名称相同的方法，通过定义不同的参数来区分这些方法，然后再调用时，Java虚拟机就会根据不同的参数列表来选择合适的方法执行。也就是说，当一个重载方法被调用时，Java用参数的类型或个数来决定实际调用的重载方法。因此，每个重载方法的参数的类型或个数必须是不同。

虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。

当Java调用一个重载方法是，参数与调用参数匹配的方法被执行。在使用重载要注意以下的几点:  
1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。  
2.不能通过访问权限、返回类型、抛出的异常进行重载。  
3.方法的异常类型和数目不会对重载造成影响。  
4.可以有不同的返回类型，只要参数列表不同就可以了。  
5.可以有不同的访问修饰符。  
6.可以抛出不同的异常。

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

## 四、重载规则 ##

被重载的方法必须改变参数列表；  
被重载的方法可以改变返回类型；  
被重载的方法可以改变访问修饰符；  
被重载的方法可以声明新的或更广的检查异常；  
方法能够在同一个类中或者在一个子类中被重载。

public class Overloading { 
     public int test(){
     System.out.println("test1");
     return 1;
     } 
     public void test(int a){
     System.out.println("test2");
     } 
     //以下两个参数类型顺序不同
     public String test(int a,String s){
     System.out.println("test3");
     return "returntest3";
     } 
     public String test(String s,int a){
     System.out.println("test4");
     return "returntest4";
     } 
     public static void main(String[] args){
     Overloading o = new Overloading();
     System.out.println(o.test());
     o.test(1);
     System.out.println(o.test(1,"test3"));
     System.out.println(o.test("test4",1));
     }
    }

## 五、访问修饰符 ##

<table> 
 <thead> 
  <tr> 
   <th>访问修饰符</th> 
   <th>本类</th> 
   <th>同包</th> 
   <th>子类</th> 
   <th>其他</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>private</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>默认</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>public</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
 </tbody> 
</table>

## 六、总结 ##

重写与重载之间的区别

方法重载：  
1、同一个类中  
2、方法名相同，参数列表不同（参数顺序、个数、类型）  
3、方法返回值、访问修饰符任意  
4、与方法的参数名无关

方法重写：  
1、有继承关系的子类中  
2、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同  
3、访问修饰符，访问范围需要大于等于父类的访问范围  
4、与方法的参数名无关

<table> 
 <thead> 
  <tr> 
   <th>区别点</th> 
   <th>重载方法</th> 
   <th>重写方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>参数列表</td> 
   <td>必须修改</td> 
   <td>一定不能修改</td> 
  </tr> 
  <tr> 
   <td>返回类型</td> 
   <td>可以修改</td> 
   <td>一定不能修改</td> 
  </tr> 
  <tr> 
   <td>异常</td> 
   <td>可以修改</td> 
   <td>可以减少或删除，一定不能抛出新的或者更广的异常</td> 
  </tr> 
  <tr> 
   <td>访问</td> 
   <td>可以修改</td> 
   <td>一定不能做更严格的限制（可以降低限制）</td> 
  </tr> 
 </tbody> 
</table>