Java面向对象之继承

Posted 2021-12-09 程序员老陆

目录

​​1. 继承​​

​​1.1 继承的实现（掌握）​​

​​2. 继承中的成员访问特点​​

​​2.1 继承中变量的访问特点（掌握）​​

​​2.2 super（掌握）​​

​​2.3 继承中构造方法的访问特点（理解）​​

​​2.4 继承中成员方法的访问特点（掌握）​​

​​2.5 super内存图（理解）​​

​​2.6 方法重写（掌握）​​

​​2.7 方法重写的注意事项（掌握）​​

​​2.8. Java中继承的注意事项（掌握）​​

​​3. 总结​​

---

1. 继承

1.1 继承的实现（掌握）

继承的概念

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法实现继承的格式继承通过extends实现

格式：class 子类 extends 父类 { }

举例：class Dog extends Animal { }

继承带来的好处 ：继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

示例代码

public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
//创建对象，调用方法
        Fu f = new Fu();
        f.show();
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

1.2 继承的好处和弊端（理解）

继承好处：

提高了代码的复用性(多个类相同的成员可以放到同一个类中)

提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

继承弊端 ：

继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

继承的应用场景：

使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承 is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

2. 继承中的成员访问特点

2.1 继承中变量的访问特点（掌握）

在子类方法中访问一个变量，采用的是就近原则。

1. 子类局部范围找

2. 子类成员范围找

3. 父类成员范围找

4. 如果都没有就报错(不考虑父亲的父亲…)

示例代码

class Fu {
    int num = 10;
}
class Zi {
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); // 输出show方法中的局部变量30
    }
}

2.2 super（掌握）

this&super关键字：

this：代表本类对象的引用

super：代表父类存储空间的标识(可以理解为父类对象引用)

this和super的使用分别：

成员变量：

this.成员变量 - 访问本类成员变量

super.成员变量 - 访问父类成员变量

成员方法：

this.成员方法 - 访问本类成员方法

super.成员方法 - 访问父类成员方法

构造方法：

this(…) - 访问本类构造方法

super(…) - 访问父类构造方法

2.3 继承中构造方法的访问特点（理解）

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，

原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法

2. 在父类中自己提供一个无参构造方法

推荐方案：

自己给出无参构造方法

2.4 继承中成员方法的访问特点（掌握）

通过子类对象访问一个方法

1. 子类成员范围找

2. 父类成员范围找

3. 如果都没有就报错(不考虑父亲的父亲…)

2.5 super内存图（理解）

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

2.6 方法重写（掌握）

1、方法重写概念

子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

2、方法重写的应用场景

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了

父类的功能，又定义了子类特有的内容

3、Override注解

用来检测当前的方法，是否是重写的方法，起到【校验】的作用

2.7 方法重写的注意事项（掌握）

方法重写的注意事项

1. 私有方法不能被重写(父类私有成员子类是不能继承的)

2. 子类方法访问权限不能更低(public > 默认 > 私有)

示例代码

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }
    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}
public class Zi extends Fu {
    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }
    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

2.8. Java中继承的注意事项（掌握）

Java中继承的注意事项

1. Java中类只支持单继承，不支持多继承

错误范例：class A extends B, C { }

2. Java中类支持多层继承

多层继承示例代码：

public class Granddad {
    public void drink() {
        System.out.println("爷爷爱喝酒");
    }
}
public class Father extends Granddad {
    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }
}
public class Mother {
    public void dance() {
        System.out.println("妈妈爱跳舞");
    }
}
public class Son extends Father {
// 此时，Son类中就同时拥有drink方法以及smoke方法
}

3. 总结

重点针对面向对象的三大特征：继承、封装、多态。另外还包括抽象类、接口、内部类等概念。很多概念对于初学者来说，更多的是先进行语法性质的了解。不要期望，通过学习面向对象三大特征就“搞透面向对象”。本章只是面向对象的起点，后面所有的章节说白了都是对面向对象面向对象三大特征的应用。

注：

建议大家，学完面向对象三大特征，迅速开展后面的学习。可以这么说，以后所有的编程都是“面向对象”的应用而已！ 继承让我们更加容易实现类的扩展。 比如，我们定义了人类，再定义Boy类就只需要扩展人类即可。实现了代码的重用，不用再重新发明轮子(don’t reinvent wheels)。

从英文字面意思理解，extends的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。比如：

现实世界中的继承，哺乳动物继承了动物。意味着，动物的特性，哺乳动物都有；在我们编程中，如果新定义一个Student类，发现已经有Person类包含了我们需要的属性和方法，那么Student类只需要继承Person类即可拥有Person类的属性和方法。

使用extends实现继承：

/**
 * 测试继承
 * @author 赵广陆
 *
 */
public class TestExtends {
  public static void main(String[] args) {
    Student   stu  =  new Student();
    stu.name="张三";
    stu.height = 180;
    stu.rest();

    Student  stu2 = new Student("李四",6,"计算机专业");

    System.out.println(stu2   instanceof  Student);
    System.out.println(stu2   instanceof   Person ); 
    System.out.println(stu2   instanceof   Object ); 
    System.out.println(new Person()   instanceof   Student ); 

  }
}

class  Person   /*extends  Object*/ {
  String  name;
  int   height;

  public void  rest(){
    System.out.println("休息一会！");
  }
}

class  Student   extends  Person  {
  String   major;

  public   void   study(){
    System.out.println("学习两小时！");
  }

  public  Student(String name,int height, String  major){
    this.name = name;
    this.height = height;
    this.major = major;
  }

  public Student(){
  }
}

运行效果：