Java面向对象：继承（Object类、super、方法重写）

---

继承

• 什么是继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
  • 继承的实现需要用到extends关键字。extends的意思是"扩展"，子类是父类的扩展

• 与继承有关的注意点

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

• 代码实例

  Person类

  package com.oop.demo5;
  //Person 人 父类/基类
  public class Person {
      int money=1_0000_0000;
      public void say() {
          System.out.println("说了一句话");
      }
  }
  

  Student类

  package com.oop.demo5;
  //Student is 人 派生类/子类
  //子类能够继承父类的public和protected成员变量和成员方法；不能够继承父类的private成员变量和成员方法
  public class Student extends Person{
  }
  

  Application类

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

  

• 快捷键

  Ctrl+H：打开继承树

Object类

在Java中，所有的类，都默认直接或者间接继承Object类

super

• 代码实例

  Person类

  package com.oop.demo6;
  
  public class Person {
      protected String name="kuangshen";
      public Person() {
          System.out.println("Person无参执行了");
      }
      public void print(){
          System.out.println("Person");
      }
  }
  

  Student类

  package com.oop.demo6;
  
  public class Student extends Person{
      private String name="qinjiang";
      public Student() {//无参构造器（若父类的无参构造器被有参构造器覆盖，即父类没有无参构造器，则子类也无法定义无参构造器）
          //隐藏代码 super（）：调用父类无参构造
          //调用父类构造器的执行代码必须放在子类构造器的第一行
          //若调用本类构造器，this（”hello“），也必须放在第一行，故在本类构造器和父类构造器之中，子类只能选择其一调用
          System.out.println("Student无参执行了");
      }
      public Student(String name) {//有参构造器
          this.name = name;
      }
      public void print(){
          System.out.println("Student");
      }
      //调用父类成员变量
      public void test1(String name){
          System.out.println(name); //调用形参name
          System.out.println(this.name); //调用本类name
          System.out.println(super.name); //调用父类name
      }
      //调用父类成员方法
      public void test2(){
          print(); //调用本类方法
          this.print(); //调用本类方法
          super.print(); //调用父类方法
      }
  }
  

  Application 1 类：利用super关键字调用父类的成员变量和成员方法：

  package com.oop.demo6;
  
  public class Application1 {
      public static void main(String[] args) {
          Student student = new Student();
          student.test1("秦疆");
          System.out.println("==========");
          student.test2();
      }
  }
  

  

  Application 2 类：利用super关键字调用父类的构造器：

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

  

• 小结：

  • 使用super的注意点：

    1. 子类用super调用父类的构造方法时，调用操作的代码必须放在子类构造方法的第一行
    2. 父类私有的成员变量和成员方法无法被子类继承，子类也就无法通过super调用
    3. super只能出现在子类的方法中
    4. super和this不能同时调用构造方法

  • super和this的区别

    1. 调用的对象不同

       this：调用本类

       super：调用本类的父类

    2. 使用的前提不同

       this：没有继承关系也可以调用

       super：只能在继承条件下使用

    3. 构造方法表示的含义不同

       this()：调用本类的无参构造

       this(参数)：调用本类的有参构造

       super()：调用父类的无参构造

       super(参数)：调用父类的有参构造

方法重写

• 代码实例

  B（父）类：

  package com.oop.demo7;
  
  public class B {
      //静态方法
      public static void test1(){
          System.out.println("B=>test()");
      }
      //非静态方法
      public void test2(){
          System.out.println("B=>test()");
      }
  }
  

  A（子）类：

  package com.oop.demo7;
  
  public class A extends B{
      //静态方法
      public static void test1(){
          System.out.println("A=>test()");
      }
      //非静态方法
      //Override:重写
      @Override //注解：有功能的注释
      public void test2() {
          System.out.println("A=>test()");
      }
  }
  

  Application类：

  package com.oop.demo7;
  
  public class Application {
      public static void main(String[] args) {
          A a = new A();
          B b = new A(); //父类的引用指向了子类
          //静态方法：方法的调用只和等号左边定义的数据类型有关
          a.test1(); //A
          b.test1(); //B
          //非静态方法：重写方法
          a.test2();
          b.test2(); //子类重写了父类的方法
      }
  }
  

  

• 小结

  • 前提：

    需要有继承关系，子类重写父类的非静态方法

  • 特点：

    1. 方法名必须相同
    2. 参数列表必须相同
    3. 方法体不同
    4. 重写只能应用在非静态方法上
    5. 方法重写后的访问修饰符不能比父类的更加严格

  • 为什么要重写方法：

    子类不一定需要父类的功能，或者父类的功能不一定满足子类

  • 快捷键

    alt + insert

  • 扩展：

    1. 修饰符的范围可以扩大但不能缩小（修饰符范围：public>protected>default>private）
    2. 抛出的异常范围可以缩小但不能扩大

---

重要声明：本篇文章整理自B站狂神说Java