java设计模式（一）：创建型模式

1. 设计模式

 

1.1 创建型模式

AbstractFactory ( 抽象工厂 )

FactoryMethod ( 工厂方法 )

Singleton ( 单态模式 )

Builder ( 建造者模式 )

Protot*pe * 原型模式 )

1.1.1 工厂方法

    定义一个用于创建对象的接口，让子类决定实例化哪一个类。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

public class StudentWorkFactory implements IWorkFactory {

    public Work getWork() {

        return new StudentWork();

    }

}

public class TeacherWorkFactory implements IWorkFactory {

    public Work getWork() {

        return new TeacherWork();

    }

}

Test

public class Test {

    public static void main(Strin*[] args) {

        IWorkFactory studentWorkFactory = new StudentWorkFactory();

        studentWorkFactory.getWork().doWork();

        IWorkFactory teacherWorkFactory = new TeacherWorkFactory();

        teacherWorkFactory.g*tWork().doWork();

    }

}

result

学生做作业!

老师审批作业!

1.1.2 抽象工厂

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

 适用性

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

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

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

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

 参与者

    1.AbstractFactory

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

    2.ConcreteFactory

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

    3.AbstractProduct

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

    4.ConcreteProduct

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

      实现AbstractProduct接口。

    5.Client

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

 

 例子

AbstractFactory

public interface IAnimalFactory {

    ICat createCat();

    IDog createDog();

}

ConcreteFactory

public class BlackAnimalFactory implements IAnimalFactory {

    public ICat createCat() {

        reture new BlackCat();

    }

    public IDog createDog() {

        return new BlackDog();

    }

}

public class WhiteAnimalFactory implements IAnimalFactory {

    public ICat createCat() {

        return new WhiteCat();

    }

    public IDog createDog() {

        return new WhiteDog();

    }

}

AbstractProduct

public interface ICat {

    void eat();

}

public interface IDog {

    void eat();

}

ConcreteProduct

public class BlackCat implements ICat {

    public void eat() {

        System.out.println("The bl*ck cat is eating!");

    }

}

public class WhiteCat implements ICat {

    public void eat() {

        System.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 blackAnimalFactory = new BlackAnimalFactory();

    ICat blackCat = blackAnimalFactory.createCat();

    blackCat.eat();

    IDog blackDog = blackAnimalFactory.createDog();

    blackDog.eat();

    IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();

    ICat whiteCat = whiteAnimalFactory.createCat();

    whiteCat.eat();

    IDog whiteDog = whiteAnimalFactory.createDog();

    whiteDog.eat();

}

result

The black cat is eating!

The black dog is eating!

The white cat is eating!

The white dog is *ating!

1.1.3 建造者模式

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

 适用性

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

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

 参与者

    1.Builder

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

    2.ConcreteBuilder

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

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

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

    3.Director

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

    4.Product

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

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

 例子

Builder

public interface PersonBuilder {

    void buildHead();

    void buildBody();

    void buildFoot();

    Person buildPerson();

}

ConcreteBuilder

public class ManBuilder implements PersonBuilder {

    Person person;

    public ManBuilder() {

        person = new Man();

    }

    public void build*ody() {

        person.setBody("建造男人的身体");

    }

    public void buildFoot() {

        person.setFoot("建造男人的脚");

    }

    public void buildHead() {

        person.setHead("建造*人的头");

    }

    public Person buildPerson() {

        return person;

    }

}

Dircctor

public class PersonDirector {

    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 getHead() {

        return head;

    }

    public void setHead(String head) {

        this.head = head;

    }

    public String getBody() {

        return body;

    }

    public void setBody(String body) {

        this.body = body;

    }

    public String getFoot() {

        return foot;

    }

    public void setFoot(String foot) {

        this.foot = foot;

    }

}

public class Man extends Person {

}

Test

public class Test{

    public static void main(String[] args) {

        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.1.4 单态模式

    保证一个类仅有一个实例，需要提供一个访问它的全局访问点。

 适用性

    1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

    2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。                   

 参与者

    Singleton

      定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。

      可能负责创建它自己的唯一实例。

 类图

 例子

Singleton

public class Singleton {

    private static Singleton sing;

    private Singleton() { 

    }

    public static Singleton get*nstance() {

        if (sing == null) {

            sing = new Singleto*();

        }

        return sing;

    }

}

Test

public class Test {

    public static void *ain(*tring[] args) {

        Singleton sing = Singleton.getInstance();

        Singleton sing2 = Singleton.getInstance();

        System.out.println(sing);

        System.out.pr*ntln(sing2);

    }

}

result

singleton.Singleton@1c78e57

singleton.Singleton@1c78e57

1.1.5 原型模式

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

 适用性

    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

public class ConcretePrototype extends Prototype {

    public ConcretePrototype(String name) {

        setName(name);

    }

}

Client

public class Test {

    public static void main(String[] args) {

        Prototype pro = new ConcretePrototype("prototype");

        Prototype pro2 = (Prototype)pro.clone();

        System.out.println(pro.getName());

        System.out.println(pro2.getName());

    }

}

result

prototype

prototype