Java 继承

文章目录

• 继承
• • 访问父类成员
  • • 子类和父类不存在同名变量
    • 子类和父类存在同名变量
    • super
    • 父类的构造初始化
    • this和super的对比
    • 初始化
    • protected
    • final
    • 继承和组合

      继承

      1. 继承：比如说有两个类，这两个类有共同的属性，（把这些共同的属性抽取出来，达到代码的复用效果），把共同的属性当成一个类，这两个类再继承这一个类

      

      2. 继承的语法，extends表示子类继承父类

      访问限定修饰符 class 子类 extends 父类{
      } 
      

      // Animal.java
      public class Animal {
          String name;
          int age;
          public void eat() {
              System.out.println(name+ "正在吃饭");
          }
          public void sleep() {
              System.out.println(name+ "正在睡觉");
          }
      }
      // Dog.java 
      public class Dog extends Animal{
          public Dog() {
              super();
          }
          void bark() {
              System.out.println(name+ "汪汪汪~~~");
          }
      }
      

      1. 子类会把父类的成员方法和成员变量继承到子类中
      2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

      访问父类成员

      子类和父类不存在同名变量

      1. 直接使用

      public class Animal {
          String name;
          int age;
      }
      

      public class Dog extends Animal{
          double weight;
          String color;
          public Dog(String name,int age,double weight,String color) {
              this.name = name;//从父类中继承下来的name
              this.age = age;//从父类中继承下来的age
              this.weight = weight;
              this.color = color;
          }
      }
      public class TestExtend {
          public static void main(String[] args) {
              Dog dog = new Dog("阿狗",3,20.5,"黑色");
              //dog类中并没有定义任何成员变量,name和age属性是从父类Animal中继承下来的
              System.out.println(dog.name);
              System.out.println(dog.age);
              System.out.println(dog.weight);
              System.out.println(dog.color);
          }
      }
      

      子类和父类存在同名变量

      1. 优先使用子类的变量和方法

      public class Animal {
          String name;
          int age;
          int a = 3;
      }
      

      public class Dog extends Animal{
          double weight;
          String color;
          int a = 0;
          
          public void method() {
              System.out.println(a);//此时a是访问父类继承的a还是子类自己的a呢?
          }
      }
      public class TestExtend {
          public static void main(String[] args) {
              Dog dog = new Dog();
              dog.method();//输出结果为0,说明method()中的a是子类自己的
          }
      }
      

      注意, 在子类方法中 或者 通过子类对象访问成员时 ：

      如果访问的成员变量子类中有，优先访问自己的成员变量。

      如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。

      如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

      总结就是一句话:就近原则,先找自己的,再找父类的.

      在父类成员变量与子类成员变量相同时,想要访问父类成员变量时该如何访问呢?

      super

      1. super 关键字，该关键字主要作用：在子类方法中访问父类的成员变量和方法 。

         2. super(); 在子类的构造方法中调用父类的构造进行初始化继承下来的变量

      public class Animal {
          String name = "父类";
          int age = 1;
          public void methodA() {
              System.out.println("父类中的A方法");
          }
          public void methodB() {
              System.out.println("父类中的B方法");
          }
      }
      public class Dog extends Animal{
          String name = "子类";
          int age = 2;
          public void methodA(int a) {
              System.out.println("子类中的A(a)方法");
          }
          public void methodB() {
              System.out.println("子类中的B方法");
          }
          public void methodC() {
              System.out.println(name);//访问子类的name,
              System.out.println(age);//访问子类的age
              System.out.println(super.name);//访问父类的name
              System.out.println(super.age);//访问父类的age
          }
      }
      public class TestExtend {
          public static void main(String[] args) {
              Dog dog = new Dog();
              dog.methodC();
          }
      }
      

      super关键字：

      1. 只能在非静态方法中使用
      2. 在子类方法中，访问父类的成员变量和方法 。

      父类的构造初始化

      1. 在子类完成构造之前，要调用父类的构造，进行从父类继承过来的成员变量的初始化

      

      2. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的 super()调用，即调用父类构造方法，且super()只能在子类构造方法中出现一次，并且只能在子类构造方法的第一句

      3. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

      public Dog() {
          //super();super();没写时,Java在第一行默认有隐含的super();
          System.out.println("子类构造方法");
      }
      

      

      4. 如果有多个父类的构造，在子类中想要怎么初始化自己继承的变量就调用哪个父类的构造

      this和super的对比

      1. 相同点：

      a. 都是关键字

      b. 都只能在非静态方法中使用，用来访问非静态成员方法和变量

      c. 在构造方法中调用，都只能是构造方法的第一句，并且不能同时存在

      1. 不同点：

      a. this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承部分成员的引用

      b. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

      c. 构造方法中：this用来调用本类的构造方法，super用来调用父类的构造方法，两种方法不能同时在构造方法中出现，因为他们都要在第一句

      d. 构造方法中一定会存在super()的调用，即使你不写，编译器也会默认加上，但是this用户不写，就没有

      初始化

      1. 请判断执行顺序？

         优先执行父类的静态，在执行子类的静态，在执行父类的实例和构造，最后执行子类的实例和构造

         因为父类要先于子类之前初始化

      

      

      protected

      1. protected是在继承的场景下使用的，前提是继承的父类是public修饰的
      2. protected和private修饰的类是会报错的

         

         

      final

      1. 被final修饰的变量就变为常量了，只能被初始化一次
      2. 被final修饰的类不能被继承

      final public class A{
      }
      final int a = 10;
      // a = 20; 不能再被修改 
      

      1. 被final修饰的方法不能被重写，是密封方法

      继承和组合

      1. 继承最好不超过三层

      

      2. 组合：代码复用的另一种方式，将一个类的实例作为另一个类的字段（变量）

      

      3. 组合：把另一个类作为当前类的成员变量，达到了类的复用的效果

      class Engine {
          void start() {
              System.out.println("Engine started");
          }
      }
      class Car {
          把Engine类当做Car类的成员变量
          private Engine engine; // Car 拥有 Engine（组合）
          public Car() {
              this.engine = new Engine(); // Engine 由 Car 控制生命周期
          }
          void start() {
              engine.start(); // 调用 Engine 的方法
              System.out.println("Car started");
          }
      }
      public class Main {
          public static void main(String[] args) {
              Car car = new Car();
              car.start();
          }
      }