当前位置：首页 > article >正文

Java多态和继承（上篇）

article 2024/11/7 8:36:25

今天来学习继承和多态

继承

1 继承的意义

Java中使用类对现实世界中实体来进行描述，
类经过实例化之后的产物对象，则可以用来表示现实中的实体，
但是现实世界错综复杂，事物之间可能会存在一些关联，

比如：狗和猫，它们都是一个动物

使用Java语言来进行描述，就会设计出：

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

       System.out.println(name + "汪汪汪~~~");
  }
}

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

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

那能否将这些共性抽取呢？
面向对象思想中提出了继承的概念，
专门用来进行共性抽取，实现代码复用

2 继承的概念

继承(inheritance)机制：
是面向对象程序设计使代码可以复用的最重要的手段，
它允许程序员在保持原有类特性的基础上进行扩展，
增加新功能，这样产生新的类，称派生类。
继承呈现了面向对象程序设计的层次结构，
体现了由简单到复杂的认知过程。
继承主要解决的问题是：共性的抽取，实现代码复用。

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

3 继承的语法

在Java中如果要表示类之间的继承关系，
需要借助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{    
   void bark(){
       System.out.println(name + "汪汪汪~~~");
  }
}
// Cat.Java
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();
  }
}

注意：

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

4 父类成员访问

在继承体系中，子类将父类中的方法和字段继承下来了，
那在子类中能否直接访问父类中继承下来的成员呢？

4.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
  }
}

子类和父类成员变量同名

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;     // 编译失败，因为父类和子类都没有定义成员变量b
  }
}

在子类方法中或者通过子类对象访问成员时：
如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，
如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
成员变量访问遵循就近原则，自己有优先自己的，
如果没有则向父类中找

4.2 子类中访问父类成员方法

成员方法名字不同

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

public class Derived extends Base{
   public void methodB(){
       System.out.println("Derived中的methodB()方法");
  }
   
   public void methodC(){
       methodB();         // 访问子类自己的methodB()
       methodA();         // 访问父类继承的methodA()
       // methodD();     // 编译失败，在整个继承体系中没有发现方法methodD()
  }
}

总结：成员方法没有同名时，
在子类方法中或者通过子类对象访问方法时，
则优先访问自己的，
自己没有时再到父类中找，如果父类中也没有则报错

成员方法名字相同

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

public class Derived extends Base{
   public void methodB(){
       System.out.println("Derived中的methodB()方法");
  }
   
   public void methodC(){
       methodB();         // 访问子类自己的methodB()
       methodA();         // 访问父类继承的methodA()
       // methodD();     // 编译失败，在整个继承体系中没有发现方法methodD()
  }
}

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

public class Derived extends Base{
   public void methodA(int a) {
       System.out.println("Derived中的method(int)方法");
  }
  
   public void methodB(){
       System.out.println("Derived中的methodB()方法");
  }
  
   public void methodC(){
       methodA();      // 没有传参，访问父类中的methodA()
       methodA(20);    // 传递int参数，访问子类中的methodA(int)
       methodB();      // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到
  }
}

【说明】
通过子类对象访问父类与子类中不同名方法时，
优先在子类中找，找到则访问，否则在父类中找，
找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，
如果父类和子类同名方法的参数列表不同(重载)，
根据调用方法适传递的参数选择合适的方法访问，
如果没有则报错；
问题：如果子类中存在与父类中相同的成员时，
那如何在子类中访问父类相同名称的成员呢？

5 super 关键字

由于设计不好，或者因场景需要，
子类和父类中可能会存在相同名称的成员，
如果要在子类方法中访问父类同名成员时，该如何操作？
直接访问是无法做到的，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关键字即可。

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

super的其他用法在之后的文章中介绍。

6 子类构造方法

父子父子，先有父再有子，
即：子类对象构造时，需要先调用基类构造方法，
然后执行子类的构造方法。

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()

在子类构造方法中，并没有写任何关于基类构造的代码，
但是在构造子类对象时，
先执行基类的构造方法，然后执行子类的构造方法，
因为：子类对象中成员是有两部分组成的，
基类继承下来的以及子类新增加的部分。
父子父子肯定是先有父再有子，所以在构造子类对象时候，
先要调用基类的构造方法，
将从基类继承下来的成员构造完整，
然后再调用子类自己的构造方法，
将子类自己新增加的成员初始化完整 。

注意：