Java继承概念详细解读

时间:2022-02-28 06:55:10

继承与合成基本概念

继承:可以基于已经存在的类构造一个新类。继承已经存在的类就可以复用这些类的方法和域。在此基础上,可以添加新的方法和域,从而扩充了类的功能。

合成:在新类里创建原有的对象称为合成。这种方式可以重复利用现有的代码而不更改它的形式。

1.继承的语法

关键字extends表明新类派生于一个已经存在的类。已存在的类称为父类或基类,新类称为子类或派生类。例如:

?
1
2
class student extends person {
}

类student继承了person,person类称为父类或基类,student类称为子类或派生类。

2.合成的语法

合成比较简单,就是在一个类中创建一个已经存在的类。

?
1
2
3
class student {
  dog dog;
}

上溯造型

1.基本概念

继承的作用在于代码的复用。由于继承意味着父类的所有方法亦可在子类中使用,所以发给父类的消息亦可发给衍生类。如果person类中有一个eat方法,那么student类中也会有这个方法,这意味着student对象也是person的一种类型。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class person {
    public void eat() {
        system.out.println("eat");
    }
    static void show(person p) {
        p.eat();
    }
}
public class student extends person{
    public static void main(string[] args) {
        student s = new student();
        person.show(s);
        // ①
    }
}

【运行结果】:

eat

在person中定义的show方法是用来接收person句柄的,但是在①处接收的却是student对象的引用。这是因为student对象也是person对象。在show方法中,传入的句柄(对象的引用)可以是person对象以及person的衍生类对象。这种将student句柄转换成person句柄的行为成为上溯造型。

2.为什么要上溯造型

为什么在调用eat是要有意忽略调用它的对象类型呢?如果让show方法简单地获取student句柄似乎更加直观易懂,但是那样会使衍生自person类的每一个新类都要实现专属自己的show方法:

?
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
class value {
    private int count = 1;
    private value(int count) {
        this.count = count;
    }
    public static final value
          v1 = new value(1),
          v2 = new value(2),
          v3 = new value(3);
}
class person {
    public void eat(value v) {
        system.out.println("person.eat()");
    }
}
class teacher extends person {
    public void eat(value v) {
        system.out.println("teacher.eat()");
    }
}
class student extends person {
    public void eat(value v) {
        system.out.println("student.eat()");
    }
}
public class upcastingdemo {
    public static void show(student s) {
        s.eat(value.v1);
    }
    public static void show(teacher t) {
        t.eat(value.v1);
    }
    public static void show(person p) {
        p.eat(value.v1);
    }
    public static void main(string[] args) {
        student s = new student();
        teacher t = new teacher();
        person p = new person();
        show(s);
        show(t);
        show(p);
    }
}

这种做法一个很明显的缺陷就是必须为每一个person类的衍生类定义与之紧密相关的方法,产生了很多重复的代码。另一方面,对于如果忘记了方法的重载也不会报错。上例中的三个show方法完全可以合并为一个:

?
1
2
3
public static void show(person p) {
   p.eat(value.v1);
}

动态绑定

当执行show(s)时,输出结果是student.eat(),这确实是希望得到的结果,但是似乎没有按照我们希望的形式来执行,再来看一下show方法:

?
1
2
3
public static void show(person p) {
   p.eat(value.v1);
}

它接收的是person句柄,当执行show(s)时,它是如何知道person句柄指向的是一个student对象而不是teacher对象呢?编译器是无从得知的,这涉及到接下来要说明的绑定问题。

1.方法调用的绑定

将一个方法同一个方法主体连接在一起就称为绑定(binding)。若在运行运行前执行绑定,就称为“早期绑定”。上面的例子中,在只有一个person句柄的情况下,编译器不知道具体调用哪个方法。java实现了一种方法调用机制,可在运行期间判断对象的类型,然后调用相应的方法,这种在运行期间进行,以对象的类型为基础的绑定称为动态绑定。除非一个方法被声明为final,java中的所有方法都是动态绑定的。

