观察者模式 Observer
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己。
观察者模式的组成
抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。
程序实例
通过程序实例来说明观察者模式：
首先定义抽象的观察者：
//抽象观察者角色 public interface Watcher { public void update(String str); }
然后定义抽象的主题角色，即抽象的被观察者，在其中声明方法（添加、移除观察者，通知观察者）：
//抽象主题角色，watched：被观察 public interface Watched { public void addWatcher(Watcher watcher); public void removeWatcher(Watcher watcher); public void notifyWatchers(String str); }
然后定义具体的观察者：
public class ConcreteWatcher implements Watcher { @Override public void update(String str) { System.out.println(str); } }
之后是具体的主题角色：
import java.util.ArrayList; import java.util.List; public class ConcreteWatched implements Watched { // 存放观察者 private List<Watcher> list = new ArrayList<Watcher>(); @Override public void addWatcher(Watcher watcher) { list.add(watcher); } @Override public void removeWatcher(Watcher watcher) { list.remove(watcher); } @Override public void notifyWatchers(String str) { // 自动调用实际上是主题进行调用的 for (Watcher watcher : list) { watcher.update(str); } } }
编写测试类：
public class Test { public static void main(String[] args) { Watched girl = new ConcreteWatched(); Watcher watcher1 = new ConcreteWatcher(); Watcher watcher2 = new ConcreteWatcher(); Watcher watcher3 = new ConcreteWatcher(); girl.addWatcher(watcher1); girl.addWatcher(watcher2); girl.addWatcher(watcher3); girl.notifyWatchers("开心"); } }
----------------------------------------------------------------------------------------------------------------------------
代理模式
一般涉及到的角色有：
抽象角色：声明真实对象和代理对象的共同接口；
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
应用场景举例：
比如西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理，表现在程序上时是这样的体现的
先说说这个场景中的要素：一种类型的女人，潘金莲，王婆，西门庆，后来扩展的贾氏也和西门庆勾上了，我们是假设的，然后西门庆找潘金莲happy,但潘金莲不好意思直接，就找个王婆代理呗。我们看看具体代码。
先定义一种女人
Java代码
- package com.yangguangfu.proxy;
- /**
- *
- * @author 阿福(trygf521@126.com)<br>
- *定义一种类型的女人，王婆和潘金莲都属于这个类型的女人
- */
- public interface KindWoman {
- //这种女人能做什么事情呢？
- public void makeEyesWithMan();//抛媚眼
- public void happyWithMan();//和男人那个....
- }
一种类型嘛，那肯定是接口，定义个潘金莲
Java代码
- package com.yangguangfu.proxy;
- /**
- *
- * @author 阿福(trygf521@126.com)<br>
- *定义一个潘金莲是什么样的人
- */
- public class PanJinLian implements KindWoman{
- @Override
- public void happyWithMan() {
- System.out.println("潘金莲和男人在做那个...");
- }
- @Override
- public void makeEyesWithMan() {
- System.out.println("潘金莲抛媚眼...");
- }
- }
再定义个丑陋的王婆
Java代码
- package com.yangguangfu.proxy;
- /**
- *
- * @author 阿福(trygf521@126.com)<br>
- *王婆这个人老聪明了，她太老了，是个男人都看不上她，
- *但是她有智慧经验呀，他作为一类女人的代理！
- */
- public class WangPo implements KindWoman {
- private KindWoman kindWoman;
- public WangPo(){
- //默认的话是潘金莲的代理
- this.kindWoman = new PanJinLian();
- }
- //她可以是KindWomam的任何一个女人的代理，只要你是这一类型
- public WangPo(KindWoman kindWoman){
- this.kindWoman = kindWoman;
- }
- @Override
- public void happyWithMan() {
- //自己老了，干不了了，但可以叫年轻的代替。
- this.kindWoman.happyWithMan();
- }
- @Override
- public void makeEyesWithMan() {
- //王婆年纪大了，谁看她抛媚眼啊
- this.kindWoman.makeEyesWithMan();
- }
- }
两个女主角都上场了，该男主角了，定义个西门庆
Java代码
- package com.yangguangfu.proxy;
- /**
- *
- * @author 阿福(trygf521@126.com)<br>
- *水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下：
- *如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！
- */
- public class XiMenQiang {
- /**
- * @param args
- */
- public static void main(String[] args) {
- WangPo wangPo;
- //把王婆叫出来
- wangPo = new WangPo();
- //然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：
- wangPo.makeEyesWithMan();
- //看到没有表面是王婆在做，其实爽的是潘金莲
- wangPo.happyWithMan();
- }
- }
那这就是活生生的一个例子，通过代理人实现了某种目的，如果真去了王婆这个中间环节，直接西门庆和潘金莲勾搭，估计很难成就武松杀嫂事件。
那我们再考虑一下，水浒里面还有没有这类型的女人？有，卢俊义的老婆贾氏（就是和那个管家苟合的那个），这个名字起的：“贾氏”，那我们也让王婆做她的代理：
Java代码
- package com.yangguangfu.proxy;
- /**
- *
- * @author 阿福(trygf521@126.com)<br>
- *定义一个贾氏是什么样的人
- */
- public class JiaShi implements KindWoman {
- @Override
- public void happyWithMan() {
- System.out.println("贾氏和男人在做那个...");
- }
- @Override
- public void makeEyesWithMan() {
- System.out.println("贾氏抛媚眼...");
- }
- }
西门庆勾潘金莲又勾引贾氏
Java代码
- package com.yangguangfu.proxy;
- /**
- *
- * @author 阿福(trygf521@126.com)<br>
- *水浒传是这样写的：西门庆被潘金莲用竹竿敲了一下，西门庆看痴迷了，被王婆看到了，就开始撮合两人好事，王婆作为潘金莲的代理人收了不少好处费，那我们假设一下：
- *如果没有王婆在中间牵线，这两个不要脸的能成事吗？难说得很！
- */
- public class XiMenQiang {
- /**
- * @param args
- */
- public static void main(String[] args) {
- WangPo wangPo;
- //把王婆叫出来
- wangPo = new WangPo();
- //然后西门庆说，我要和潘金莲Happy,然后王婆就安排了西门庆丢筷子哪出戏：
- wangPo.makeEyesWithMan();
- //看到没有表面是王婆在做，其实爽的是潘金莲
- wangPo.happyWithMan();
- //西门庆勾引贾氏
- JiaShi jiaShi = new JiaShi();
- wangPo = new WangPo(jiaShi);
- wangPo.makeEyesWithMan();
- wangPo.happyWithMan();
- }
- }
说完这个故事，那我总结一下，代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口呗。好了不多说了，慢慢体会吧。
工厂模式
一、工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式在《Java与模式》中分为三类：
1）简单工厂模式（Simple Factory）：不利于产生系列产品；
2）工厂方法模式（Factory Method）：又称为多形性工厂；
3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；
二、简单工厂模式
简单工厂模式又称 静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
1）简单工厂模式（Simple Factory）：不利于产生系列产品；
2）工厂方法模式（Factory Method）：又称为多形性工厂；
3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；
二、简单工厂模式
简单工厂模式又称 静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。
三、工厂方法模式
工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
来看下它的组成：
代码：
//抽象产品角色
public interface Moveable {
void run();
}
//具体产品角色
public class Plane implements Moveable {
@Override
public void run() {
System.out.println("plane....");
}
}
public class Broom implements Moveable {
@Override
public void run() {
System.out.println("broom.....");
}
}
public interface Moveable {
void run();
}
//具体产品角色
public class Plane implements Moveable {
@Override
public void run() {
System.out.println("plane....");
}
}
public class Broom implements Moveable {
@Override
public void run() {
System.out.println("broom.....");
}
}
//抽象工厂
public abstract class VehicleFactory {
abstract Moveable create();
}
//具体工厂
public class PlaneFactory extends VehicleFactory{
public Moveable create() {
return new Plane();
}
}
public class PlaneFactory extends VehicleFactory{
public Moveable create() {
return new Plane();
}
}
public class BroomFactory extends VehicleFactory{
public Moveable create() {
return new Broom();
}
}
//测试类
public Moveable create() {
return new Broom();
}
}
public class Test {
public static void main(String[] args) {
VehicleFactory factory = new BroomFactory();
Moveable m = factory.create();
m.run();
}
}
可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。
四、简单工厂和工厂方法模式的比较
工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。
五、抽象工厂模式
代码：
//抽象工厂类
public abstract class AbstractFactory {
public abstract Vehicle createVehicle();
public abstract Weapon createWeapon();
public abstract Food createFood();
}
public abstract Vehicle createVehicle();
public abstract Weapon createWeapon();
public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
@Override
public Food createFood() {
return new Apple();
}
@Override
public Vehicle createVehicle() {
return new Car();
}
@Override
public Weapon createWeapon() {
return new AK47();
}
}
@Override
public Food createFood() {
return new Apple();
}
@Override
public Vehicle createVehicle() {
return new Car();
}
@Override
public Weapon createWeapon() {
return new AK47();
}
}
//测试类
public class Test {
public static void main(String[] args) {
AbstractFactory f = new DefaultFactory();
Vehicle v = f.createVehicle();
v.run();
Weapon w = f.createWeapon();
w.shoot();
Food a = f.createFood();
a.printName();
}
}
public static void main(String[] args) {
AbstractFactory f = new DefaultFactory();
Vehicle v = f.createVehicle();
v.run();
Weapon w = f.createWeapon();
w.shoot();
Food a = f.createFood();
a.printName();
}
}
在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
六、总结。
（1） 简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。
扫一扫
1845
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
