【JavaSE系列】第八节—— 继承

未央.303

已于 2023-11-10 09:29:21 修改

阅读量212

点赞数 17

分类专栏： JavaSE系列文章标签： java javaee

于 2023-01-05 19:02:38 首次发布

本文链接：https://blog.csdn.net/qq_64861334/article/details/127789436

版权

JavaSE系列专栏收录该内容

11 篇文章 1 订阅

订阅专栏

前言

本节课我们将进入到Java的第二个特性：继承。本节内容十分重要，也有一定难度，一定要好好弄清楚有关内容。为接下来的Java学习铺垫道路。

一、引出继承

Java中使用类对现实世界中的实体进行描述；

类经过实例化以后的产物对象，则可以用来表示现实中的实体；

但是，在现实生活中，某些实体与实体之间具有相同的属性；

比如说，上面的小猫和小狗，就具有一个共性：它们都是动物；

如果用Java语言来描述小猫和小狗，那么就可以这样来设计：
//定义一个Cat类
 
class Cat {
    public String name;
    public  int age;
    public String sex;
 
    public void eat() {
        System.out.println(this.name+"吃饭");
    }
    public void mew(){
        System.out.println(this.name+"喵喵叫");
    }
}
//定义一个Dog类
 
class Dog {
    public String name;
    public  int age;
    public String sex;
 
    public void eat() {
        System.out.println(this.name+"吃饭");
    }
    public void bark(){
        System.out.println(this.name+"汪汪叫");
    }
}
Cat类和 Dog类有许多一样的属性；那么，能不能将这些共性给抽取出来呢？

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

二、继承的概念

继承机制：

是面向对象程序设计是代码可以复用的最重要的手段；

它允许程序员在保持原有类的特性的基础上进行扩展，增加新功能，这样产生新的类，称为派生类；

继承体现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程；

继承主要解决的问题是：共性的抽取，实现代码复用。

例如，上面的小猫和小狗的例子，我们可以把它们的共性抽取出来，然后把这些抽取出来的共性重新放到一个类Animal当中：
 public String name;
    public  int age;
    public String sex;
 
    public void eat() {
        System.out.println(this.name+"吃饭");
    }
此时，可以通过关键字extends 构成一个继承关系：

画图演示：

三、继承的语法

语法格式：

//修饰符可以省略，也可以不用省略
 
[修饰符] class 子类 extends 父类 {
        //继承的成员变量或方法
}
【注意】

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

举例说明：

所以，对上面的例子可以使用继承的方式来设计：

 
class Animal {
    public String name;
    public  int age;
    public String sex;
 
    public void eat() {
        System.out.println(this.name+"吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}
 
//Cat类
class Cat extends Animal{
    public void mew(){
        System.out.println(this.name+"喵喵叫");
    }
}
 
//Dog类
class Dog extends Animal{
    public void bark(){
        System.out.println(this.name+"汪汪叫");
    }
}
 
public class TestDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "喵喵";
        cat.eat();
        cat.mew();
 
        Dog dog = new Dog();
        dog.name = "汪汪";
        dog.sleep();
        dog.bark();
    }
}

四、父类成员访问

在继承体系中，子类将父类中的方法和字段继承下来了；

那在子类中能否直接访问父类中继承下来的成员呢？

4.1 子类中访问父类的成员变量

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

代码示例:

 
class Base{
    public int a = 1;
    public int b = 2;
}
 
class Derived extends Base {
    public int c = 3;
    public int d = 4;
 
    public void test(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}

画图示例：

结果示例：

2.子类和父类成员变量存在同名情况

代码示例:
class Base3{
    public int a = 1;
    public int b = 2;
}
 
class Derived3 extends Base3 {
    public int a = 3;
    public int d = 4;
 
    public void test(){
        System.out.println("a = "+a);
        System.out.println("b = "+b);
        System.out.println("d = "+d);
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.test();
    }
}
结果示例：

结论总结：

由图可以看出，父类和子类都有相同的成员变量a，而最终打印的结果是子类成员变量a 的值；

如果子类和父类的成员变量重名，那么优先访问子类的成员变量；

这也可以理解，继承嘛，当自己的意志和父类的意志有冲突的时候，优先考虑一下自己的意志嘛！

那么，如果实在想访问父类的成员变量，很简单，使用关键字super;这个会在下面详细的介绍。

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

1.子类和父类成员方法不存在同名的情况

代码示例;
class Base3{
    
