logo头像
Snippet 博客主题

【JavaSe必知必会】34-面向对象三大特性之继承

继承概述

  • 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
  • 通过extends关键字可以实现类与类的继承
    • class 子类名 extends 父类名{}
  • 单独的这个类成为父类,基类或者超类;这多个类可以称为子类或者派生类。
  • 有了继承以后,我们定义一个类的时候,可以在一个已经存在的类的基础上,还可以定义自己的新成员。

    继承的好处

  • 提高了代码的复用性
    • 多个类相同的成员可以放到同一个类中
  • 提高了代码的维护性
    • 如果功能的代码需要修改,修改一处即可
  • 让类与类之间产生了关系,是多态的前提
    • 其实这也是类的一个弊端:类的耦合性很强
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/*
继承概述:
把多个类中相同的内容给提取出来定义到一个类中。

如何实现继承?
Java提供了关键字:extends

格式:
class 子类名 extends 父类名{}

好处:
A:提供了代码的复用性
B:提供了代码的维护性
C:让类与类之间产生关系,是多态的前提

*/
//继承前
/*class Student{
public void eat(){
System.out.println("吃饭");
}

public void sleep(){
System.out.println("睡觉");
}
}

class Teacher{
public void eat(){
System.out.println("吃饭");
}

public void sleep(){
System.out.println("睡觉");
}
}*/
//使用继承后
class Person{
public void eat(){
System.out.println("吃饭");
}

public void sleep(){
System.out.println("睡觉");
}
}

class Student extends Person{}

class Teacher extends Person{}

public class ExtendsDemo{
public static void main(String[] args){
Student s = new Student();
s.eat();
s.sleep();
System.out.println("-------------");

Teacher t = new Teacher();
t.eat();
t.sleep();
}
}

继承的特点

  • java中只支持单继承,不支持多继承
    • 一个类中只能有一个父类,不可以有多个父类
    • class SubDemo extends Demo{} //ok
    • class SubDemo extends Demo1,Demo2…//error
  • java支持多层继承(继承体系)
    • class A{}
    • class B extends A{}
    • class C extends B{}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
java中继承的特点:
A:java中只支持单继承,不支持多继承
有些语言是支持多继承的,格式:extends 类1,类2,...
B:java支持多层继承(继承体系)
*/
/*
class Father{}
class Mother{}
class Son extends Father,Mother{}
*/
class GrandFather{
public void show(){
System.out.println("我是你爷爷");
}
}
class Father extends GrandFather{
public void method(){
System.out.println("我是你爸爸");
}
}

class Son extends Father{}

public class ExtendsDemo2{
public static void main(String[] args){
Son s = new Son();
s.method();
Father f = new Father();
f.show();
s.show();
}
}

继承的注意事项

  • 子类只能继承父类所有非私有的成员(成员方法和成员变量)
    • 其实这也体现了继承的另一个弊端:打破了封装性
  • 子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法
  • 不要为了部分功能而去继承
  • 什么时候使用继承呢?
    • 继承中类之间体现的是:”is a“的关系
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/*
继承的注意事项:
A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
B:子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法
C:不要为了部分功能而去继承
class A{
public void show1(){}
public void show2(){}
}
class B{
public void show2(){}
public void show3(){}
}
//我们发现B类中出现了和A类一样的show2()方法,所以,我们就用继承体现
class B extends A{
public void show3(){}
}
这样其实不好,因为这样你不但有了show2()方法,还多show1(),有可能这个show1()不是我们想要的。

那么,我们什么适合考虑使用继承呢?
继承中类之间体现的是:”is a“的关系
Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法:
如果有两个类A,B,只有她们符合A是B的一种,或者B是A的一种,就可以考虑继承
*/
class Father{
private int num = 10;
public int num2 = 20;

private void method(){
System.out.println(num);
System.out.println(num2);
}

public void show(){
System.out.println(num);
System.out.println(num2);
}
}

class Son extends Father{
public void function(){
//System.out.println(num);//num 在 Father 中是 private 访问控制
System.out.println(num2);
}
}

public class ExtendsDemo3{
public static void main(String[] args){
//创建对象
Son s = new Son();
//s.method();//子类不能继承父类的私有方法
s.show();
//System.out.println(s.num);//num 在 Father 中是 private 访问控制
s.function();
}
}

继承中成员变量的关系

在子类方法中访问一个变量

  • 首先在子类局部范围找
  • 然后在子类成员范围找
  • 最后在父类成员范围找(肯定不能访问到父类局部范围)
  • 如果还是没有就报错(不考虑父亲的父亲…)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/*
类的组成:
成员变量
构造方法
成员方法
现在我们又讲了继承,所以,我们就应该考虑一下,类的组成部分的各自关系

继承中的成员变量的关系:
A:子类中的成员变量和父类中的成员变量名称不一样
B:子类中的成员变量和父类中的成员变量名称一样
在子类中访问一个变量的查找顺序:
a:在子类方法的局部范围找,有就使用
b:在子类的成员范围找,有就使用
c:在父类的成员范围找,有就使用
d:如果还找不到,会报错

*/
class Father{
public int num = 10;

public void method(){
int num = 50;
}
}

class Son extends Father{
public int num2 = 20;
public int num = 30;
public void show(){
int num = 40;
System.out.println(num);
System.out.println(num2);
//System.out.println(num3);//找不到符号
}
}

public class ExtendsDemo4{
public static void main(String[] args){
Son s = new Son();
s.show();
}
}

super关键字

  • super的用法和this很像
    • this代表本类对应的引用
    • super代表父类存储空间的标识(可以理解为父类引用)

      用法

  • 访问成员变量
    • this.成员变量
    • super.成员变量
  • 访问构造方法
    • this(…)
    • super(…)
  • 访问成员方法
    • this.成员方法()
    • super.成员方法()

      继承中构造方法的关系

  • 子类中所有的构造方法默认都会访问父类中空参的构造方法
    • 因为子类会继承父类中的数据,可能还会使用父类的数据。所以,子类初始化之前,一定要完成父类数据的初始化
    • 每一个构造方法的第一条语句默认都是:super()
  • 如果父类中没有构造方法,该怎么办?
    • 子类通过super去显示调用父类其他的带参的构造方法
    • 子类通过this去调用本类的其他构造方法
      • 本类其他构造方法也必须首先访问了父类的构造方法
    • 一定要注意:
      • super(…)或者this(…)必须出现在第一条语句上
      • 否则,就会有父类数据的多次初始化

        继承中成员方法的关系

  • 通过子类对象去访问一个方法
    • 首先在子类中找
    • 然后在父类中找
    • 如果还是没有就报错

      方法重写

      概述

  • 子类中出现了和父类中一模一样的方法声明,也被称为方法覆盖,方法复写。
  • 使用特点:
    • 如果方法名不同,有就调用对应的方法。
    • 如果方法名相同,最终使用的就是子类自己的。

      应用

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

      注意事项

  • 父类中私有方法不能被重写
  • 子类重写父类方法时,访问权限不能更低
  • 父类静态方法,子类也必须通过静态方法进行重写(其实算不上方法重写)
微信打赏

赞赏是不耍流氓的鼓励