设计模式

 

public abstract class INoodles {
    /**
     * 描述每种面条啥样的
     */
    public abstract void desc();
}

复制代码

先来一份兰州拉面（具体的产品类）：
复制代码

public class LzNoodles extends INoodles {
    @Override
    public void desc() {
        System.out.println("兰州拉面 上海的好贵 家里才5 6块钱一碗");
    }
}

复制代码

程序员加班必备也要吃泡面（具体的产品类）：
复制代码

public class PaoNoodles extends INoodles {
    @Override
    public void desc() {
        System.out.println("泡面好吃 可不要贪杯");
    }
}

复制代码

还有我最爱吃的家乡的干扣面（具体的产品类）：
复制代码

public class GankouNoodles extends INoodles {
    @Override
    public void desc() {
        System.out.println("还是家里的干扣面好吃 6块一碗");
    }
}

复制代码

准备工作做完了，我们来到一家“简单面馆”（简单工厂类），菜单如下：
复制代码

public class SimpleNoodlesFactory {
    public static final int TYPE_LZ = 1;//兰州拉面
    public static final int TYPE_PM = 2;//泡面
    public static final int TYPE_GK = 3;//干扣面

    public static INoodles createNoodles(int type) {
        switch (type) {
            case TYPE_LZ:
                return new LzNoodles();
            case TYPE_PM:
                return new PaoNoodles();
            case TYPE_GK:
            default:
                return new GankouNoodles();
        }
    }
}

复制代码

简单面馆就提供三种面条（产品），你说你要啥，他就给你啥。这里我点了一份干扣面:

/**
 * 简单工厂模式
 */
 INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_GK);
 noodles.desc();

输出：

还是家里的干扣面好吃 6块一碗

特点

1 它是一个具体的类，非接口 抽象类。有一个重要的create()方法，利用if或者 switch创建产品并返回。

2 create()方法通常是静态的，所以也称之为静态工厂。
缺点

1 扩展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）

2 不同的产品需要不同额外参数的时候 不支持。

 

 

 

 

工厂方法

 

    *义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例*延迟到其子类。

 适用性

    1.当一个类不知道它所必须创建的对象的类的时候。

    2.当一个类希望由它的子类来指定它所创建的对象的时候。

    3.当*将创建对象的职责委托给多个帮助*类中的某一个，并且*希望将哪一个帮助子类是代理者这一信息局部化的时候。

 参与者

    1.Product

      定义工厂方法所创建的对象的接口。

    2.ConcreteProduct

      实现Product接口。

    3.Creator

      声明工厂方法，该方法返回一个Product类型的对象*

      Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。

      可以调用工厂方法以创建一个Product对象。

    4.ConcreteCreator

      重定义工厂方法以返回一个ConcreteProduct实例。

*roduct 

public interface Work {

    void doWork();
}
ConcreteProduct 

public class StudentWork implements Work {

    public void doWork() {
        System.out.println("学生*作业!");
    }

}

public class TeacherWork implements Work {

    public void doWork() {
        System.out.println("老师审批作业!");
    }

}
Creator 

public interface IWorkFactory {

    Work get*ork();
}
Concre*eCreator 

pu*lic class StudentWorkFactory implements IWorkFactory {

    public Work getWork() {
        *eturn new StudentWork();
    }

}

public class TeacherWorkFactory implements IWorkFactory {

    public Work getWork() {
        return new TeacherWork();
    }

}
Test 

public class Test {

    public static void m*in(Strin*[] args) {
        IWorkFactory studentWorkFactory = new StudentWorkFactory();
        studentWorkFactory.getWork().d*Work();
        
        IWorkFactory teacherWorkFactory * new TeacherWorkFactory();
        teacherWorkFactory.g*tWork().*oWork();
    }

}
result 

学生做作业!
老师审批作业!

 抽象工厂

 

    提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

 适用性

    1.一个系统要独立于它的*品的创建、组合和表示时。

    2.一个系统要由多个产品系列中的一个来配置时。

    3.当你要强调一系列相关的产品对象的设计以便进行联合使用时*

    4*当你提供一个产品类库，而只想显示它们*接口而不是实现时。

 

 参与者

    1.Ab*tractFactory

      声明一个创建抽象产品对象的操作接口。

    2.ConcreteFactory

      实现创建具体产品对象的操作。

    *.AbstractProduct

      为一类产品对象声明一个接口。

    4.ConcreteProdu*t

      定义一个将被相应的具体工厂创建的产品*象。

      实现*bstractProduct接口。

 

    5.Client

      仅使用由AbstractFactory和AbstractProduc*类声明的接口

*bstractFactory 

public interface IAn*malFactory {

    ICat createCat();
    
    IDog cre*teDog();
}
ConcreteFactory 

p*blic class BlackAnimalFactory implem*nts IAnimalFactory {

    public ICat createCat() {
        retur* new BlackCat();
    }

    public IDog createDog() {
        return new BlackDog();
    }

}

public class WhiteAnimalFac*ory imp*ements IAnimalFactory {

    public ICat createCat() {
        return new WhiteCat();
    }

    public IDog cre*teDog() {
        return new WhiteDog();
    }

}
Abstrac*Product 

public interface ICat {

    void eat();
}

public interface IDog {

    void eat();
}
Concrete*roduct 

public class Black*at implements ICat {

    public void eat() {
        System.out.println("The bl*ck cat is eating!");
    }

}

public class WhiteCat implements *Cat {

