【Java基础08_2】继承

最新推荐文章于 2021-05-30 17:32:03 发布

五命九九

最新推荐文章于 2021-05-30 17:32:03 发布

阅读量257

点赞数

分类专栏： Java 文章标签：继承 java

本文链接：https://blog.csdn.net/qq_32106647/article/details/78226370

版权

Java 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

格式

通过extends关键字可以实现类与类的继承：
class 子类名 extends 父类名 { }
父类：称之为基类或者超类；
子类：也称为派生类。

继承 Demo1

// 定义一个人类
class Person {
    // 成员变量
    private String name;    // 姓名
    private int age;        // 年龄

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    // 吃饭的方法
    public void eat() {
        System.out.println("吃米饭...");
    }
    // 睡觉的方法
    public void sleep() {
        System.out.println("该睡觉了...");
    }
    // 学习的方法
    public void study() {
        System.out.println("该学习了...");
    }
}
// 学生类
class Student extends Person{

    // 无参的构造方法
    public Student() {}
}
// 老师类
class Teacher extends Person{
}
// 测试类
class ExtendsDemo1 {

    public static void main(String[] args) {

        // 测试学生类
        Student s = new Student();
        s.setName("张三");
        s.setAge(20);
        System.out.println(s.getName() + "---" + s.getAge());
    }
}

优点

提高了代码的复用性
提高了代码的维护性
让类与类之间产生了关系，是多态的前提

缺点

继承使得类与类之间的关系变得更加密切，这会导致类的耦合性加强。然而，开发的原则是高内聚，低耦合。
一个类不应当过多地依赖于其他的类，且应当具备独立完成某个功能的能力和高度效率。
一个类不应该有多种复杂的功能，而是应当“专注”地负责一个功能，这样不仅使类不用依赖别的类，更加提高了该类本身的办事效率。
耦合：类与类之间的关系。
内聚：就是自己独立完成某件事情的能力。

特点

Java中继承特点：
- Java只支持单继承，不支持多继承。有些语言(例如C++)是支持多继承。
- Java支持多层继承(继承体系)

注意事项

子类只能继承父类所有非私有的成员(成员方法和成员变量)
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
不要为了部分功能而去继承

什么时候用继承

继承其实体现的是一种关系：”is a” ，是一个。
采用假设法。
- 如果有两个类A，B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

继承中成员变量的关系

子类中的成员变量和父类中的成员变量名称可以不一样
子类中的成员变量和父类中的成员变量名称可以一样，在子类中访问一个变量的查找顺序遵循”就近原则”
1. 在子类的方法的局部范围找,有就使用
2. 在子类的成员范围找,有就使用
3. 在父类的成员范围找,有就使用
4. 如果还找不到,就报错

this 和 super 的区别和应用

区别:

this 代表的是本类对象的引用
super 代表的是父类存储空间的标识（可以理解成父类的引用，可以操作父类的成员）

应用:

调用成员变量
- this.成员变量 —— 调用本类的成员变量
- super.成员变量 —— 调用父类的成员变量
调用构造方法
- this(…) —— 调用本类的构造方法
- super(…) —— 调用父类的构造方法
调用成员方法
- this.成员方法 —— 调用本类的成员方法
- super.成员方法 —— 调用父类的成员方法

继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中空参数的构造方法
原因：子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
其实：每一个构造方法的第一条语句默认都是：super();

[问题：] 多层继承时，继承的层级越多，要初始化的父类构造方法就越多，某种意义上是不是减缓了程序的运行速度？

注意事项

父类没有无参构造方法，子类怎么办?
- 在父类中添加一个无参的构造方法
- 子类通过super去显示调用父类其他的带参的构造方法
- 子类通过this去调用本类的其他构造方法
super(…)或者this(….)必须出现在第一条有效执行的语句上

面试题

1.看程序写结果

class Father{
    public int num = 10;
    public Father(){
        System.out.println("father");
    }
}
class Son extends Father{
    public int num = 20;
    public Son(){
        System.out.println("son");
    }
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}
class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.show();
    }
}

答案：
father
son
30
20
10

2.看程序写结果

class Father {
    static {
        System.out.println("静态代码块Father");
    }

    {
        System.out.println("构造代码块Father");
    }

    public Father() {
        System.out.println("构造方法Father");
    }
}

class Son extends Father {
    static {
        System.out.println("静态代码块Son");
    }

    {
        System.out.println("构造代码块Son");
    }

    public Son() {
        System.out.println("构造方法Son");
    }
}
class Test {
    public static void main(String[] args) {
        Son son = new Son();

    }
}

答案
静态代码块Father
静态代码块Son
构造代码块Father
构造方法Father
构造代码块Son
构造方法Son

继承中成员方法关系

当子类的方法名和父类的方法名不一样的时候，有就直接使用，没有就报错。
当子类的方法名和父类的方法名一样的时候
- 通过子类调用方法:
- 先查找子类中有没有该方法，如果有就使用
- 在看父类中有没有该方法，有就使用
- 如果没有就报错

方法重写概述及其应用

方法重写
- 子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。
方法重写的作用
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
Override和Overload的区别?
- 一个是重写一个是重载，前者是子类跟父类拥有着一样的方法声明（包括方法名，返回值类型和参数列表），后者是方法声明的参数列表不同。

方法重载 Demo

// 父类
class Father {

    public void show() {
        System.out.println("Father....show....");
    }

    public void eat() {
        System.out.println("吃大米...");
    }

}
// 子类
class Son extends Father {

    public void show() {
        System.out.println("Son....show....");
    }
    public void eat() {
        System.out.println("吃大米...");
        System.out.println("吃牛排！！！");
    }
}
// 测试类
class OverrideDemo {

    public static void main(String[] args) {
        // 创建子类的对象
        Son son = new Son();
        // 调用show()
        son.show();
    }
}