目录

一、设计模式

1.创建型模式

1.1、FactoryMethod ( 工厂方法 )

1.2、AbstractFactory ( 抽象工厂 )

1.3 Singleton ( 单态模式 )

1.4 Builder ( 建造者模式 )

1.5、Prototype ( 原型模式 )

一、设计模式

1.创建型模式

    其中创建型模式分为: FactoryMethod ( 工厂方法 )、AbstractFactory ( 抽象工厂 )、Singleton ( 单态模式 )、Builder ( 建造者模式 )、Prototype ( 原型模式 )

1.1、FactoryMethod ( 工厂方法 )

  概述

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

适用性

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

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

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

参与者

1.Product

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

2.ConcreteProduct

实现Product接口。

3.Creator

声明工厂方法，该方法返回一个Product类型的对象。 Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。 可以调用工厂方法以创建一个Product对象。

4.ConcreteCreator

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

 例子

// Product
 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 getWork();
}


//ConcreteCreator

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(String[] args) {
        IWorkFactory studentWorkFactory = new StudentWorkFactory();
        studentWorkFactory.getWork().doWork();
        
        IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
        teacherWorkFactory.getWork().doWork();
    }

}

//result 

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

1.2、AbstractFactory ( 抽象工厂 )

概述

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

适用性

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

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

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

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

参与者

1.AbstractFactory

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

2.ConcreteFactory

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

3.AbstractProduct

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

4.ConcreteProduct

    定义一个将被相应的具体工厂创建的产品对象。 实现AbstractProduct接口。

5.Client
     仅使用由AbstractFactory和AbstractProduct类声明的接口

类图

 例子

//AbstractFactory 

public interface IAnimalFactory {

    ICat createCat();
	
    IDog createDog();
}

// ConcreteFactory 

public class BlackAnimalFactory implements IAnimalFactory {

    public ICat createCat() {
        return 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 black cat is eating!");
    }

}

public class WhiteCat implements ICat {

    public void eat() {
        System.out.println("The white 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 eating!");
    }

}

//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 eating!

1.3 Singleton ( 单态模式 )

 概述

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

适用性

1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。 2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

参与者

Singleton 定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。 可能负责创建它自己的唯一实例。

类图

 例子

//Singleton 

public class Singleton {
    
    private static Singleton sing;

    private Singleton() {
        
    }
    
    public static Singleton getInstance() {
        if (sing == null) {
            sing = new Singleton();
        }
        return sing;
    }
}

//Test 

public class Test {
    
    public static void main(String[] args) {
        Singleton sing = Singleton.getInstance();
        Singleton sing2 = Singleton.getInstance();
        
        System.out.println(sing);
        System.out.println(sing2);
    }
}

//result 

singleton.Singleton@1c78e57
singleton.Singleton@1c78e57

1.4 Builder ( 建造者模式 )

概述

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

适用性

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 buildBody() {
        person.setBody("建造男人的身体");
    }

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

    public void buildHead() {
        person.setHead("建造男人的头");
    }

    public Person buildPerson() {
        return person;
    }
}

//Director 

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.5、Prototype ( 原型模式 )

概述

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

适用性

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