Java 从入门到进阶之路(十)

之前的文章我们介绍了一下 Java 中的引用型数组类型,接下来我们再来看一下 Java 中的继承。

继承的概念

继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

在日常生活中,我们会养些猫和狗,从程序的角度讲猫和狗都属于对象,那么我们就可以根据其特性来定义,如下:

 1 class Dog extends Animal {
 2     String name;
 3     String color;
 4     int age;
 5 
 6     void run() {
 7         System.out.println("我可以跑");
 8     }
 9 
10     void lookDoor() {
11         System.out.println("我可以看门");
12     }
13 }
14 
15 class Cat {
16     String name;
17     String color;
18     int age;
19 
20     void run() {
21         System.out.println("我可以跑");
22     }
23 
24     void catchMouse() {
25         System.out.println("我可以抓老鼠");
26     }
27 }

我们在定义 Dog 和 Cat 类的时候发现它们绝大部分属性和方法是相同的。那这样的话我们再定义其他动物的时候同样会出现这种气矿,这就造成了大量代码的重复,造成程序臃肿,不易维护。

我们可以这样解决上面的问题,将 Dog 和 Cat 类里相同的属性和方法写到一个父类里,自己特有的方法在自己的类里完成,这样就可以有效的解决上面的问题,其实这就是 Java 类的继承,如下:

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         Dog dog = new Dog();
 4         dog.run(); // 我可以跑
 5         dog.lookDoor(); // 我可以看门
 6 
 7         Cat cat = new Cat();
 8         cat.run(); // 我可以跑
 9         cat.catchMouse(); // 我可以抓老鼠
10     }
11 }
12 
13 class Animal{
14     String name;
15     String color;
16     int age;
17 
18     void run() {
19         System.out.println("我可以跑");
20     }
21 }
22 
23 class Dog extends Animal {
24     void lookDoor() {
25         System.out.println("我可以看门");
26     }
27 }
28 
29 class Cat extends Animal {
30     void catchMouse() {
31         System.out.println("我可以抓老鼠");
32     }
33 }

在上面的代码中,我们定义类一个 Animal 类,里面定义了 Dog 和 Cat 类中相同的属性和方法,然后我们在定义 Dog 和 Cat 类的时候通过 extends Animal 的方式来继承 Animal 类,当我们继承 Animal 类的时候,Animal 类中的属性和方法就会被一并继承过来,这样我们在声明 Dog 和 Cat 类的时候便可以调用从 Animal 类及成果来的属性和方法,这就是继承。

继承:

1、目的:避免代码重复,有利于代码的重用

2、通过 extends 实现继承

3、父类:所有子类所用共有的属性和方法;子类:子类所特有的属性和方法

4、子类继承父类后,子类具有 子类+父类 的属性和方法

5、一个父类可以有多个子类,一个子类只能有一个父类-----单一继承

6、继承具有传递性

7、Java 规定:构造子类之前必须先构造父类,子类构造中若没有调用父类的构造,则默认super(),若自己调了,则不再默认提供。

在上面的5,6条我们可以看出,在写程序时,我们不能这样 class Dog extends Cat extends Animal 的形式来实现继承,这样会出现编译错误,但是我们可以通过   class Cat extends Animal class Dog extends Cat 的形式来逐层进行继承。

在上面的代码中我们已经了解了 Java 的继承,接下来我们在结合之前说到的构造方法来介绍一下 super

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         Dog dog = new Dog();
 4         dog.run(); // 我可以跑
 5         dog.lookDoor(); // 我可以看门
 6         dog.name = "旺财";
 7         dog.color = "黄色";
 8         dog.age = 8;
 9         System.out.println("我叫" + dog.name + ",今年" + dog.age + ",是" + dog.color + "的"); // 我叫旺财,今年8,是黄色的
10 
11         Cat cat = new Cat("咪咪", "白色", 5);
12         cat.run(); // 我可以跑
13         cat.catchMouse(); // 我可以抓老鼠
14         System.out.println("我叫" + cat.name + ",今年" + cat.age + ",是" + cat.color + "的"); // 我叫咪咪,今年5,是白色的
15     }
16 }
17 
18 class Animal {
19     String name;
20     String color;
21     int age;
22 
23     Animal() {
24 
25     }
26 
27     Animal(String name, String color, int age) {
28         this.name = name;
29         this.color = color;
30         this.age = age;
31     }
32 
33     void run() {
34         System.out.println("我可以跑");
35     }
36 }
37 
38 class Dog extends Animal {
39     Dog() {
40         super();
41     }
42 
43     void lookDoor() {
44         System.out.println("我可以看门");
45     }
46 }
47 
48 class Cat extends Animal {
49     Cat(String name, String color, int age) {
50         super(name, color, age);
51     }
52 
53     void catchMouse() {
54         System.out.println("我可以抓老鼠");
55     }
56 }

在上面的代码中,我们在父类 Animal 类中分别定义了一个无参构造和一个有参构造,在子类 Dog 中定义了一个无参构造,在子类 Cat 中定义类一个有参构造,我们发现,在子类的构造方法中我们添加了一个 super() 的方法,通过这种方法我们就可以继承来自父类的构造方法,从而在实例化我们的子类的时候初始化我们想要的参数,在继承父类的有参构造的时候需要将父类有参构造的参数传递进来。

接下来我们来看下面的代码:

 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         Dog dog1 = new Dog();
 4         Dog dog2 = new Animal(); // 编译错误
 5         Animal animal1 = new Animal();
 6         animal1.run(); // 我可以跑
 7         animal1.lookDoor(); // 编译错误
 8         Animal animal2 = new Dog();
 9         animal2.run(); // 我可以跑
10         animal1.lookDoor(); // 编译错误
11     }
12 }
13 
14 class Animal {
15     String name;
16     String color;
17     int age;
18 
19     Animal() {
20 
21     }
22 
23     Animal(String name, String color, int age) {
24         this.name = name;
25         this.color = color;
26         this.age = age;
27     }
28 
29     void run() {
30         System.out.println("我可以跑");
31     }
32 }
33 
34 class Dog extends Animal {
35     Dog() {
36         super();
37     }
38 
39     void lookDoor() {
40         System.out.println("我可以看门");
41     }
42 }

在上面的代码中,我们如果通过 new Dog() 来创建一个 Dog 对象是完全没有问题的,通过 new Animal() 来创建一个 Animal 对象也是没有问题的,但是通过 new Animal() 来创建一个 Dog 对象会编译错误,通过 new Dog() 来创建一个 Animal 对象也是没有问题的,我们可以这样理解,new 类名() 所指向的类必须是本类或父类,不能是子类,即等号左侧的类型必须大于或等于等号右侧的 new 出来的类。当大于时我们称之为向上造型。向上造型后  子类 将不再具备其自己定义的方法,只有父类的方法。

我来评几句
登录后评论

已发表评论数()

相关站点

热门文章