面向接口编程的优点
1 首先什么是面向接口编程?
1、 面向接口编程就是先把客户的业务逻辑线提取出来，作为接口，业务具体实现通过该接口的实现类来完成。
2、 当客户需求变化时，只需编写该业务逻辑的新的实现类，通过更改配置文件(例如Spring框架)中该接口
3、 的实现类就可以完成需求，不需要改写现有代码，减少对系统的影响。2 面向接口编程的优点？
1 降低程序的耦合性。其能够最大限度的解耦，所谓解耦既是解耦合的意思，它和耦合相对。耦合就是联系
，耦合越强，联系越紧密。在程序中紧密的联系并不是一件好的事情，因为两种事物之间联系越紧密，你更换
其中之一的难度就越大，扩展功能和debug的难度也就越大。
2 易于程序的扩展；
3 有利于程序的维护；3 接口编程在设计模式中的体现：开闭原则
其遵循的思想是：对扩展开放，对修改关闭。其恰恰就是遵循的是使用接口来实现。在使用面向接口的编程过程
中，将具体逻辑与实现分开，减少了各个类之间的相互依赖，当各个类变化时，不需要对已经编写的系统进行
改动，添加新的实现类就可以了，不在担心新改动的类对系统的其他模块造成影响。4 一个老生常谈的例子：JDBC
SUN公司提供了一套JDBC接口规范，MySql公司开发了自己对JDBC规范的驱动，Oracle公司开发了一套自己
的JDBC规范的驱动。当用户安装的是MySQL数据库的时候，在spring容器中配置mySQl的IOC，然后在java
代码中调用MySQL驱动实现类，同理，当用户安装的是Oracle数据库的时候，在spring容器中配置Oracle
的IOC，然后在java代码中调用Oracle驱动实现类。5 一个简单的spring接口编程的例子：（假如给学校做一个网页：下面的模块是一个子模块）
客户需求：显示”西安电子科技大学”的”地理位置”和“经纬度”第一步：先建立一个school接口类： School.java
package com.wu.xidian;
/**
* @author wunan E-mail: 2215225782@qq.com
* @version 创建时间：2017年4月13日 下午4:20:28
* School接口类
*/
public interface School {
//显示地理位置
void showGeography();
//显示经纬度
void showLangtutide();}
第二步：实现接口类：
package com.wu.xidian;
/**
* @author wunan E-mail: 2215225782@qq.com
* @version 创建时间：2017年4月13日 下午4:23:53
* 接口类的实现
*/
public class Xidian_SchoolImpl_N implements School {
@Override
public void showGeography() {
System.out.println("西安电子科技大学地址 ：西安市-雁塔区-太白南路-西安电子科技大学(北校区)");
}
@Override
public void showLangtutide() {
System.out.println("西安电子科技大学地理位置：34.2369070000,108.9232450000");
}}
第三步：创建一个实例：来显示学校
package com.wu.xidian.test; import com.wu.xidian.School; /** * @author wunan E-mail: 2215225782@qq.com * @version 创建时间：2017年4月13日 下午4:44:19 * 创建一个实例：来显示学校 */ public class XidianSchool {
private School school = null;
//注意:此处是对接口的set
public void setSchool(School school) {
this.school = school;
}
public XidianSchool(){};
public XidianSchool(School s)
{
this.school= s;
}
//显示
public void getSchoolInfo()
{
school.showGeography();
school.showLangtutide();
}
}
第四步编写测试类：
package com.wu.xidian.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wu.xidian.School;
/**
* @author wunan E-mail: 2215225782@qq.com
* @version 创建时间：2017年4月13日 下午5:01:24
* 测试：
*/
public class Test1 {
@Test
public void demo01(){
//从spring容器获得
//1 获得容器
String xmlPath = "com/wu/xidian/applicationContext.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
//2获得内容 --不需要自己new，都是从spring容器获得
XidianSchool bean = (XidianSchool)applicationContext.getBean("XidianSchool");
bean.getSchoolInfo();
}
}
第五步：编写applicationContext.xml文件：
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="XidianSchool" class="com.wu.xidian.test.XidianSchool">
<property name="school" ref="N"/>
</bean>
<bean id="N" class="com.wu.xidian.Xidian_SchoolImpl_N"></bean>
好了，这下问题解决了！
张校长：西电有两个校区，我需要你们把两个校区的地址和经纬度都显示出来！
项目主管：可是，业务要求项目书上要求中只要求显示一个校区的地址和经纬度啊，这。。。。
小吴程序员：很淡定的说，没问题，可以解决！
为何他会如此的理直气壮，因为他采用了面向接口的编程：
添加业务：（不需要修改原来的代码，只需要新建一个类继承原来的接口）
第六步：添加Xidian_SchoolImpl_S.java
package com.wu.xidian;
/**
* @author wunan E-mail: 2215225782@qq.com
* @version 创建时间：2017年4月13日 下午4:23:53
* 显示南校区的信息：
*/
public class Xidian_SchoolImpl_S implements School {
@Override
public void showGeography() {
System.out.println("西安电子科技大学地址 ：西安市-长安区-西隆段-西安电子科技大学(南校区)");
}
@Override
public void showLangtutide() {
System.out.println("西安电子科技大学地理位置：34.1295220000,108.8400530000");
}}
第七步：修改applicationContext.xml文件即可！（添加Xidian_SchoolImpl_S的IOC）
来源于：https://blog.csdn.net/jj_nan/article/details/70161086
自我总结：
面向接口编程是一种重要的编程思想，它将实现与接口分离，以提高代码的可维护性、可扩展性和可测试性。以下从多个方面详细阐述其优点，并举例说明。
1. 提高代码的可扩展性
- 原理：接口定义了一组方法的规范，而具体的实现可以根据需求进行扩展。当需要添加新的功能或修改现有功能时，只需实现新的接口实现类，而不需要修改现有的代码。
- 举例：假设我们正在开发一个游戏，游戏中有不同类型的角色，每个角色都有攻击的能力。我们可以定义一个
Attackable接口：
// 定义攻击接口
interface Attackable {
void attack();
}
// 战士类实现攻击接口
class Warrior implements Attackable {
@Override
public void attack() {
System.out.println("战士使用剑进行攻击");
}
}
// 法师类实现攻击接口
class Mage implements Attackable {
@Override
public void attack() {
System.out.println("法师使用魔法进行攻击");
}
}
// 游戏角色管理类
class GameCharacterManager {
public void performAttack(Attackable character) {
character.attack();
}
}
// 测试代码
public class Main {
public static void main(String[] args) {
GameCharacterManager manager = new GameCharacterManager();
Attackable warrior = new Warrior();
Attackable mage = new Mage();
manager.performAttack(warrior);
manager.performAttack(mage);
// 现在要添加一个新的角色类型：刺客
class Assassin implements Attackable {
@Override
public void attack() {
System.out.println("刺客使用匕首进行攻击");
}
}
Attackable assassin = new Assassin();
manager.performAttack(assassin);
}
}
在这个例子中，当需要添加新的角色类型（如刺客）时，只需要实现 Attackable 接口，而不需要修改 GameCharacterManager 类的代码，体现了良好的可扩展性。
2. 增强代码的可维护性
- 原理：接口将抽象和实现分离，使得代码结构更加清晰。当接口的实现发生变化时，只要接口本身不变，不会影响到使用该接口的其他代码。
- 举例：假设我们有一个数据存储系统，需要将数据存储到不同的介质中，如文件系统和数据库。我们可以定义一个
DataStorage接口：
// 数据存储接口
interface DataStorage {
void saveData(String data);
}
// 文件存储实现类
class FileDataStorage implements DataStorage {
@Override
public void saveData(String data) {
System.out.println("将数据保存到文件系统: " + data);
}
}
// 数据库存储实现类
class DatabaseDataStorage implements DataStorage {
@Override
public void saveData(String data) {
System.out.println("将数据保存到数据库: " + data);
}
}
// 数据处理类
class DataProcessor {
private DataStorage storage;
public DataProcessor(DataStorage storage) {
this.storage = storage;
}
public void processAndSave(String data) {
// 数据处理逻辑
String processedData = data.toUpperCase();
storage.saveData(processedData);
}
}
// 测试代码
public class Main {
public static void main(String[] args) {
DataStorage fileStorage = new FileDataStorage();
DataProcessor processor = new DataProcessor(fileStorage);
processor.processAndSave("hello world");
// 现在要将存储方式从文件系统切换到数据库
DataStorage databaseStorage = new DatabaseDataStorage();
processor = new DataProcessor(databaseStorage);
processor.processAndSave("hello world");
}
}
在这个例子中，DataProcessor 类依赖于 DataStorage 接口，而不是具体的实现类。当需要将存储方式从文件系统切换到数据库时，只需要更换 DataStorage 接口的实现类，而不需要修改 DataProcessor 类的代码，提高了代码的可维护性。
3. 实现多态性
- 原理：多态是面向对象编程的重要特性之一，通过接口可以实现不同对象对同一方法的不同实现。在运行时，可以根据实际对象的类型调用相应的方法。
- 举例：继续以上面的游戏角色为例，
GameCharacterManager类的performAttack方法接受一个Attackable类型的参数。在调用该方法时，可以传入不同的实现类对象（如Warrior、Mage、Assassin），根据传入对象的实际类型调用相应的attack方法，实现了多态性。
GameCharacterManager manager = new GameCharacterManager();
Attackable warrior = new Warrior();
Attackable mage = new Mage();
Attackable assassin = new Assassin();
manager.performAttack(warrior); // 调用 Warrior 的 attack 方法
manager.performAttack(mage); // 调用 Mage 的 attack 方法
manager.performAttack(assassin); // 调用 Assassin 的 attack 方法
4. 便于团队协作开发
- 原理：接口可以作为团队成员之间的契约，定义了模块之间的交互方式。不同的团队成员可以分别负责接口的实现和使用，提高开发效率。
- 举例：在一个大型的电商系统中，有一个订单处理模块和一个支付模块。订单处理模块需要调用支付模块的接口来完成支付操作。开发人员可以先定义一个
PaymentService接口：
// 支付服务接口
interface PaymentService {
boolean pay(double amount);
}
订单处理模块的开发人员可以根据这个接口进行开发，而支付模块的开发人员则负责实现这个接口。双方可以并行开发，提高开发效率。
总结
面向接口编程通过将抽象和实现分离，提高了代码的可扩展性、可维护性，实现了多态性，同时便于团队协作开发。在实际编程中，合理使用接口可以使代码更加灵活、健壮，易于维护和扩展。
浙公网安备 33010602011771号