day7抽象类接口多态

Posted 2020-08-14

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了day7抽象类接口多态相关的知识，希望对你有一定的参考价值。

抽象类

为什么使用抽象类

1：定义Dog类

有颜色属性和叫的方法

2：定义Bird类

有颜色属性和叫的方法

3：定义其父类Animal

1：抽取共性颜色属性和叫的方法

1：颜色的属性可以使用默认初始化值。

2：叫的方法在父类中如何定义？

1：狗是旺旺

2：鸟是叽叽喳喳

3：可以将父类的方法定义为狗叫让鸟继承父类重写叫的方法

1：鸟怎么确定是否要重写父类方法。

　　　　　　　2：不重写，编译和运行都没有问题，只是执行鸟叫的方法就会出现狗叫

4：父类的方法很难确定。

4：抽象类

　　　　1：当描述一个类的时候，如果不能确定功能函数如何定义，那么该类就可以定义为抽象类，功能函数应该描述为抽象函数。

5：抽象类的实现方式

1：定义animal类

1：定义叫的方法，无法确定方法体，不写方法体

1：public void shout (); 编译失败

2：根据提示在shout的方法加入abstract修饰

1：编译失败，有新的提示

3：根据提示将类加入abstract修饰

1：编译通过

 1 abstract class Animal {
 2     String color;
 3 
 4     abstract void shout();
 5 }
 6 
 7 class Dog extends Animal {
 8 
 9     void shout() {
10         System.out.println("旺旺");
11     }
12 
13 }
14 
15 class Bird extends Animal {
16 
17     void shout() {
18         System.out.println("叽叽喳喳");
19     }
20 }

View Code

6：抽象类的特点

1：有抽象函数的类，该类一定是抽象类。

2：抽象类中不一定要有抽象函数。

3：抽象类不能使用new创建对象

1：创建对象，使用对象的功能，抽象类的方法，没有方法体。

4：抽象类主要为了提高代码的复用性，让子类继承来使用。

5：编译器强制子类实现抽象类父类的未实现的方法。

1：可以不实现，前提是子类的也要声明为抽象的。

7：抽象的优点

1：提高代码复用性

2：强制子类实现父类中没有实现的功能

2：提高代码的扩展性，便于后期的代码维护

8：抽象类不能创建对象，那么抽象类中是否有构造函数？

　　　　　　1：抽象类中一定有构造函数。主要为了初始化抽象类中的属性。通常由子类实现。

9：final和abstract是否可以同时修饰一个类？

一定不能同时修饰。

 1 abstract class Animal {
 2 
 3     String name;
 4 
 5     // 抽象类可以有构造函数
 6     Animal() {
 7 
 8     }
 9 
10     Animal(String name) {
11         this.name = name;
12     }
13 
14     abstract void shout();
15 
16 }
17 
18 class Dog extends Animal {
19     Dog() {
20 
21     }
22 
23     Dog(String name) {
24         super(name);
25     }
26 
27     void shout() {
28         System.out.println("旺旺");
29 
30     }
31 }
32 
33 class Demo3 {
34 
35     public static void main(String[] args) {
36         // 抽象类不能创建对象
37         // Animal a=new Animal();
38         Dog d = new Dog("旺财");
39 
40         System.out.println();
41     }
42 }

View Code

2：抽象练习

1：定义抽象类MyShape（图形）

1：定义抽象方法获取图形的长度和面积

2：定义子类Rect继承父类MyShape

1：定义自身特有的长和宽（成员变量） width height;

2：实现父类未实现的函数。

3：定义子类 Circle实现父类MyShape

1：定义自身特有的半径和圆周率（使用常量）

2：实现父类为实现的方法。

 1 /*
 2  }
 3  2：抽象练习 
 4  1：定义抽象类MyShape（图形）
 5  1：定义抽象方法获取图形的长度和面积
 6  2：定义子类Rect继承父类MyShape   
 7  1：定义自身特有的长和宽（成员变量）  width height;
 8  2：实现父类未实现的函数。
 9  3：定义子类 Circle实现父类MyShape
10  1：定义自身特有的半径和圆周率（使用常量）
11  2：实现父类为实现的方法。
12  */
13 abstract class MyShape {
14 
15     abstract double getLen();
16 
17     abstract double getArea();
18 
19 }
20 
21 class Rect extends MyShape {
22     double width;
23     double height;
24 
25     Rect() {
26 
27     }
28 
29     Rect(double width, double height) {
30         this.width = width;
31         this.height = height;
32     }
33 
34     double getLen() {
35         return 2 * (width + height);
36     }
37 
38     double getArea() {
39         return width * height;
40     }
41 }
42 
43 class Circle extends MyShape {
44     double r;
45     public static final double PI = 3.14;
46 
47     Circle() {
48 
49     }
50 
51     Circle(double r) {
52         this.r = r;
53     }
54 
55     double getLen() {
56         return 2 * PI * r;
57     }
58 
59     double getArea() {
60         return PI * r * r;
61     }
62 }
63 
64 class Demo4 {
65 
66     public static void main(String[] args) {
67         Rect r = new Rect(5, 5);
68         System.out.println(r.getLen());
69         System.out.println(r.getArea());
70         System.out.println();
71 
72         Circle c = new Circle(5);
73         System.out.println(c.getLen());
74         System.out.println(c.getArea());
75 
76     }
77 }