BlogJava-积少成多-随笔分类-模式

观察者模式

思无 — Mon, 30 May 2011 04:24:00 GMT

//被观察者接口，有添加观察者对象，唤醒所有观察者等方法申明。
public interface ISubject {
    public void setName(String name);
    public String getName();
    public void addObserver(IObserver o);
    public void notifyAllObserver();
}

import java.util.*;
public class Subject implements ISubject{
    private String name;
    List<IObserver> observers = new ArrayList<IObserver>();
    public Subject(){}

    public Subject(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public void addObserver(IObserver o){
        observers.add(o);
    }
    public void notifyAllObserver(){
        for(int i=0;i<observers.size();i++){
            observers.get(i).showInfo();
        }
    }
}

//观察者接口。
public interface IObserver {
    public void showInfo();
}

public class Observer implements IObserver{

    private ISubject sjtref = null;

    public void setRef(ISubject sjt){
        this.sjtref=sjt;
    }
    public Observer(ISubject sjtref){
        super();
        this.sjtref=sjtref;
    }
    public void showInfo(){
        System.out.println("Observering:"+sjtref.getName());
    }
}

public class ObserverMain {
    public static void main(String args[]){
        //新建被观察对象
        ISubject subject = new Subject("Shen,Ziping");
        //新建观察者对象
        IObserver observer1 = new Observer(subject);
        //注册
        subject.addObserver(observer1);
        //唤醒观察者
        subject.notifyAllObserver();
    }
}

思无 2011-05-30 12:24 发表评论

抽象工厂模式

思无 — Fri, 27 May 2011 06:21:00 GMT

public interface IMobilePhone {
    public void call();
}

public class NokiaMPhone implements IMobilePhone{
    public void call(){
    }
}

public class OppoMPhone implements IMobilePhone{
    public void call(){
    }
}

public interface IFactory {
    public IMobilePhone createNokiaPhone();
    public IMobilePhone createOppoPhone();
}

public class MobilePhoneFactory implements IFactory{
    public IMobilePhone createNokiaPhone(){
        return new NokiaMPhone();
    }
    public IMobilePhone createOppoPhone(){
        return new OppoMPhone();
    }
}

public class Client {
    public static void main(String args[]){
        IFactory factory = new MobilePhoneFactory();
        IMobilePhone nokia = factory.createNokiaPhone();
        IMobilePhone oppo = factory.createOppoPhone();
        nokia.call();
        oppo.call();
    }
}

就代码上而言，工厂模式和抽象工厂模式功能上是差不多的。都通过借口遍程实现了比较好的代码隔离。不同的地方在于factory类的组织。工厂模式对每一个产品均实现一个工厂。而抽象工厂在一个工厂类中建立多个方法返回多种产品。

思无 2011-05-27 14:21 发表评论

工厂模式

思无 — Fri, 27 May 2011 02:53:00 GMT

工厂模式的产品角色和简单工厂并没有区别。变化就是在工厂角色那。将具体创建产品的工作放到子工厂进行。这样就便于进行扩展了。
public interface IProduct {
    public void desc();
}

public class ProductA implements IProduct {
    public void desc() {
        //excute;
    }
}

public class ProductB implements IProduct {
    public void desc() {
        //excute;
    }
}

public interface IFactory {
    public IProduct factory();
}

public class FactoryA implements IFactory {
    public IProduct factory() {
        return new ProductA();
    }
}

public class FactoryB implements IFactory {
    public IProduct factory() {
        return new ProductB();
    }
}

个人觉得如果工厂的factory方法如果是静态的也可以阿。为什么不呢？但是接口是无法申明static的方法的。只能用类或抽象类来做。不知道还有没有更好的方法。

public abstract class IFactory {
    public static IProduct factory(){return null;};
}

public class FactoryA extends IFactory {
    public static IProduct factory() {
        return new ProductA();
    }
}

public class FactoryB extends IFactory {
    public static IProduct factory() {
        return new ProductB();
    }
}

思无 2011-05-27 10:53 发表评论

简单工厂模式

思无 — Fri, 27 May 2011 02:38:00 GMT

public interface IProduct {
    public void desc();
}

public class ProductA implements IProduct {
    public void desc(){
        System.out.println("A");
    }
}

public class ProductB implements IProduct {
    public void desc(){
        System.out.println("B");
    }
}

public class Factory {
    public static IProduct factory(String name)throws Exception{
        if(name.equalsIgnoreCase("A")){
            return new ProductA();
        }else if(name.equalsIgnoreCase("B")){
            return new ProductB();
        }else{
            throw new Exception("Don't support");
        }
    }
}
优点
1. 工厂创建的类实现相同的接口。便于统一创建和返回。
2. 对于不支持的类型，可以抛出异常。
缺点
1. 不支持新加类型。如果要加入新的类型。需要修改Factory类。

思无 2011-05-27 10:38 发表评论