【Java基础08_2】继承

我就是我 2022-06-07 06:49 137阅读 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());
        }
    }

> **优点**

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

> **缺点**  
>

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

> **特点**

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

> **注意事项**

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

> **什么时候用继承**

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

> **继承中成员变量的关系**

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

> **this 和 super 的区别和应用**

##### **区别:** #####

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

##### **应用:** #####

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

> **继承中构造方法的关系**

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

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

> **注意事项**

1.  父类没有无参构造方法，子类怎么办?
    
     *  在父类中添加一个无参的构造方法
     *  子类通过super去显示调用父类其他的带参的构造方法
     *  子类通过this去调用本类的其他构造方法
2.  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

> **继承中成员方法关系**

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

> **方法重写概述及其应用**

1.  **方法重写**
    
     *  子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。
2.  **方法重写的作用**
    
     *  当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
3.  **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();
        }
    }

> **方法重写的注意事项**

1.  父类中**私有**方法**不能被重写**。  
    
    
     *  因为父类**私有方法**子类根本就**无法继承**。
2.  子类重写父类方法时，访问权限不能更低。  
    
    
     *  子类的方法的访问权限要**大于或者等于**父类的方法的访问权限。
     *  建议:最好就一致。
3.  父类静态方法，子类也必须通过静态方法进行重写。  
    
    
     *  其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，参见多态内容。
4.  子类重写父类方法的时候，最好声明一模一样。