【面向对象特性】继承——super关键字、方法重写

继承

1.定义

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有的数据属性和行为，并能扩展新的能力。
继承是类与类之间的关系，与现实中的继承（儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。
如果B类继承于A类，那么B就拥有A的方法和属性。

2.实现

继承使用extends关键字

• Java中只有单继承，没有多继承！（一个儿子只能有一个父亲，但一个父亲可以有好几个孩子）
• 继承是类与类之间的一种关系。除此之外，类与类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有“is a”的关系。

父类：

package com.oop.demo05;
//人
//在Java中，所有的类都默认直接或间接继承Object
public class Person {
    //public
    //private私有的子类就不能继承父类
    private int money=10_0000_0000;
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public void say(){
        System.out.println("说了一句话");
    }
}

子类：

package com.oop.demo05;
//学生  is  人
//子类继承了父亲，就会拥有父亲的全部方法
public class Student extends Person {
   
    }
}

实现：

package com.oop;
import com.oop.demo05.Student;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }
}

3.super关键字

super可以理解为父类的，super可以用来调用属性、方法、构造器。

• super调用属性

  父类：

  package com.oop.demo05;
  //人
  public class Person {
      protected String name="张三"; 
  }
  

  子类:

  package com.oop.demo05;
  //学生  is  人
  //子类继承了父亲，就会拥有父亲的全部方法
  public class Student extends Person {
      private String name="haojiale";
      public void test(String name){
          System.out.println(name);//郝佳乐
          System.out.println(this.name);//haojiale
          System.out.println(super.name);//张三
      }
  
  }
  

  实现：

  package com.oop;
  import com.oop.demo05.Student;
  public class Application {
      public static void main(String[] args) {
          Student student = new Student();
          student.test("郝佳乐");
          
      }
  }
  

在子类Student中System.out.println(name);输出的是传进来的值， System.out.println(this.name);输出的是当前类的属性值， System.out.println(super.name);是使用super关键字调用父类Person中的属性。

• super调用方法

  父类：

  package com.oop.demo05;
  //人
  public class Person {
      //修饰符如果改为private，私有的东西无法继承！
      public void print(){
          System.out.println("Person");
      }
  }
  

  子类：

  package com.oop.demo05;
  //学生  is  人
  //子类继承了父亲，就会拥有父亲的全部方法
  public class Student extends Person {
      public void print(){
          System.out.println("Student");
      }
      public void test1(){
          print();//Student
          this.print();//Student
          super.print();//Person
      }
  }
  

  实现：

  package com.oop;
  import com.oop.demo05.Student;
  public class Application {
      public static void main(String[] args) {
          Student student = new Student();
          student.test1();
      }
  }
  

• super调用构造器

  父类：

  package com.oop.demo05;
  //人
  public class Person {
       public Person(){
          System.out.println("Person无参执行了");
      }
  }
  

  子类：

  package com.oop.demo05;
  //学生  is  人
  //子类继承了父亲，就会拥有父亲的全部方法
  public class Student extends Person {
      public Student(){
          //隐藏代码：调用了父类的无参构造
          //super();调用父类的构造器必须在子类构造器的第一行
          System.out.println("Student无参执行了");
      }
  }
  

  实现：

  package com.oop;
  import com.oop.demo05.Student;
  public class Application {
      public static void main(String[] args) {
          Student student = new Student();
      }
  }
  

在调用父类构造器的时候，子类中有一行隐藏代码super();调用父类的构造器，这行代码可以不用写，也会自动调用父类的无参构造。

super注意点：

​ 1.super调用父类的构造方法，必须在构造方法的第一行
​ 2.super必须只能出现在子类的方法或构造方法中
​ 3.super和this不能同时调用构造方法，因为它俩都必须在构造方法的第一行

super与this的对比：

​ 1.代表的对象不同
​ this：本身调用者这个对象
​ super：代表父类对象的应用
​ 2.前提
​ this：没有继承也可以使用
​ super：只能在继承条件下才可以使用
​ 3.构造方法
​ this(); 本类的构造
​ super(); 父类的构造

4.方法重写

方法的重写是指两个方法的返回值、方法名、参数的类型和个数相同（子类重写父类的方法），方法的重写不能发生在同类中，只能发生在子类中，方法的重写新的方法将覆盖原有的方法。

父类：

package com.oop.demo05;
public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

子类：

package com.oop.demo05;
public class A extends B {
    @Override 
    public void test() {
        System.out.println("A=>test()");
    }
}

实现：

package com.oop;
import com.oop.demo05.A;
import com.oop.demo05.B;
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();
        B b = new A();//子类重写了父类的方法
        b.test();
    }
}

重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.方法重写的权限：修饰符范围可以扩大 public>Protected>Defalut>private
4.抛出异常：范围可以被缩小但不能扩大 ClassNotFoundException–>Exception(大)
子类的方法和父类必须一致；方法体可以不同
为什么需要重写：
1.父类的功能，子类不一定需要或者不一定满足