继承和多态（一）

继承

首先提出两个问题。

什么是继承？继承从字面上理解通俗点就是子承父业。

我们为什么需要继承？比如，猫和狗两个动物，可以写成两个类，设计成代码就是

// Dog.java
public class Dog{
  string name;
  int age;
  float weight;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void sleep(){
    System.out.println(name + "正在睡觉");
 }
 
  void Bark(){

    System.out.println(name + "汪汪汪~~~");
 }
}
// Cat.Java
public class Cat{
  string name;
  int age;
  float weight;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void sleep()
 {
    System.out.println(name + "正在睡觉");
 }
 
  void mew(){
    System.out.println(name + "喵喵喵~~~");
 }
}

通过观察上述代码会发现，猫和狗的类中存在大量重复，如下所示：

从图中可以看出，两者出现了很多共性。为了解决这个问题，java便有了继承这个概念，进行共专门用来性抽取，实现代码复用。

上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。

继承的语法

类之间的继承关系，用extends关键字

修饰符 class 子类 extends 父类 {
 // ... 
}

有了继承之后，上文描述的猫和狗类就有了更简洁的思想，让代码更加美丽。比如一下代码

public class Animal{
  String name;
  int age;
 
  public void eat(){
    System.out.println(name + "正在吃饭");
 }
 
  public void sleep(){
    System.out.println(name + "正在睡觉");
 }
}

public class Dog extends Animal{  
  void bark(){
    System.out.println(name + "汪汪汪~~~");
 }
}

public class Cat extends Animal{ 
  void mew(){
    System.out.println(name + "喵喵喵~~~");
 }
}
// TestExtend.java
public class TestExtend {
  public static void main(String[] args) {
    Dog dog = new Dog();
    // dog类中并没有定义任何成员变量，name和age属性是从父类Animal中继承下来的
    System.out.println(dog.name);
    System.out.println(dog.age);
    // dog访问的eat()和sleep()方法也是从Animal中继承下来的
    dog.eat();
    dog.sleep();
    dog.bark();
 }
}

通过继承关系，定义一个动物父类，抽取猫和狗的共性，通过extends关键字将父类中的成员变量和方法继承下来。

那么问题又来了，虽然都继承下来了，可是在子类中能不能直接访问继承下来的成员呢？

1.子类和父类不存在同名成员变量

public class Base {
  int a;
  int b;
}
public class Derived extends Base{
  int c;
  public void method(){
    a = 10;   // 访问从父类中继承下来的a
    b = 20;   // 访问从父类中继承下来的b
    c = 30;   // 访问子类自己的c
 }
}

2.子类和父类成员变量同名

public class Base {
  int a;
  int b;
  int c;
}
/
public class Derived extends Base{
  int a;        // 与父类中成员a同名，且类型相同
  char b;       // 与父类中成员b同名，但类型不同
  public void method(){
    a = 100;     // 访问父类继承的a，还是子类自己新增的a？
    b = 101;     // 访问父类继承的b，还是子类自己新增的b?
    c = 102;     // 子类没有c，访问的肯定是从父类继承下来的c
    // d = 103;   // 编译失败，因为父类和子类都没有定义成员变量d
 }
}

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

• 如果访问的成员变量子类中有，优先访问自己的成员变量
• 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
• 如果访问的成员变量与父类中成员变量同名，则优先访问自己的

总结：成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

成员方法也是同样的道理

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错
• 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错

那么，如果子类和父类存在相同变量时，在子类里如何访问父类的同名变量呢？

Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

public class Base {
  int a;
  int b;
public void methodA(){
  System.out.println("Base中的methodA()");
}
public void methodB(){
  System.out.println("Base中的methodB()");
}
}


public class Derived extends Base{
  int a;   // 与父类中成员变量同名且类型相同
  char b;  // 与父类中成员变量同名但类型不同
  // 与父类中methodA()构成重载
  public void methodA(int a) {
    System.out.println("Derived中的method()方法");
 }
  // 与基类中methodB()构成重写
  public void methodB(){
    System.out.println("Derived中的methodB()方法");
 }
  public void methodC(){
    // 对于同名的成员变量，直接访问时，访问的都是子类的
    a = 100;  // 等价于： this.a = 100;
    b = 101;  // 等价于： this.b = 101;
    // 注意：this是当前对象的引用
    // 访问父类的成员变量时，需要借助super关键字
    // super是获取到子类对象中从基类继承下来的部分
    super.a = 200;
    super.b = 201;
    // 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
    methodA();    // 没有传参，访问父类中的methodA()
    methodA(20);   // 传递int参数，访问子类中的methodA(int)
    // 如果在子类中要访问重写的基类方法，则需要借助super关键字
    methodB();    // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
    super.methodB(); // 访问基类的methodB()
 }
}

注意：super和this关键字只能在非静态方法中使用。

关于继承中子类和父类的构造方法

在这一块，我们需要注意一些事项，子类对象构造时，需要先调用父类构造方法，然后执行子类的构造方法。

public class Base {
  public Base(){
    System.out.println("Base()");
}

public class Derived extends Base{
 public Derived(){
   // super();  // 注意子类构造方法中默认会调用父类的无参构造方法：super(),
   // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
   // 并且只能出现一次
   System.out.println("Derived()");
 }
}
public class Test {
  public static void main(String[] args) {
    Derived d = new Derived();
 }
}

运行结果：

Base()
Derived()

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

怎么理解呢，就是说如果父类的构造方法是带有参数的，那么子类的构造方法需要调用父类的构造方法帮助父类完成初始化。

像这样，父类带有参数的构造方法，而子类中并没有构造方法调用父类构造方法为父类初始化成员变量就会报错。那么，我们需要优化代码

在子类的构造方法中调用父类构造方法帮助父类初始化就不会报错了，或者子类的构造方法也可以不用带参数，可以这么写

注意事项：

1.  在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
2. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现。

以上大概就是继承的内容了，后续会继续更新多态。