韩顺平循序渐进学java 第13讲 抽象类.接口

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了韩顺平循序渐进学java 第13讲 抽象类.接口相关的知识,希望对你有一定的参考价值。

13.1抽象类

13.1.1 概念

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

13.1.2 抽象类-深入讨论

抽象类是java中一个比较重要的类:

1、用abstract关键字来修饰一个类时,这个类就叫抽象类;

2、用abstract关键字来修饰一个方法时,这个方法就叫抽象方法;

3、抽象方法在编程中用的不是很多,但是在公司笔试时考的较多。

13.1.3 抽象类-注意事项

1、抽象类不能实例化;

2、抽象类不一定要包含abstract方法;

3、一旦包含有abstract方法,则这个类必须声明为abstract类;

4、抽象方法不能有主体。例如 abstract void cry();  不能加{}

13.2 接口

13.2.1 概念

接口就是给出一些没有内容的方法,封装到一起,到某个类要使用的时候,再根据具体情况把这些方法写出来。语法:

class 类名 implements 接口

{

  方法;

  变量;

}

小结:接口是更加抽象的抽象的类,抽象类里的方法可以有方法体,但接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低耦合的设计思想。

13.2.2 注意事项

1、接口不能被实例化;

2、接口中所有的方法都不能有主体;例如 void cry(); 后不能有{}

3、一个类可以实现多个接口;

4、接口中可以有变量(但是变量不能用privateprotected修饰),注意:

  a. 接口中的变量,本质上都是static的,而且是final,不管你加不加static修饰;

  b. 在java开发中,经常把常用的变量,定义在接口中,作为全局变量使用。

访问形式: 接口名.变量名

5、一个接口不能继承其它的类,但是可以继承别的接口。

13.3 实现接口 vs 继承类

1、Java的继承是单继承,也就是一个类最多只能有一个父类,这种单继承的机制可以保证类的纯洁性,比c++中的多继承机制简洁。但是不可否认,对子类功能的扩展有一定影响。所以我们认为:实现接口可以看作是对继承的一种补充。

2、还有一点,继承是层级式的,不太灵活。这种结构修改某个类就会打破这种继承的平衡,而接口就没有这样的麻烦,因为它只针对实现接口的类才起作用。所以:实现接口可以在不打破集成关系的前提下,对某个类功能进行扩展,非常灵活。

13.4 绑定

将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定,分前期绑定和后期绑定两种。

1、前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定,比如static方法和final方法(注意:这里也包括private方法,因为它是隐式final的);

2、后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,因此又叫做动态绑定,或者运行时绑定,除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。

13.5 接口多态优点

继承是多态得以实现的基础。

从字面上理解,多态就是一种类型(如 都是Car类型)表现出多种形态(宝马名字是BMW,售价是300000;奇瑞名字是CheryQQ,售价是20000)。

多态给我们带来的好处是消除了类的耦合关系,使程序更容易扩展。

比如在汽车销售的例子中,新增加一种类型汽车的销售,只需要让新定义的类实现Car并实现它的所有方法,而无需对原有代码做任何修改,CarShop类的sellCar(Car car)方法就可以处理新的车型了。

 

抽象类的演示代码如下:

 

 1 /**日期:2016-03-04
 2  * 功能:抽象类的演示
 3  */
 4 public class Practice4 
 5 {
 6     public static void main(String []args)
 7     {
 8         //Animal an=new Animal(); //抽象类不能实例化
 9         Cat1 cat=new Cat1();
10         cat.cry();
11     }
12 }
13 
14 abstract class Animal1 //这就是一个抽象类
15 {
16     String name;
17     int age;
18     abstract public void cry();//抽象类中也可以没有抽象类,这时cry就变成了Cat类自己的成员方法
19     public void eat() //抽象类中也可以有实现的类
20     {
21         
22     }
23 }
24 
25 class Cat1
26 {
27     //当一个类继承的父类是抽象类的话,需要我们把父类中的抽象方法都实现
28     
29     public void cry()
30     {
31         System.out.println("喵喵叫!"); 
32     }
33 }

 

运行结果如下:

