参照例Ch1_1,思考如下代码使用接口实现依赖反转。 A a=new C(); a.fun();
时间: 2024-09-15 14:14:03 浏览: 18
在软件设计原则中,依赖反转(Dependency Inversion Principle,DIP)提倡高内聚、低耦合的原则,避免直接依赖,而是通过接口和抽象来控制组件之间的交互。假设我们有 Ch1_1 中类似的一个例子:
```java
// 原来的代码 - 高耦合
interface IFun {
void fun();
}
class A {
private IFun funImpl; // 对IFun的具体实现有硬编码依赖
public A(IFun impl) {
this.funImpl = impl;
}
public void useFun() {
funImpl.fun();
}
}
class B implements IFun { // 具体实现
@Override
public void fun() {
System.out.println("B's implementation");
}
}
class C implements IFun { // 另一具体实现
@Override
public void fun() {
System.out.println("C's implementation");
}
}
public class Main {
public static void main(String[] args) {
A a = new A(new C()); // 高耦合,因为创建了A时就确定了使用的fun实现是C
a.useFun();
}
}
```
为了应用依赖反转,我们可以修改代码如下:
```java
// 使用接口和构造函数传递实现 - 依赖倒置
interface IFun {
void fun();
}
class Client { // 客户端不再持有具体的实现
private A a;
public Client(A a) {
this.a = a;
}
public void callFun(IFun fun) {
a.useFun(fun); // 由外部传入的fun决定使用哪个实现
}
}
class A {
private IFun funImpl;
public A(IFun impl) {
this.funImpl = impl;
}
public void useFun(IFun fun) {
fun.fun();
}
}
// 创建时不再指定具体实现
public class Main {
public static void main(String[] args) {
IFun c = new C();
Client client = new Client(new A(c)); // 现在在创建A时不确定使用哪个实现
client.callFun(c);
}
}
```