Java 从入门到进阶之路(十)_腾讯云双十一,腾讯云

  • Java 从入门到进阶之路(十)_腾讯云双十一,腾讯云已关闭评论
  • 128 人浏览
  • A+
所属分类:首页

之前的文章我们引见了一下 Java 中的援用型数组范例,接下来我们再来看一下 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 出来的类。当大于时我们称之为向上外型。向上外型后  子类 将不再具有其本身定义的要领,只要父类的要领。

 

腾讯云双十一活动