Java的设计模式

Posted 2022-07-21 noperx

一，适配器设计模式

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。

主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

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();