1.观察者模式

package 观察者模式.实现1;import 观察者模式.实现2.ConcreteObserver;
import 观察者模式.实现2.Observer;public class ConcreteSubject extends Subject {private String state;public void change(String newState){state=newState;this.notifyObserver();}}
class test{private static ConcreteSubject subject;private static Observer observer;public static void main(String[] args) {//创建观察者对象subject=new ConcreteSubject();//创建主题对象observer=new ConcreteObserver();//观察者对象登记到主题对象上subject.attach(observer);//改变主题对象的状态subject.change("new State");}
}package 观察者模式.实现1;import java.util.Enumeration;
import java.util.Vector;import 观察者模式.实现2.Observer;public abstract class Subject {private Vector observersVector=new Vector(); public void attach(Observer o) {observersVector.addElement(o);}public void detach(Observer o) {observersVector.removeElement(o);}public void notifyObserver() {Enumeration enumeration=observers();while(enumeration.hasMoreElements()){((Observer)enumeration.nextElement()).update();}}public Enumeration observers(){return ((Vector)observersVector.clone()).elements();}/*方案2：主题对象的功能必须由一个java聚集来维护一个对所有的观察者对象的引用*     管理这个聚集的方法是由抽象主题角色来声明并具体主题角色来实现导致了具体主题角色*     到抽象观察者角色的连线* 问题：聚集的管理方法在每一个具体角色上都不同吗？* 聚集管理方法本身是所有具体主题角色所共有的，因而这些聚集管理方法本身就是所有具体主题角色所共有的，因而* 这些方法以及聚集本身都可以移到抽象主题角色上去，notifyObserver()依赖聚集对象也可以用的移到抽象* 主题角色上去--方案1* * 区别：代表存储观察者对象的聚集连线是从抽象主题到抽象观察者** */
}package 观察者模式.实现2;public class ConcreteObserver implements Observer{/*具体主题对象可以动态的维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的方法：* 从具体的主题角色指向观察者角色的合成关系，代表具体主题可以有任意多个对抽象观察者的引用。* */public void update() {System.out.println("我正在......");}}package 观察者模式.实现2;import java.util.Enumeration;
import java.util.Vector;public class ConcreteSubject implements Subject{private Vector observersVector=new Vector(); //聚集public void attach(Observer o) {observersVector.addElement(o);}public void detach(Observer o) {observersVector.removeElement(o);}public void notifyObserver() {Enumeration enumeration=observers();while(enumeration.hasMoreElements()){((Observer)enumeration.nextElement()).update();}}public Enumeration observers(){return ((Vector)observersVector.clone()).elements();}}package 观察者模式.实现2;
/*内涵：定义了一种一对多的依赖关系，让多个观察者同时监听某一主题对象，当这个主题对象发生变化时会通知*    所有的观察者对象，使他们能自动更新自己*    --某个对象发生改变时其他对象能做出相应的改变* */
public interface Observer {/*角色：* 抽象主题（subject）角色：将所有观察者对象的引用保存在一个聚集（如：vector），每个主题都可以有*    任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象（抽象被观察者角色）* 抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题更新时通知自己;这个接口叫更新接口，抽象*    观察者角色一般用一个抽象类或接口实现* 具体主题角色：将有关状态存入具体观察者对象；在具体主题内部改变时；给所有观察者发出通知；具体主题角色*    又叫具体被观察者角色。具体主题角色实现对观察者引用聚集的管理方法* 具体观察者角色：存储与主题状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使*    本身状态与主题的状态相协调。如果需要具体观察者可以保存一个指向具体主题对象的引用* */void update();}package 观察者模式.实现2;public interface Subject {//登记一个新的观察者对象public void attach(Observer o);//删除一个已经登记过的观察者对象public void detach(Observer o);//通知所有登记过的观察者对象void notifyObserver();}

2.门面模式

package 门面模式;public class Alarm {public void activate(){System.out.println("启动警报器");}public void deactivate(){System.out.println("关闭警报器");}public void runing(){System.out.println("拉响警报器");}public void stopRing(){System.out.println("停掉警报器");}}package 门面模式;public class Camera {public void turnOn(){System.out.println("打开录像机");}public void turnOff(){System.out.println("关闭录像机");}public void rotate(int degrees){System.out.println("转动录像机"+degrees+"");}}
package 门面模式;public class Light {public void turnOn(){System.out.println("开灯");}public void turnoff(){System.out.println("关灯");}public void changeBulb(){System.out.println("换灯泡啦......");}}package 门面模式;
/*门面角色：此角色知道相关（一个或多个）子系统的功能和责任，在正常的情况下，本角色会将所有的请求委派到相应的子系统* 子系统角色：可以同时拥有一个或多个子系统，每个子系统都是一个类的集合，都可以被客户端或门面调用，对子系统而言门面* 只是另一个客户端而已* */
public class SecurityFacade {//门面类/*内涵：* 为一个复杂的子系统提供一个简单的接口：可以提高代码的复用性* 子系统的独立性* 层次化结构：简化了层与层之间的依赖关系* */private Camera camera1,camera2;private Light light1,light2,light3;private Sensor sensor;private Alarm alarm;public void trunOn(){camera1.turnOn();camera2.turnOn();light1.turnOn();light2.turnOn();light3.turnOn();sensor.activate();alarm.activate();}public void deavtivate(){camera1.turnOff();camera2.turnOff();light1.turnoff();light2.turnoff();light3.turnoff();sensor.deactivate();alarm.deactivate();}}
package 门面模式;public class Sensor {public void activate(){System.out.println("启动感应器");}public void deactivate(){System.out.println("关闭感应器");}public void trigger(){System.out.println("触发感应器");}}

3.桥梁模式

package 桥梁模式;
/*桥梁模式有助于理解"开闭原则"，"合成/聚合原则"*桥梁模式的用意是将抽象化与实现化脱耦，使他们可以独立的变化*1.抽象化：存在于多个实体之间的共同的概念性联系*  在过程上，抽象化就是忽略一些信息，把不同实体当做相同实体看待 例：共同类、抽象类、继承关系*2.实现化：抽象化给出的具体实现*3.脱耦：将两个实体行为的某种关联，而将他们的强关联去掉。*  强关联：编译期已经确定，无法再运行时动态改变的关联*  弱关系：可以在运行期动态确定并且动态改变的关联*  例：继承关系是强关联，聚合关系是弱关联* */
public abstract class Abstraction {//抽象化角色/*角色：* 抽象化角色：抽象化给出定义，并保存一个对实现化对象的引用* 修正抽象化角色：扩展抽象化角色，改变和修正父类对抽象化的定义* 实现化角色：给出实现化的接口，但不给出具体的实现；这个接口不一定与抽象化接口相同。实现化角色应该给出*          底层操作，而抽象化角色应该给出更高一层的操作* 具体实现化角色：给出实现化接口的具体实现* */protected Implementor imp;public void operation(){imp.operationImp();//抽象化角色可以向不同实现化对象委派，来达到动态转换自己功能的目的//抽象化角色的接口比实现化角色的接口更宽，抽象化角色除了提供与实现化角色相关的方法之外//还有可能提供其他商业方法，而实现化角色则往往为实现抽象化角色的相关行为而存在}}package 桥梁模式;
//具体实现化角色
public class ConcreteImplementor extends Implementor{@Overridepublic void operationImp() {System.out.println("Do something......");}}package 桥梁模式;
//实现化角色
public abstract class Implementor {public abstract void operationImp();}package 桥梁模式;
//修正抽象化角色
public class RefindAbstraction extends Abstraction{@Overridepublic void operation() {// TODO Auto-generated method stubsuper.operation();}}

4.装饰模式

package 装饰模式;
/*抽象构件角色* */
public interface Compent {/*抽象构件：给出一个抽象接口，以规范准备接收附加责任的对象* 具体构件：定义一个将要接收附加责任附件的类* 装饰角色：持有一个构件对象的实例，并定义一个与抽象构件接口一致的接口* 具体装饰角色：负责给构件对象贴上附加责任* */void sampleOperation();/*装饰模式的使用：* 需要扩展一个类的功能，或者给一个类增加附加功能* 需要动态的给一个对象增加功能，这些功能可以动态的撤销* 需要增加一些基本功能的排列组合而产生非常大的功能，从而使继承关系变得不现实* */}package 装饰模式;
//具体构件类
public class ConcreteCompent implements Compent {public void sampleOperation() {// TODO Auto-generated method stub}}package 装饰模式;
//具体装饰类
public class ConcreteDecroator extends Decrorator{public ConcreteDecroator() {super();// TODO Auto-generated constructor stub}public ConcreteDecroator(Compent com) {super(com);// TODO Auto-generated constructor stub}@Overridepublic void sampleOperation() {// TODO Auto-generated method stubsuper.sampleOperation();}}class test{public static void main(String[] args) {Compent com=new ConcreteCompent();//创建一个真实的对象Compent dec=new ConcreteDecroator(com);//装饰的变化--所有的变化都是由真实对象操作}
}package 装饰模式;
//装饰角色
public class Decrorator implements Compent {/*内涵：Decrorator本身不是一个抽象类，在实际应用中也不一定是抽象类，但是他的功能是一个抽象的角色，因而* 称为抽象装饰 例 大圣的72般变化* */private Compent compent;public Decrorator(Compent com){this.compent=com;}public Decrorator(){}public void sampleOperation() {compent.sampleOperation();}}