标签：功能 策略 理解 color return 运行 bsp 装饰模式 The
一，适配器设计模式
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。
主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
1，类的适配器模式
public class Source { public void method1(){ System.out.println("this id original method"); } }
public interface Targetable { // 与原类中的方法相同 public void method1(); //新的方法 public void method2(); }
public class Adapter extends Source implements Targetable { @Override public void method2() { System.out.println("this is the targetable method"); } }
public class AdapterTest { public static void main(String[] args) { Targetable target = new Adapter(); target.method1();// this id original method target.method2();// this is the targetable method } }
2，对象的适配器模式
基本思路和类的适配器模式相同，只是将 Adapter 类作修改，这次不继承 Source 类，而是持有 Source 类的实例，以达到解决兼容性的问题
public class Wrapper implements Targetable { private Source source; public Wrapper(Source source){ this.source = source; } @Override public void method1() { source.method1(); } @Override public void method2() { System.out.println("this is this targetable method"); } }
public class AdapterTest2 { public static void main(String[] args) { Targetable target = new Wrapper(new Source()); target.method1();// this id original method target.method2();// this is the targetable method } }
3，接口的适配器模式
有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
public interface OriginalInterface { public void method1(); public void method2(); }
public abstract class OriginalInterfaceImpl implements OriginalInterface{ @Override public void method1() { System.out.println("this method one"); } @Override public void method2() { System.out.println("this is method two"); } }
public class MyClass extends OriginalInterfaceImpl { @Override public void method1() { System.out.println("this is override method one"); } }
二，装饰模式
装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
public interface Sourceable { public void method(); }
public class Source implements Sourceable { @Override public void method() { System.out.println("the original method!"); } }
public class Decorator implements Sourceable { private Sourceable source; public Decorator(Sourceable source){ this.source = source; } @Override public void method() { System.out.println("do something before this method"); source.method(); System.out.println("do something after this method"); } }
public class TestDecorator { public static void main(String[] args) { Sourceable source = new Source(); Sourceable decorator = new Decorator(source); /** * 运行结果 * do something before this method * the original method! * do something after this method */ decorator.method(); } }
三，策略模式
策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。
public interface MyCalculator { public int calculate(String exp); }
public class AbstractCalculator { public int[] split(String exp, String opt){ String[] array = exp.split(opt); int[] arrayInt = new int[2]; arrayInt[0] = Integer.parseInt(array[0]); arrayInt[1] = Integer.parseInt(array[1]); return arrayInt; } }
public class Minus extends AbstractCalculator implements MyCalculator { @Override public int calculate(String exp) { int[] ints = split(exp, "-"); return ints[0]-ints[1]; } }
public class Plus extends AbstractCalculator implements MyCalculator { @Override public int calculate(String exp) { int[] ints = split(exp, "\\+"); return ints[0]+ints[1]; } }
public class TestStrategy { public static void main(String[] args) { String exp = "2+9"; MyCalculator plus = new Plus(); int i = plus.calculate(exp); System.out.println(i); } }
四，观察者模式
观察者模式很好理解，类似于邮件订阅和 RSS 订阅，当我们浏览一些博客或 wiki 时，经常会看到 RSS 图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
public interface Observer { public void update(); }
public class Observer1 implements Observer { @Override public void update() { System.out.println("observer1 has received"); } }
public class Observer2 implements Observer { @Override public void update() { System.out.println("observer2 has received"); } }
public interface Subject { // 添加观察者 public void add (Observer observer); //删除观察者 public void del (Observer observer); //通知所有的观察者 public void notifyObservers(); //自身操作 public void operation(); }
public class AbstractSubject implements Subject { private Vector<Observer> vector = new Vector<>(); @Override public void add(Observer observer) { vector.add(observer); } @Override public void del(Observer observer) { vector.remove(observer); } @Override public void notifyObservers() { Enumeration<Observer> enumeration = vector.elements(); while (enumeration.hasMoreElements()){ enumeration.nextElement().update(); } } @Override public void operation() { } }
public class MySubject extends AbstractSubject { @Override public void operation() { System.out.println("update self"); notifyObservers(); } }
public class TestObserver { public static void main(String[] args) { MySubject mySubject = new MySubject(); mySubject.add(new Observer1()); mySubject.add(new Observer2()); /** * 运行结果 * update self * observer1 has received * observer2 has received */ mySubject.operation(); } }
标签：功能 策略 理解 color return 运行 bsp 装饰模式 The
原文地址：https://www.cnblogs.com/noperx/p/11368435.html
