面向对象---继承

继承

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).

有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.

例如, 设计一个类表示动物 注意, 我们可以给每个类创建一个单独的 java 文件. 类名必须和 .java 文件名匹配(大小写敏感)

// Animal.java 
public class Animal {
     public String name;
          public Animal(String name) {
      this.name = name;
     }
          public void eat(String food) {
         System.out.println(this.name + "正在吃" + food);
     }
 } 
 
// Cat.java 
class Cat {
    public String name;
          public Cat(String name) {
      this.name = name;
     }
          public void eat(String food) {
         System.out.println(this.name + "正在吃" + food);
     }
 } 
 
// Bird.java 
class Bird {
  public String name;
          public Bird(String name) {
         this.name = name;
     }
          public void eat(String food) {
         System.out.println(this.name + "正在吃" + food);
     }
          public void fly() {
         System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
     }
 } 

这个代码我们发现其中存在了大量的冗余代码

仔细分析, 我们发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系: 

这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.

这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.

从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.

此时, Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类, 对于像 Cat 和 Bird 这样的类, 我们称为 子类, 派生类

和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果.

语法规则

class 子类 extends 父类 {
      
} 

使用 extends 指定父类.

Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).

子类会继承父类的所有 public 的字段和方法. 对于父类的 private 的字段和方法, 子类中是无法访问的.

子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.

对于上面的代码, 可以使用继承进行改进. 此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再 写 name 字段和 eat 方法.
 

class Animal {
     public String name; 
 
    public Animal(String name) {
         this.name = name;
     } 
 
    public void eat(String food) {
         System.out.println(this.name + "正在吃" + food);
     }
 } 
 
class Cat extends Animal {
     public Cat(String name) {
         // 使用 super 调用父类的构造方法.
          super(name);
     }
 } 
 
class Bird extends Animal {
     public Bird(String name) {
        super(name);
     } 
 
    public void fly() {
         System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
     }
 } 
 
public class Test {
     public static void main(String[] args) {
         Cat cat = new Cat("小黑");
         cat.eat("猫粮");
         Bird bird = new Bird("圆圆");
         bird.fly();
     }
 }  

extends 英文原意指 "扩展". 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 "扩展".

例如我们写的 Bird 类, 就是在 Animal 的基础上扩展出了 fly 方法.

protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷.

两全其美的办法就是 protected 关键字.

对于类的调用者来说, protected 修饰的字段和方法是不能访问的

对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的

Java 中对于字段和方法共有四种访问权限 

        private: 类内部能访问, 类外部不能访问

        默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.

        protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.

        public : 类内部和类的调用者都能访问

final 关键字 
曾经我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示 常量 (不能修改)

final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.

final 关键字的功能是 限制 类被继承 "限制" 这件事情意味着 "不灵活".

在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.

当用 final 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的.