继承和多态

Spliceㅤ

已于 2022-08-08 14:34:18 修改

阅读量520

点赞数 1

分类专栏： JavaSE博客文章标签： java servlet jvm

于 2022-08-06 19:18:11 首次发布

本文链接：https://blog.csdn.net/zyx22334/article/details/126195459

版权

JavaSE博客专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1. 继承

面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

比如：以下代码Dog与Cat属于子类/派生类，而Animal属于父类/基类/超类

子类继承父类后会把属性和方法全部继承。

class Animal {
    public String name;
    public int age;

    public void eat() {
        System.out.println(name + "正在吃饭！！！");
    }
}
class Dog extends Animal{
    public void wag(){
        System.out.println(name+"摇尾巴！！！");
    }
}
class Cat extends Animal{
    public void catchmouse(){
        System.out.println(name+"抓老鼠！！！");
    }
}

继承的语法：

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

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

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

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

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

Java只能继承一个类，不能实现多继承。

1.3 super关键字

super的三种用法：

1.super.data；访问父类的普通成员变量。

2.super.fun( )；调用父类的普通成员方法。

3.super( )；调用父类的构造方法。

注意事项：

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

一、1. 在继承的基础上，this会优先访问子类自己的，如果子类没有，则会访问父类的。

2. super只是一个关键字，在代码层面上能够达到易读的效果。

3.另外，如果既没有this也没有super系统则会根据就近原则优先访问子类自己。（有些书上说super是父类的引用这是错误的）

二、在父类中添加一个带两个对象的构造方法，但是继承了父类的子类却开始报错了。

这是为什么呢？

原因：

我们知道JVM对对象成员进行初始化，但是对象属性的初始化必须得用到构造方法，在子类实例化的时候我们知道会自动生成一个无参构造方法进行初始化，而如果在父类中创建一个这样的构造方法，无参构造方法将不会生成，初始化也将无法进行。

所以说，我们如果想要程序顺利运行，应当在子类中优先进行构造方法的初始化

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

注意：
1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含super()调用，即调用基类构造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

1.4 super和this

相同点：

1. 都是Java中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点：

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

2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现
4. 构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

1.5 初始化顺序

下面代码表明了两个子类在父类中（静态块，实例块，构造方法）的运行顺序

class Person {
  public String name;
  public int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println("Person：构造方法执行");
 }
 {
    System.out.println("Person：实例代码块执行");
 }
  static {
    System.out.println("Person：静态代码块执行");
 }
}
class Student extends Person{
  public Student(String name,int age) {
    super(name,age);
    System.out.println("Student：构造方法执行");
 }
 {
    System.out.println("Student：实例代码块执行");
 }
 
  static {
    System.out.println("Student：静态代码块执行");
 }
}
public class TestDemo4 {
  public static void main(String[] args) {
    Student student1 = new Student("张三",19);
    System.out.println("===========================");
    Student student2 = new Student("gaobo",20);
}
  public static void main1(String[] args) {
    Person person1 = new Person("bit",10);
    System.out.println("============================");
    Person person2 = new Person("gaobo",20);
 }
}

运行顺序：先执行各自类的静态代码块-》再依次执行各自类的实例代码块和构造代码块

静态代码块：static

实例代码块：出现Animal animal=new Animal（）类似的就是指对象的实例化。

构造代码块：public Animal（）{

}就是指构造代码块。

在程序运行中，使先运行父类的再按顺序运行子类的。

运行结果是：

Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

2. protected 关键字

在类和对象章节中，为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问

3. final 关键字

添加final的类将不会受到别的类的继承。

final的使用：

1.使常量不再被更改。

2.方法

4. 继承与组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。
继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物
组合表示对象之间是has-a的关系，比如：汽车

// 轮胎类
class Tire{
  // ...
}
// 发动机类
class Engine{
  // ...
}
// 车载系统类
class VehicleSystem{
  // ...
}
class Car{
  private Tire tire;      // 可以复用轮胎中的属性和方法
  private Engine engine;    // 可以复用发动机中的属性和方法
  private VehicleSystem vs;  // 可以复用车载系统中的属性和方法
 
  // ...
}
// 奔驰是汽车
class Benz extend Car{
  // 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

5. 多态

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

class Animal{
    public String name;
    public int age;
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println(name+"吃饭");
    }
}
class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println(name+"吃狗粮");
    }
}
class Cat extends Animal{
    public Cat(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println(name+"吃鱼");
    }
}
public class Test {
    public static void eat(Animal eat){
        eat.eat();
    }
    public static void main(String[] args) {
        Dog dog=new Dog("阿黄",15);
        Cat cat=new Cat("欢欢",10);
        eat(cat);
        eat(dog);

    }
}

一个调用调用同样的方法，但调用的对象不同最后导致输出的结果不同，这种思想就叫做多态。

多态实现的条件：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

所以说，重写是什么呢？

5.2.1 重写

重写构成的条件：

1. 方法名称相同。

2. 返回值相同

3.参数列表相同（数据属性，顺序，参数个数）

注意：子类的访问权限要大于或等于父类的访问权限。（private修饰的方法无法重写）

重写的规则：

1. 子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型方法名 (参数列表) 要完全一致
2. 被重写的方法返回值类型可以不同，但是必须是具有父子关系的

3. 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected父类被static、private修饰的方法、构造方法都不能被重写。
4. 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

5.2.2 重写和重载的区别

重载：

1.方法名相同。

2.参数列表不同（数据类型、参数、个数）

3.返回值不做要求

重写：

1. 方法名称相同。

2.参数列表相同（数据属性，顺序，参数个数）

3. 返回值相同构成父子关系也可以。

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

5.3 向上转移和向下转型

5.3.1 向上转型

通过将animal直接指向dog可以调用Animal中的方法。

但如果重写一个eat方法放到dog类里重新运行该程序将会运行dog类中的eat方法。

使用情景：

1.直接赋值
Animal animal =dog("旺财",15);

2. 方法传参

3. 方法返回

向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。

5.3.2 向下转型

类似

Animal animal=new Dog();

就是想要用父类实例化对象引用子类的方法和对象。

但极度不方便，尽量不要用。

6. 避免在构造方法中调用重写的方法

class A{
    public A(){
        func();
    }
    public void func(){
        System.out.println("A");
    }
}
class B extends A{
    private int num=1;
    public void func(){
        System.out.println("B"+num);
    }
}
public class Test{
    public static void main(String[] args) {
        
        B b=new B();
    }
}