用一张图表示上溯造型的继承关系:

Java继承概念详细解读

用代码概括为:

shapes=newshape();

按照继承关系,将创建的circle对象句柄赋给一个shape是合法的,因为circle属于shape的一种。

当调用其中一个基础类方法时:

shapes=newshape();

此时,调用的是circle.draw(),这是由于动态绑定的原因。

?
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
class person {
    void eat() {
    }
    void speak() {
    }
}
class boy extends person {
    void eat() {
        system.out.println("boy.eat()");
    }
    void speak() {
        system.out.println("boy.speak()");
    }
}
class girl extends person {
    void eat() {
        system.out.println("girl.eat()");
    }
    void speak() {
        system.out.println("girl.speak()");
    }
}
public class persons {
    public static person randperson() {
        switch ((int)(math.random() * 2)) {
            default:
                case 0:
                  return new boy();
            case 1:
                  return new girl();
        }
    }
    public static void main(string[] args) {
        person[] p = new person[4];
        for (int i = 0; i < p.length; i++) {
            p[i] = randperson();
            // 随机生成boy或girl
        }
        for (int i = 0; i < p.length; i++) {
            p[i].eat();
        }
    }
}

对所有从person衍生出来的类,person建立了一个通用接口,所有衍生的类都有eat和speak两种行为。衍生类覆盖了这些定义,重新定义了这两种行为。在主类中,randperson随机选择person对象的句柄。**上诉造型是在return语句里发生的。**return语句取得一个boy或girl的句柄并将其作为person类型返回,此时并不知道具体是什么类型,只知道是person对象句柄。在main方法中调用randperson方法为数组填入person对象,但不知具体情况。当调用数组每个元素的eat方法时,动态绑定的作用就是执行对象的重新定义了的方法。

然而,动态绑定是有前提的,绑定的方法必须存在于基类中,否则无法编译通过。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class person {
    void eat() {
        system.out.println("person.eat()");
    }
}
class boy extends person {
    void eat() {
        system.out.println("boy.eat()");
    }
    void speak() {
        system.out.println("boy.speak()");
    }
}
public class persons {
    public static void main(string[] args) {
        person p = new boy();
        p.eat();
        p.speak();
        // the method speak() is undefined for the type person
    }
}

如果子类中没有定义覆盖方法,则会调用父类中的方法:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
class person {
    void eat() {
        system.out.println("person.eat()");
    }
}
class boy extends person {
}
public class persons {
    public static void main(string[] args) {
        person p = new boy();
        p.eat();
    }
}

【运行结果】:

person.eat()

2.静态方法的绑定

将上面的方法都加上static关键字,变成静态方法:

?
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
class person {
    static void eat() {
        system.out.println("person.eat()");
    }
    static void speak() {
        system.out.println("person.speak()");
    }
}
class boy extends person {
    static void eat() {
        system.out.println("boy.eat()");
    }
    static void speak() {
        system.out.println("boy.speak()");
    }
}
class girl extends person {
    static void eat() {
        system.out.println("girl.eat()");
    }
    static void speak() {
        system.out.println("girl.speak()");
    }
}
public class persons {
    public static person randperson() {
        switch ((int)(math.random() * 2)) {
            default:
                case 0:
                  return new boy();
            case 1:
                  return new girl();
        }
    }
    public static void main(string[] args) {
        person[] p = new person[4];
        for (int i = 0; i < p.length; i++) {
            p[i] = randperson();
            // 随机生成boy或girl
        }
        for (int i = 0; i < p.length; i++) {
            p[i].eat();
        }
    }
}

【运行结果】:
person.eat()
person.eat()
person.eat()
person.eat()
观察结果,对于静态方法而言,不管父类引用指向的什么子类对象,调用的都是父类的方法。

助记口诀

- 静态方法:静态方法看父类
- 非静态方法:非静态方法看子类

总结

以上就是本文关于java继承概念详细解读的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

原文链接:http://www.cnblogs.com/xiaoxiaoyihan/p/5014682.html