【Java基础08_2】继承

概述

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

格式

通过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的一种，就可以考虑使用继承。

继承中成员变量的关系

子类中的成员变量和父类中的成员变量名称可以不一样

子类中的成员变量和父类中的成员变量名称可以一样，在子类中访问一个变量的查找顺序遵循”就近原则”

在子类的方法的局部范围找,有就使用

在子类的成员范围找,有就使用

在父类的成员范围找,有就使用

如果还找不到,就报错

this 和 super 的区别和应用

[b]区别:[/b]

this 代表的是本类对象的引用

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

[b]应用:[/b]

调用成员变量

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();
}
}

方法重写的注意事项

父类中私有方法不能被重写。

因为父类私有方法子类根本就无法继承。

子类重写父类方法时，访问权限不能更低。

子类的方法的访问权限要大于或者等于父类的方法的访问权限。

建议:最好就一致。

父类静态方法，子类也必须通过静态方法进行重写。

其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，参见多态内容。

子类重写父类方法的时候，最好声明一模一样。