1 喵喵叫!

 

 接口演示代码如下:

 1 /**日期:2016-03-05
 2  * 功能:接口的演示
 3  */
 4 public class Practice1
 5 {
 6     public static void main(String []args)
 7     {
 8         Computer computer1=new Computer();
 9         computer1.useUsb(new Camera()); //体现了多态
10         computer1.useUsb(new Phone()); //体现了多态
11         computer1.insertEarPhone(new Phone()); //体现了多态
12         System.out.println(Usb.wrongMessage); //直接调用接口中声明的变量
13     }
14 }
15 class Computer
16 {
17     public void useUsb(Usb usb) //体现了多态
18     {
19         usb.start();
20         usb.stop();
21     }
22     public void insertEarPhone(Earphone earphone)
23     {
24         earphone.notice();
25         earphone.noticeSim();
26     }
27 }
28 interface Usb //定义接口
29 {
30     //接口中声明的变量为static的和final的(即必须初始化),可作为全局变量
31     String wrongMessage="404 not found!"; 
32     public void start();
33     public void stop();
34 }
35 
36 interface Simcard
37 {
38     public void noticeSim();
39 }
40 
41 interface Earphone extends Simcard //一个接口不能继承其它的类,但是可以继承别的接口
42 {
43     public void notice();
44 }
45 
46 //编写相机类,并实现Usb接口
47 //重要原则:当一个类实现了一个接口,就要求该类将这个接口的所有方法统统实现
48 class Camera implements Usb
49 {
50     public void start()
51     {
52         System.out.println("相机开始工作!");
53     }
54     public void stop()
55     {
56         System.out.println("相机停止工作!");
57     }
58 }
59 
60 class Phone implements Usb,Earphone //一个类可以实现多个接口
61 {
62     public void start()
63     {
64         System.out.println("手机开始工作!");
65     }
66     public void stop()
67     {
68         System.out.println("手机停止工作!");
69     }
70     public void notice()
71     {
72         System.out.println("耳机插入了!");
73     }
74     //Earphone继承了Simcard接口,所以必须将Simcard接口里的所有方法也实现
75     public void noticeSim()
76     {
77         System.out.println("SIM卡插入了!");
78     }
79 }

运行结果如下:

1 相机开始工作!
2 相机停止工作!
3 手机开始工作!
4 手机停止工作!
5 耳机插入了!
6 SIM卡插入了!
7 404 not found!

 

接口扩展灵活性演示代码如下:

 1 /**日期:2016-03-05
 2  * 功能:接口扩展灵活性的演示
 3  * 说明:增加一种销售车辆时,只需要增加下面演示的代码A和代码B就可以了,无需修改其它代码,很方便 
 4  */
 5 public class Practice
 6 {
 7     public static void main(String []args)
 8     {
 9         CarShop carshop1=new CarShop();
10         carshop1.sellCar(new BMW());
11         carshop1.sellCar(new CheryQQ());
12         //carshop1.sellCar(new Audy()); //代码A:增加销售车辆时,增加该行代码
13     }
14 }
15 class CarShop
16 {
17     private int income=0;
18     public void sellCar(Car car)
19     {
20         System.out.println("卖出了一辆"+car.getName());
21         income+=car.getPrice();
22         System.out.println("收入"+income);
23     }
24 }
25 
26 interface Car
27 {
28     public String getName();
29     public int getPrice();
30 }
31 
32 class BMW implements Car
33 {
34 
35     @Override
36     public String getName() {
37         // TODO Auto-generated method stub
38         return "BMW";
39     }
40 
41     @Override
42     public int getPrice() {
43         // TODO Auto-generated method stub
44         return 300000;
45     }
46     
47 }
48 
49 class CheryQQ implements Car
50 {
51 
52     @Override
53     public String getName() {
54         // TODO Auto-generated method stub
55         return "CheryQQ";
56     }
57 
58     @Override
59     public int getPrice() {
60         // TODO Auto-generated method stub
61         return 20000;
62     }
63     
64 }
65 
66 //代码B:增加销售车辆时,增加该段代码
67 /*class Audy implements Car 
68 {
69 
70     @Override
71     public String getName() {
72         // TODO Auto-generated method stub
73         return "Audy";
74     }
75 
76     @Override
77     public int getPrice() {
78         // TODO Auto-generated method stub
79         return 200000;
80     }
81     
82 }*/

运行结果如下:

1 卖出了一辆BMW
2 收入300000
3 卖出了一辆CheryQQ
4 收入320000

 

以上是关于韩顺平循序渐进学java 第13讲 抽象类.接口的主要内容,如果未能解决你的问题,请参考以下文章

韩顺平循序渐进学java 第08讲 this.类变量

韩顺平循序渐进学Java零基础 第13章 常用类

韩顺平循序渐进学java 第12讲 多态

韩顺平循序渐进学java 第04讲 流程控制

韩顺平循序渐进学java 第03讲 运算符

韩顺平循序渐进学java 第01讲 内容介绍.项目演示.原理剖析