第11章（下）--面向对象编程（高级特性）

Posted 2020-12-11 -xuewuzhijing-

1.  抽象类

 

当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法，这个方法就是抽象方法,用abstract 来修饰该类就是抽象类。

 

 

 

      抽象类的介绍

 

1)      用abstract 关键字来修饰一个类时,这个类就叫抽象类
访问修饰符 abstract 类名{
}

2)      用abstract 关键字来修饰一个方法时,这个方法就是抽象方法
访问修饰符 abstract 返回类型 方法名(参数列表);

 

3)      抽象类的价值更多是在于设计，是设计者设计好后，让子类继承并实现抽象类(即：实现抽象类的抽象方法)

 

4)      抽象方法在编程中用的不是很多,但是在公司笔试时,却是考官比较爱问的知识点

 

 

 

   抽象类使用的注意事项和细节讨论

 

1)      抽象类不能被实例化  [举例]

2)      抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法 [举例]

3)      一旦类包含了abstract方法,则这个类必须声明为abstract [说明]

4)      abstract 只能修饰类和方法，不能修饰属性和其它的。[说明]

5)      抽象类可以有任意成员【因为抽象类还是类】，比如：非抽象方法、构造器、静态属性等等 [举例]

6)      抽象方法不能有主体，即不能实现.如图所示

7)      如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例 A类,B类,C类]

8)      抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的。说明: static关键字是不和重写相关，static方法不能重写

 

• 和前面一样，多态在抽象类上也体现在

多态数组【存放不同的子类对象, Dog和Cat】

多态参数【接收不同的子类对象】

 

 

 1 public class AbstractPolyDemo {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         
 6         Animal03 animals[] = new Animal03[2];
 7         animals[0] = new Cat03();
 8         animals[1] = new Dog03();
 9         
10         //抽象类体现出多态数组
11         for (int i = 0; i < animals.length; i++) {
12             animals[i].eat();
13             show(animals[i]);
14         }
15 
16     }
17     
18     //多态参数
19     public static void show(Animal03 animal) {
20         if (animal instanceof Cat03) {
21             Cat03 cat = (Cat03)animal;
22             cat.catchMouse();
23         } else if (animal instanceof Dog03) {
24             Dog03 dog = (Dog03)animal;
25             dog.watchDoor();
26         }
27     }
28 
29 }
30 
31 abstract class Animal03 {
32     
33     abstract public void eat();
34 }
35 
36 class Cat03 extends Animal03 {
37 
38     @Override
39     public void eat() {
40         // TODO Auto-generated method stub
41         System.out.println("小猫喜欢吃<?)))><<");
42     }
43     
44     public void catchMouse() {
45         System.out.println("小猫抓老鼠");
46     }
47     
48 }
49 
50 class Dog03 extends Animal03 {
51 
52     @Override
53     public void eat() {
54         // TODO Auto-generated method stub
55         System.out.println("小狗喜欢吃骨头~~");
56     }
57     
58     public void watchDoor() {
59         System.out.println("小狗看门~~");
60     }
61     

 

 

        抽象类最佳实践-模板设计模式

1.1.1       基本介绍

 

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

   

     最佳实践

 

设计一个抽象类(Template)，能完成如下功能:

1)      编写方法caleTime() ,可以计算某段代码的耗时时间

2)      编写抽象方法code()

3)      编写一个子类Sub,继承抽象类Template，并实现code方法。

4)      编写一个测试类TestTemplate,看看是否好用。

 

 1 public class AbstractTemplateDemo {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         Sub sub = new Sub();
 6         sub.caleTime();
 7         
 8         Sub2 sub2 = new Sub2();
 9         sub2.caleTime();
10 
11     }
12 
13 }
14 
15 // 通过抽象类开发要给 模板设计模式
16 
17 abstract class Template {
18 
19     abstract public void code(); // code不确定.
20     // 统计code() 方法执行时间
21 
22     public void caleTime() {
23         // 1先得到当前的时间(毫秒)
24         long nowTime = System.currentTimeMillis();
25         code();
26         // 2得到执行后的时间
27         long endTime = System.currentTimeMillis();
28         System.out.println("执行代码时间为=" + (endTime - nowTime));
29     }
30 }
31 
32 class Sub extends Template { // 张三
33 
34     @Override
35     public void code() {
36         // TODO Auto-generated method stub
37         // 测试 hello, 拼接 10000次
38         String str = "hello";
39         for (int i = 0; i < 20000; i++) {
40             str += "jack" + i;
41         }
42 
43     }
44 
45 }
46 
47 class Sub2 extends Template {// 李四
48 
49     @Override
50     public void code() {
51         // TODO Auto-generated method stub
52         // 测试 hello, 拼接 10000次
53         StringBuilder str = new StringBuilder("hello");
54         for (int i = 0; i < 20000; i++) {
55             str.append("jack" + i);
56         }
57 
58     }
59 
60 }

 

 

 标准 服务 产品 项目

接口快速入门

 1 public class InterfaceDemo {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         Computer computer = new Computer();
 6         Phone phone = new Phone();
 7         Camera camera = new Camera();
 8         
 9         computer.work(phone); //这里因为Phone已经实现了UsbInterface
10         computer.work(camera);//这里因为Camera已经实现了UsbInterface
11 
12     }
13 
14 }
15 
16 
17 class Computer {
18     public void work(UsbInterface usbInterace) {
19         //...
20         usbInterace.start();
21         usbInterace.start();
22     }
23 }
24 
25 //定义给接口，要求各个类去实现
26 interface UsbInterface {
27     //定一些规范, 规范可以简单的理解就是方法（没有实现的方法）
28     public void start();
29     public void stop();
30 }
31 
32 class Camera implements UsbInterface {
33 
34     @Override
35     public void start() {
36         // TODO Auto-generated method stub
37         System.out.println("相机开始工作~~");
38     }
39 
40     @Override
41     public void stop() {
42         // TODO Auto-generated method stub
43         System.out.println("相机结束工作~~");
44         
45     }
46     
47 }
48 
49 class Phone implements UsbInterface {
50 
51     @Override
52     public void start() {
53         // TODO Auto-generated method stub
54         System.out.println("手机开始工作~~");
55         
56     }