JAVA 中涉及到的设计模式

骑猪看日落 2022-08-20 02:30 298阅读 0赞

1  
**代理模式**  
**当我们开发中如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：**  
1修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

下面用代码表示代理的用法：  
首先来一个接口：Sourceable

public interface Sourceable {  
       public void action();  
    }

原有类继承该接口 Source:  
package cn.itd.yw.model;

public class Source implements Sourceable\{  
@Override  
public void action() \{  
System.out.println(“source method—-“);  
\}  
\}

你要实现你想要的效果的类继承之前的接口，Proxy(代理类）

package cn.itd.yw.model;

public class Proxy implements Sourceable \{  
private Source source;

public Proxy(){
        super();
        this.source = new Source();
    }
    @Override
    public void action() {
        before();
        source.action();
        after();
    }
    
    private void after() {
        System.out.println("proxy before----");
    }
    
    private void before() {
        System.out.println("proxy after----");
    }

测试结构如下：
    proxy after----
    source method---- proxy before---- **策略模式** 决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。 首先写个计算的接口：

package cn.itd.yw.strategy;

public interface ICalculate \{  
public int calculate(String exp);  
\}

算法类继承该接口：

package cn.itd.yw.strategy;

public class Plus extends AbstractCalculator implements ICalculate\{  
public int calculate(String exp) \{  
int\[\] arr = split(exp, “\\+”);  
return arr\[0\] + arr\[1\];  
\}  
\}

最后是AbstractCalculator 辅助类

package cn.itd.yw.strategy;

public abstract class AbstractCalculator \{  
public int\[\] split(String exp, String opt)\{  
String\[\] array = exp.split(opt);  
int\[\] intArray = new int\[2\];  
intArray\[0\] = Integer.parseInt(array\[0\]);  
intArray\[1\] = Integer.parseInt(array\[1\]);  
return intArray;  
\}  
\}

**观察者模式**
    
    首先搞一个观察者接口:

package cn.itd.yw.Observer;

public interface Observer \{  
public void update();

下面依次搞几个实现了该接口的观察者

package cn.itd.yw.Observer;

public class Observer1 implements Observer \{

@Override
    public void update() {
        System.out.println("observer1 has received");
    }

package cn.itd.yw.Observer;

public class Observer2 implements Observer\{  
@Override  
public void update() \{  
System.out.println(“observer2 has received”);  
\}  
\}

然后在创建一个操作观察者的接口:

package cn.itd.yw.Observer;

public interface Subject \{  
//增加观察者  
public void add(Observer observer);  
//删除观察者  
public void remove(Observer bObserver);  
//通知所有观察者  
public void notifyAllObservers();  
//自身的操作  
public void operation();  
\}

实现上面的接口具体来操作observers:

package cn.itd.yw.Observer;

import java.util.Enumeration;  
import java.util.Vector;

public abstract class AbstractSubject implements Subject \{  
private Vector vector = new Vector();

@Override
    public void add(Observer observer) {
        vector.add(observer);
    }
    
    @Override
    public void notifyAllObservers() {
        Enumeration<Observer> enumo = vector.elements();
        while (enumo.hasMoreElements()) {
            enumo.nextElement().update();
        }
    }
    
    @Override
    public void remove(Observer observer) {
        vector.remove(observer);
    }

再创建一个实现自己的方法的类：

package cn.itd.yw.Observer;

public class MySubject extends AbstractSubject \{  
@Override  
public void operation() \{  
System.out.println(“update self!”);  
notifyAllObservers();  
\}  
\}

最后测试代码：

package cn.itd.yw.Observer;

public class ObserverDemo \{  
public static void main(String\[\] args) \{  
MySubject subject = new MySubject();  
subject.add(new Observer1());  
subject.add(new Observer2());  
subject.notifyAllObservers();  
\}  
\}

打印结果： observer1 has received observer2 has received **状态模式** 当对象的状态改变时，同时改变其行为。 首先创建一个核心state类：

package cn.itd.yw.state;

public class State \{  
private String state;

public String getState() {
        return state;
    }
    
    public void setState(String state) {
        this.state = state;
    }
    
    public void method1(){
        System.out.println("my name method1");
    }
    
    public void method2(){
        System.out.println("my name method2");
    }

然后在创建一个判断state的类：

package cn.itd.yw.state;

public class Context \{  
private State state;  
public Context(State state)\{  
this.state = state;  
\}  
public State getState() \{  
return state;  
\}  
public void setState(State state) \{  
this.state = state;  
\}

public void method(){
        if (state.getState() == "state1") {
            state.method1();
        }else if (state.getState() == "state2") {
            state.method2();
        }
    }

最后测试代码：
    package cn.itd.yw.state;
    
    public class StateDemo {
        public static void main(String[] args) {
            State state1 = new State();
            state1.setState("state1");
            Context context = new Context(state1);
            context.method();
        }
    }
    
    
    结果打印：my name method1
    
    **桥接模式**
        使抽象和实现解耦，使二者可以独立变化：
    
    先定义一个接口：

package cn.itd.yw.bridge;

public interface Sourceable \{  
void method();  
\}

实现该接口的2个子类：

package cn.itd.yw.bridge;

public class SourceSub1 implements Sourceable\{

@Override
    public void method() {
        System.out.println("this is sub1");
    }

package cn.itd.yw.bridge;

public class SourceSub2 implements Sourceable \{

@Override
    public void method() {
        System.out.println("this is sub2");
    }

然后再定义一个桥，持有该Sourceable的一个实例：

package cn.itd.yw.bridge;

public abstract class Bridge \{  
private Sourceable sourceable;

public Sourceable getSourceable() {
        return sourceable;
    }
    
    public void setSourceable(Sourceable sourceable) {
        this.sourceable = sourceable;
    }
    
    public void method(){
        sourceable.method();
    }

最后是继承上面的类的MyBridge:

package cn.itd.yw.bridge;

public class MyBridge extends Bridge \{  
@Override  
public void method() \{  
super.method();  
\}  
\}

测试代码：

package cn.itd.yw.bridge;

public class BridgeDemo \{

/**
     * @param args
     */
    public static void main(String[] args) {
        Bridge bridge = new MyBridge();
        bridge.setSourceable(new SourceSub1());
        bridge.method();
    
        bridge = new MyBridge();
        bridge.setSourceable(new SourceSub2());
        bridge.method();
    }

“\`

打印结果：  
this is sub1  
this is sub2