    public void eat() {
        Sy*tem.out.prin*ln("The w*ite cat is eating!*);
    }

}

public class BlackDog implements IDog {

    public void eat() {
        System.out.println("The black dog is eating");
    }

}

public class WhiteDog implements IDog {

    public void eat() {
        System.out.println("The white dog is eat*ng!");
    }

}
Client 

public static void main(String[] args) {
    IAnimalFactory blackAnimalFa*tory = new BlackAnimalFactory();
    ICat blackCat = blackAnimalFactory.createCat();
    blackCat.eat();
    IDog blackD*g = blackAnimalFactory.createDog();
    blackDog.eat();
    
    IAnimalFactory whiteAnimalF*ctory = new WhiteAnimalFactory();
    ICat whiteCat = whiteAnimalFactory.createCat();
    whiteCat.eat();
    IDog *hiteDog = whiteAnimalFactory.createDog();
    whiteDog.eat();
}
res*lt 

The bla*k cat is eating!
Th* black dog is eatin*!
The white cat is eating!
The white dog is *ating!

建造者模式

    将一个复杂对象的构造与它的表示分离，使不同样的构建过程可以创建不同的表示。

 适用性

    1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

    *.当构造过程必须允*被构造的对象有不同*表示时。

 参与者

    1.Builder

      为创建一个Product对象的各个部件指定抽象接口。

    2.ConcreteBuilder

      实现Buil*er的接口以构造和装配该产品的各个部件。

      定义并明确它所创建的表示*

      提供一个检索产品的接口。

    3.Director

      构造一个使用Builder接口的对象。

    4.Product

      表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。

      包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

Buil*er 

public interface PersonBuilder {

    void buildHead();
    
    v*id buildBody();
    
    void buildFoot()*

    Person buildPerson();
}
ConcreteBuilder 

public class ManBuilder implements PersonB*ilder {

    Person person;
    
    public ManBuilder() {
        person = ne* Man();
    }
    
    publ*c void build*ody() {
        perso*.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFo*t("建造男人的脚");
    }

    public void buildHead() {
        pers*n.setHead("建造*人的头");
    }

    *ublic Person buildPerson() {
        retur* person;
    }
}
Dir*ctor 

public class PersonDirec*or {

    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}
Product 

public class Person {

    private String head;
    
    private String body;
    
    private String foot;

    public String getH*ad() {
        return head;
    }

    public void setHead(String hea*) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.b*dy = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        t*is.foot = foot;
    }
}

public class Man extends Person {

}
Test 

publ*c class Test{
    
    public static void main(String[] ar*s) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System*out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}
result 

建造男人*身体
建造男*的脚
建造男人的头

原型模式

    用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
 适用性

    1.当一个系统应该独立于它的产品创*、构成和表示时。

    2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。

    3.为了避免创建一个与产品类层次平行的工厂*层次时。

    4.当一个类的实例只能有几个不同状态组合中的一种时。

    建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
            
 参与者

    1. Prototype
       声明一个克隆自身的接口。

    2. ConcretePrototype
       实现一个克隆自身的操作。

    3. Client
       让一个原型克*自身从而创建一个新的对象。
 类图

 例子
Prototype 

public class Prototype implements Cloneable {

    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }

    public Object clone(){
        try {
            return super.clone();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}
ConcretePrototype 

publ*c class ConcretePrototype extend* Prototype {

    public ConcretePrototype(String name) {
        setName(name);
    }
}
Client 

public clas* Test {

    public static void main(String[] args) {
        Prototype pro = new ConcretePrototy*e("prototype");
        Prototype pro2 = (Prototype)pro.clone();
        *ystem.out.println(pro.getName()*;
        System.out.println(pro2.getName());
    }
}
result 

prototype
prototype

装饰模式

    动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模*相比生成子类更为*活。

 适用性

    1.在不影响其他*象的情况下，以动态、透明的方式给单个对象添加职责。

    2.处理那些可以撤消的职责。

    3.当不能采用生成子类的方法进行扩充时。

 参与者

    1.Component

      定义一个对象接口，可以给这些对象动态地添加职责。

    2.ConcreteComponent

      定义一个对象，可以给这个对象添加一些职责。

    3.Decorator

      维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。

    4.ConcreteDecorator

      向组件添加职责。

Component 

public interface Person {

    void eat();
}
ConcreteComponent 

*ublic class M*n implements Person {

    public void eat() {
        System.out.println("男人在吃");
    *
}
Decorator 

public abstrac* class Decorator implements Perso* {

    protected Person person*
    
    public void setPerson(Person person) {
        this.person = person;
    }
    
    public void eat() {
        person.eat();
    }
}
ConcreteDec*rator 

publi* class ManDecoratorA extends Decorator {

    public void eat() {
        super.eat();
        reEat();
        Sy*tem.out.println("ManDecoratorA类");
    }

    public void reEat() {
        System.out.println("再吃一顿饭");
    *
}

public class ManDecoratorB extends Decorator *
    
    public void eat() {
        super.eat();
        Syst*m.out.println("===============");
        System.out.println("ManDecoratorB类");
    }
}
Test 

public class Test {

    public st*tic void main(Strin*[] args) {
        Man man = new Man();
        ManDecoratorA md1 = new ManDecoratorA();
        ManDecoratorB md2 = n*w ManDecoratorB();
        
        md1.setPerson(man);
        md2.setPerson(md1);
        md2.eat();
    }
}
result 

男人在吃
再吃一顿饭
ManDecoratorA类
===============
ManDecoratorB类