面向对象：7.1、方法的重写

面向对象：7.1、方法的重写

1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.
2. 静态方法不能重写
   1. 父类的静态方法不能被子类重写为非静态方法
   2. 父类的非静态方法不能被子类重写为静态方法
   3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。

1. 重写的语法
   1. 方法名必须相同
   2. 参数列表必须相同
   3. 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
   4. 抛出异常类型的范围可以被缩小,但是不能被扩大
      ClassNotFoundException ---> Exception
   5. 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型
      **例如：**父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的子类型

注：一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括号中代码不一样)

为什么要重写？

子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需
要把方法进行重写。

总结

方法重写的时候，必须存在继承关系。

方法重写的时候，方法名和形式参数 必须跟父类是一致的。

方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <public，friendly < public )

方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系

方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

代码实现

package com.hsy.extend.methodOverride;

public class Person {
   
   String name;
   int age;
   
   public Person(){
      
   }
   public Person(String name,int age){
      this.name = name;
      this.age = age;
   }
   
    void eat(){
      System.out.println("吃饭");
   }
   public void walk(int distance){
      System.out.println("走路,走的距离是：" + distance + "公里");
      show();
      eat();
   }
   
   private void show(){
      System.out.println("我是一个人");
   }
   
   public Object info(){
      return null;
   }
   
   public double info1(){
      return 1.0;
   }

}

package com.hsy.extend.methodOverride;

public class Student extends Person{

   String major;
   
   public Student(){
      
   }
   public Student(String major){
      this.major = major;
   }
   
   public void study(){
      System.out.println("学习。专业是：" + major);
   }
   
   //对父类中的eat()进行了重写
   public void eat(){
      System.out.println("学生应该多吃有营养的食物");
   }
   
   public void show(){
      System.out.println("我是一个学生");
   }
   
   public String info(){
      return null;
   }
   
// public int info1(){
//    return 1;
// }
   
// public void walk(int distance){
//    System.out.println("重写的方法");
// }
   
   
   public void walk(int distance) {
      System.out.println("重写的方法");
   }

}

package com.hsy.extend.methodOverride;
/*
 * 方法的重写(override / overwrite)
 * 
 * 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
 * 
 * 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
 * 
 * 3. 重写的规定：
 *           方法的声明： 权限修饰符  返回值类型  方法名(形参列表) throws 异常的类型{
 *                    //方法体
 *                 }
 *           约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
 *        ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
 *      ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
 *         >特殊情况：子类不能重写父类中声明为private权限的方法
 *      ③ 返回值类型：
 *         >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
 *         >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
 *         >父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
 *    ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
 * **********************************************************************
 *    子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。
 *
 * 面试题：区分方法的重载与重写
 */
public class PersonTest {
   
   public static void main(String[] args) {
      
      Student s = new Student("计算机科学与技术");
      s.eat();
      s.walk(10);
      
      System.out.println("**************");
      
      s.study();
      
      Person p1 = new Person();
      p1.eat();
      
   }
}