- 未使用简单工厂模式
public class l6 {
public static void main(String[] args) {
// 使用者和被使用者耦合,产生了依赖,当被使用着改变时会影响使用者
// 使用工厂模式降低两者之间依赖
Product phone = new Phone();
phone.work();
}
}
interface Product {
public void work();
}
class Phone implements Product {
public void work() {
System.out.println("手机开始工作");
}
}
class Computer implements Product {
public void work() {
System.out.println("电脑开始工作");
}
}
- 使用简单工厂模式
public class l6 {
public static void main(String[] args) {
// 使用者和被使用者耦合,产生了依赖,当被使用着改变时会影响使用者
// 使用工厂模式降低两者之间依赖
Product phone = ProductFactory.getProduct("phone");
if (null != phone) {
phone.work();
}
}
}
// 工厂类
class ProductFactory {
public static Product getProduct(String name) {
if ("phone".equals(name)) {
return new Phone();
} else if ("computer".equals(name)) {
return new Computer();
} else {
return null;
}
}
}
interface Product {
public void work();
}
class Phone implements Product {
public void work() {
System.out.println("手机开始工作");
}
}
class Computer implements Product {
public void work() {
System.out.println("电脑开始工作");
}
}
- 未使用静态代理
public class l6 {
public static void main(String[] args) {
}
}
interface Action {
public void doAction();
}
class UserAction implements Action {
public void doAction() {
System.out.println("用户开始做工作啦");
}
}
但是在用户开始工作前后的准备啥事情一定得需要做,但是又不是老板要的结果,又为必需品,此时就要用到静态代理模式,请往下看
- 使用静态代理模式
public class l6 {
public static void main(String[] args) {
Action useAction = new UserAction();
ActionProxy proxy = new ActionProxy(useAction);
proxy.doAction();
}
}
class ActionProxy implements Action {
private Action target;// 被代理的对象
public ActionProxy(Action target) {
this.target = target;
}
// 执行操作
public void doAction() {
long startTimne = System.currentTimeMillis();
target.doAction();// 执行真正的业务
long endTime = System.currentTimeMillis();
System.out.println("共耗时:" + (endTime - startTimne));
}
}
interface Action {
public void doAction();
}
class UserAction implements Action {
public void doAction() {
System.out.println("用户开始做工作啦");
}
}
为啥耗时0呢太短了就一个输出,让我们给它加点复杂点
class UserAction implements Action {
public void doAction() {
for (int i = 1; i <= 200; i++) {
System.out.println("用户开始做工作啦");
}
}
}
- 使用适配器前
public class l6 {
public static void main(String[] args) {
PowerA powerA = new PowerAImpl();
work(powerA);
}
public static void work(PowerA a) {
System.out.println("正在连接");
a.insert();
;
System.out.println("工作结束");
}
}
interface PowerA {
public void insert();
}
class PowerAImpl implements PowerA {
public void insert() {
System.out.println("电源A开始工作");
}
}
注意对修改关闭,对扩展开放
怎么补救到达上面想让也输出PowerB,但是不再重新定义方法来输出调用…适配器(解决A和B不兼容,B不能转到work()方法里面调用)
public class l6 {
public static void main(String[] args) {
PowerA powerA = new PowerAImpl();
work(powerA);
PowerB powerB = new PowerBImpl();
Adapter adapter = new Adapter(powerB);
work(adapter);
}
public static void work(PowerA a) {
System.out.println("正在连接");
a.insert();
System.out.println("工作结束");
}
}
// 适配器
class Adapter implements PowerA {
private PowerB powerB;
public Adapter(PowerB powerB) {
this.powerB = powerB;
}
public void insert() {
powerB.connect();
}
}
interface PowerB {
public void connect();
}
class PowerBImpl implements PowerB {
public void connect() {
System.out.println("电源B开始工作");
}
}
interface PowerA {
public void insert();
}
class PowerAImpl implements PowerA {
public void insert() {
System.out.println("电源A开始工作");
}
}
- 适配器的另一种用法
interface Animal {
public void sing();
public void cry();
public void run();
public void swim();
}
class Dog implements Animal {
public void sing() {
}
public void cry() {
}
public void run() {
System.out.println("我是一只修勾,最喜欢奔跑的感觉");
}
public void swim() {
}
}
每回实现类都要四个方法都写一遍很麻烦,如下
// 中间类:(适配器类)
abstract class AnimalFunction {
public void sing() {
}
public void cry() {
}
public void run() {
}
public void swim() {
}
}
interface Animal {
public void sing();
public void cry();
public void run();
public void swim();
}
class Dog extends AnimalFunction {
public void run() {
System.out.println("我是一只修勾,最喜欢奔跑的感觉");
}
}