    public void method(){
        System.out.println("Base3:method");
    }
}
 
class Derived3 extends Base3 {
 
    public void method2(){
        System.out.println("Derived3:method2");
    }
 
    public void test(){
        method();
        method2();
}
 
public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.test();
    }
结果示例：

【总结】

成员方法没有同名时，子类优先访问；

如果子类没有所需的成员变量和成员方法，而父类也没有，那么程序将会报错。

2. 子类和父类成员方法存在同名的情况

代码示例:

 
class Base3{
 
    public void method(){
        System.out.println("Base3:method");
    }
}
 
class Derived3 extends Base3 {
 
    public void method(int a){
        System.out.println("Derived3:method2 "+a);
    }
 
    public void test(){
        method();
        method(100);
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.test();
    }
}

结果示例：

【说明】

1.通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问；否则在父类中找，找到则访问；否则程序编译报错；
2.通过子类访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同（重载），根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类同名方法的原型一致（重写-后面会介绍的），这只能访问到子类的，父类的无法通过子类对象直接访问到。

五、super 关键字

由于设计不好，或者因场景需要，子类和父类可能会存在相同名称的成员；

如果要在子类中访问父类同名成员时，那么应该怎么访问呢？直接访问是无法做到的；

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

5.1 super.成员变量

代码示例：

代码结果：

5.2 super.成员方法

代码示例;

代码结果：

5.3 super.构造方法

代码分析：

package Demo1;
 
class Animal {
    public String name;
    public int age;
 
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
}
 
class Cat extends Animal {
    public String hair;
    public void mew() {
        System.out.println(this.name + "正在叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        cat1.name = "咪咪";
        cat1.mew();
        cat1.eat();
    }
}

代码运行结果：

当我们把 name和age的访问权限修改成private以后，子类就不去能访问了(注意是不能访问了，而不是没有被继承)：

那么，此时可以去提供 getter和setter方法，再对代码进行修修改改：

package Demo1;
 
class Animal {
//    public String name;
    private String name;
//    public int age;
    private int age;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
}
 
class Cat extends Animal {
    public String hair;
    public void mew() {
        //System.out.println(this.name + "正在叫");
        //System.out.println(this.getAge());
    }
}
 
public class Test {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        //cat1.name = "咪咪";
        cat1.setName("咪咪");
        cat1.mew();
        cat1.eat();
    }
}

于是，这些成员就被赋初值了：

可是，当我们就直接加上构造方法的时候，代码就会报错啦：

这是为什么呢？

——原来，当构造子类的时候，一定要先帮助父类构造，再帮助子类构造。

所以说，还需要创建子类的构造方法，同时，要想先帮助父类构造，那可以用super关键字来进行调用：

【注意】

在调用构造方法的时候，和this一样，super必须放在第一行；
父子父子，先有父再有子，在子类当中可以通过super关键字来调用父类的构造方法；
super不能在静态方法中使用;

3.super不能在静态方法中使用：

代码示例：

六、继承方式

在Java中，只存在以下几种继承方式：

【注意】：Java是不支持多继承的，即：不支持一个子类有多个父类。

从上面来看，父类一层一层的被继承下去；

但是，如果不想被继承了，那到底该怎么做呢？很简单，这就需要又引出了final关键字；

七、final关键字

作用:

当一个类被final关键字修饰以后，这个类就不能继承了：

【注意】

被final修饰的类，我们把它叫做密封类(说明当前的类不能被继承)；

以前也介绍过，被final修饰的成员不能被修改(变成了常量）；当然，final还可以修饰方法

八、继承与组合

和继承类似，组合也是一种表达类之间关系的方式，也是可以达到代码复用的效果；

组合并没有涉及到特殊的语法(比如说 extends 这样的关键字)，仅仅是将一个类的实例作为另外一个类的字段；

继承表示对象之间是 is-a 的关系，比如：小狗是动物，小猫是动物；

组合表示对象之间是 has-a 的关系，比如：汽车；

eg:汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车就是由这些零部件组成的。

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

组合和继承都可以实现代码复用；

应该使用继承还是组合，需要根据应用场景来选择一般建议：能用组合尽量用组合。