面向接口编程的小例子

以前学习Java的时候，就听过面向接口编程，可惜当时水平太低不理解（当然，现在水平还是很低），现在学习了一点。接下来，我们通过一个小例子学习面向接口编程。

 

背景：假设每个单身狗都喜欢和蚊子玩，蚊子有一个唱歌的方法。代码如下：

1. //Mosquito.java
2. //蚊子类，拥有一个唱歌的方法
3. package project.app.service;
5. publicclassMosquito{
6. publicString sing(){
7. return"You have to admit that I sing songs very well.";
8. }
9. }
10.  

1.  
2. //Single.java
3. //单身狗类，playWithMosquito依赖于蚊子类
4. package project.app.service;
5. import project.app.service.Mosquito;
7. publicclassSingle{
8. privateMosquito mosquito;
9. publicvoid setMosquito(Mosquito mosquito){
10. this.mosquito = mosquito;
11. }
12. publicvoid playWithMosquito(){
13. System.out.println(mosquito.sing());
14. }
15. }

接下来，可以测试一下

1. //Test.java
2. package chris;
3. import project.app.service.*;
5. publicclassTest{
6. publicstaticvoid main(String[] args)throwsException{
7. Single single =newSingle();
8. Mosquito mosquito =newMosquito();
9. //设置single实例和mosquito实例的关系
10. single.setMosquito(mosquito);
11. single.playWithMosquito();
12. }
13. }

结果：

You have to admit that I sing songs very well.

 

如果之后单身狗和蚊子友谊的小船翻了，改成和蟑螂玩了，应该怎么改代码呢？一般的做法大概是这样。

增加蟑螂类。

1. //Cockroach.java
2. //蟑螂类，有不同于蚊子的唱歌的方法
3. package project.app.service;
5. publicclassCockroach{
6. publicString sing(){
7. return"I sing when everybody is in sleep.";
8. }
9. }

在单身狗类中，将有关蚊子的改成有关蟑螂的。

1. //Single.java
2. //单身狗类，playWithMosquito依赖于蟑螂类
3. package project.app.service;
4. import project.app.service.Cockroach;
6. publicclassSingle{
7. privateCockroach cockroach;
8. publicvoid setCockroach(Cockroach cockroach){
9. this.cockroach = cockroach;
10. }
11. publicvoid playWithCockroach(){
12. System.out.println(cockroach.sing());
13. }
14. }

可以测试一下。

1. //Test.java
2. package chris;
3. import project.app.service.*;
5. publicclassTest{
6. publicstaticvoid main(String[] args)throwsException{
7. Single single =newSingle();
8. Cockroach cockroach =newCockroach();
9. single.setCockroach(cockroach);
10. single.playWithCockroach();
11. }
12. }

运行结果： I sing when everybody is in sleep.

 

经过上面的实践，我们发现，单身狗类依赖于蚊子类，导致蚊子类变化成蟑螂类时，单身狗类的代码必须跟着改变，这样类之间的耦合性太强了。我们想想，蚊子和蟑螂虽然唱着不同的歌，但是唱歌的方法却是相同的。为了代码能够降低耦合，我们可以使用接口，利用面向对象的多态性。可以将蚊子和蟑螂抽象一下，在概念上，往上升一级，比如宠物，动物，生物，物质。动物、生物和物质这几个接口就太宽了，也把单身狗包括进去了，那么，我们选择到宠物这一层。我们通过例子看一下。

1. //Pet.java
2. //宠物接口，有一个唱歌的方法
3. package project.app.service;
5. publicinterfacePet{
6. publicString sing();
7. }

蚊子类实现宠物接口

1. //Mosquito.java
2. //
3. package project.app.service.impl;
4. import project.app.service.Pet;
6. publicclassMosquitoimplementsPet{
7. publicString sing(){
8. return"You have to admit that I sing songs very well.";
9. }
10. }

1. //Single.java
2. //单身狗类，playWithMosquito依赖于Pet接口，注意，这个时候单身狗类只依赖于宠物接口，不依赖于具体的蚊子类了。
3. package project.app.service;
4. import project.app.service.Pet;
6. publicclassSingle{
7. privatePet pet;
8. publicvoid setPet(Pet pet){
9. this.pet = pet;
10. }
11. publicvoid playWithPet(){
12. System.out.println(pet.sing());
13. }
14. }

1. //Test.java
2. package chris;
3. import project.app.service.Single;
4. import project.app.service.Pet;
5. import project.app.service.impl.Mosquito;
7. publicclassTest{
8. publicstaticvoid main(String[] args)throwsException{
9. Single single =newSingle();
10. Mosquito mosquito =newMosquito();
11. single.setPet(mosquito);
12. single.playWithPet();
13. }
14. }

如果我们改成和蟑螂玩，则修改代码时，增加蟑螂类的代码（也要实现宠物接口），单身狗类不用变（耦合性大大降低啊，节省了好多重复劳动）。

1. //Cockroach.java
2. //蟑螂类，有唱歌的方法
3. package project.app.service.impl;
4. import project.app.service.Pet;
6. publicclassCockroachimplementsPet{
7. publicString sing(){
8. return"I sing when everybody is in sleep.";
9. }
10. }

 

测试代码经过轻微的修改：

1.  
2. //Test.java
3. package chris;
4. import project.app.service.Single;
5. import project.app.service.Pet;
6. import project.app.service.impl.Cockroach;
8. publicclassTest{
9. publicstaticvoid main(String[] args)throwsException{
10. Single single =newSingle();
11. Cockroach cockroach =newCockroach();
12. single.setPet(cockroach);
13. single.playWithPet();
14. }
15. }

 

上面的例子可以算是面向接口编程的一个例子。通过使用接口，利用面向对象的多态性，将蚊子类抽象成宠物接口，使单身狗类只依赖于抽象的宠物接口，大大降低了单身狗类对具体的蚊子类的依赖。这样，大大地方便了后期的扩展和维护，比如增加会唱歌的蟋蟀类等。

 

 

 

From WizNote