Java的继承

作者: 寻心_0a46 | 来源:发表于2023-04-21 12:39 被阅读0次

继承的概念：继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

例如生活中的继承关系：

14B0951E-FC75-47A3-B611-4E1883887339.jpg

兔子和羊属于食草动物类，狮子和豹属于食肉动物类。食草动物和食肉动物又都是属于动物类。所以继承需要符合的关系是：is-a，父类更通用，子类更具体。虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

为什么需要继承

继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。
继承提供了软件复用功能。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(成员属性和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。
继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。

继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。如图：

java-extends-2020-12-08.png

继承的特性

子类拥有父类所有的属性、方法，但被 private 修饰的属性和方法子类无法直接访问。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承 Object(这个类在 java.lang 包中，所以不需要 import)祖先类。

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，通过 extends 关键字可以申明一个类是从另外一个类继承而来的。extends 关键字只能继承一个类。一般形式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

implements关键字：使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。一般形式如下：

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 与 this 关键字

super关键字：可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。this 关键字可以解决实例变量和局部变量之间发生的同名的冲突。

一般使用形式如下：

// 动物类 父类
class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}

// 狗狗类 子类 继承动物类 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}
// 程序执行输出结果如下：
// a.eat()方法输出 animal : eat
// d.eatTest()方法中 this.eat()方法输出 dog : eat
// d.eatTest()方法中 super.eat()方法输出 animal : eat

final 关键字：final 可以用来修饰变量(包括类属性、对象属性、局部变量和形参)、方法(包括类方法和对象方法)和类。final 含义为 "最终的"。使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承(注: final 定义的类，其中的属性、方法并不是 final 的)；使用 final 关键字修饰方法，该方法不能被子类重写。

声明类格式如下：

final class 类名 {//类体}

修饰方法格式如下：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动（隐式）在子类的构造器第一行调用父类的无参构造器；如果子类构造方法第一行显式调用了父类构造方法，则系统不在提供对父类的无参构造器的自动调用。

$\color{red}{构造器调用实例：}$

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}
// 程序运行输出结果为：
// ------SubClass 类继承------
// SuperClass()
// SubClass
// SuperClass(int n)
// SubClass(int n):100
// ------SubClass2 类继承------
// SuperClass(int n)
// SubClass2
// SuperClass()
// SubClass2(int n):200

Java 转型问题

向上转型：通俗地讲即是将子类对象转为父类对象。此处父类对象可以是接口。向上转型不用强制转换。向上转型中的方法调用：

public class Upcasting {
    public static void main(String[] args) {
        // 向上转型
        Animal bird = new Bird();
        bird.eat();
        // 调有时用子类作为参数
        sleep(new Bird());
        sleep(new Dog());
    }

    // 这里以父类做为方法参数
    public static void sleep (Animal animal) {
        // 方法睡
        animal.sleep();
    }
}

// 动物类，作为父类
class Animal {
    // 方法 吃
    public void eat() {
        System.out.println("动物正在吃...");
    }
    // 方法 睡
    public void sleep() {
        System.out.println("动物正在睡...");
    }

}

// 小鸟类 继承 动物类
class Bird extends Animal {
    // 方法 吃
    public void eat() {
        System.out.println("小鸟正在吃...");
    }
    // 方法 飞翔
    public void fly() {
        System.out.println("小鸟正在飞翔...");
    }
    // 方法 睡
    public void sleep() {
        System.out.println("小鸟正在睡...");
    }
}

//小狗类 继承 动物类
class Dog extends Animal {
    // 方法 吃
    public void eat() {
        System.out.println("小狗正在吃...");
    }
    // 方法 跑
    public void run() {
        System.out.println("小狗正在跑...");
    }
    // 方法 睡
    public void sleep() {
        System.out.println("小狗正在睡...");
    }
}

// 程序运行输出结果为：
// 小鸟正在吃...
// 小鸟正在睡...
// 小狗正在睡...

代码解析：

Animal bird = new Bird() 向上转型时，bird 实际指向的是 Bird 子类，故 bird.eat() 调用方法时会调用子类本身的方法。
需要注意的是向上转型时 bird 会遗失除了与父类对象共有的其他方法。如本例中的 fly 方法不再为 bird 所有。
Upcasting 类中定义的 sleep() 方法以父类 Animal 类对象为参数，调有时分别用子类 Bird 类对象与 Dog 类对象作为参数，结果分别调用了子类的 sleep() 方法，就是利用了向上转型。这样使代码变得简洁。不然的话，如果 sleep() 方法以子类对象为参数，则有多少个子类就需要写多少个函数。这也体现了 JAVA 的抽象编程思想。

向下转型：与向上转型相反，即是把父类对象转为子类对象。需要强制转换。向下转型中的方法调用：

public class Downcasting {
    public static void main(String[] args) {
        Girl girl = new Girl();
        // 不安全的向下转型，girl指向的是父类对象，编译无错但会运行会出错 ClassCastException，所以需要添加判断
        if(girl instanceof MMGirl) {
            MMGirl mmgirl = (MMGirl)girl;
            mmgirl.smile();
            mmgirl.c();
        }
        // 向上转型
        Girl girl2 = new MMGirl();
        // 安全的向下转型，mmGirl指向的是子类对象，编译和运行皆不会出错
        MMGirl mmGirl = (MMGirl) girl2;
        mmGirl.smile();
        mmGirl.c();
    }
}

// 女孩类 作为父类
class Girl {
    // 方法 微笑
    public void smile(){
        System.out.println("girl smile()...");
    }
}

// MM女孩类 继承 女孩类
class MMGirl extends Girl{
    // 方法 微笑
    @Override
    public void smile() {
        System.out.println("MMGirl smile sounds sweet...");
    }
    // 方法 c
    public void c(){
        System.out.println("MMGirl c()...");
    }
}

// 程序运行输出结果为：
// MMGirl smile sounds sweet...
// MMGirl c()...

总结：

1、父类引用指向子类对象，而子类引用不能指向父类对象。
2、把子类对象直接赋给父类引用叫 upcasting 向上转型，向上转型不用强制转换。
3、把指向子类对象的父类引用赋给子类引用叫 downcasting 向下转型，要强制转换。

Java的继承

为什么需要继承

继承类型

继承的特性

继承关键字

构造器

Java 转型问题

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读