设计模式学习(一) 创建型

时间：2020-04-27 15:31:51 阅读：59 评论：0 收藏：0 [点我收藏+]

标签：res only 数据库连接 bsp 现在 decide prot efault 完成

2020年04月26日-

为什么学习设计模式？

　　设计模式是很多经验丰富的程序员总结出来的、一些问题的解决方案。学习设计模式可以让我们读写代码更得心应手。让代码更灵活、复用性好、可扩展性好。

设计模式按照特点可分为三种。

　　创建型结构型行为型

创建型：

　　最常说到的单例模式就是创建型。创建模式是用来创建对象的模式、把具体的信息封装起来、隐藏类的实例、提供尽可能大的灵活性。

　　简单说就是what 创建什么 who 谁创建 when 什么时候创建 ? 目的：封装创建的逻辑、尽量少更改代码！

　　包括5种：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

　　#单例模式(Singleton Pattern)：Ensure a class has only one instance,and provide a global point of access to it.

　　　　一个类只有一个实例、且自行实例化、并向整个系统提供这个实例

　　　　优点：减少内存的开支

　　　　缺点：无法创建子类、扩展困难、测试困难、需要定义静态的资源

　　　　用：比如记录系统访问次数、读配置文件、数据库连接、spring 框架中默认Bean 是单例的。在分布式系统中应避免使用有状态的单例。如单例类实现了

Serializable或 Cloneable 接口就会破坏"唯一单例"的要求。所以通常单例不需要实现这两个接口。

　　　　懒汉：第一次引用才进行实例化

public class SingletonPattern {

    private static volatile SingletonPattern instance = null;    //保证 instance 在所有线程中同步

    private SingletonPattern() {//构造方法私有 确保一个实例 避免外界利用构造函数创建实例
    }

    public static synchronized SingletonPattern getInstance() {// 同步线程安全 通过该方法获取实例对象

        if (instance == null) {
            instance = new SingletonPattern();
        }
        return instance;
    }
}

　　　　饿汉：类加载就进行实例化

public class SingletonPattern {

    private static SingletonPattern instance = new SingletonPattern();

    private SingletonPattern() {
    }

    public static SingletonPattern getInstance() {
        return  instance;
    }
}

　　#工厂模式(Factory Pattern) Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.

　　　　工厂类为抽象类、具体工作由子类来完成。强调“单个对象”的变化。

　　　　有简单工厂模式(不属于23种设计模式)、工厂模式、抽象工厂模式

　　　　*简单工厂模式：

　　　　　　工厂类处于中心的位置由他决定实例化谁？

　　　　　　优点：尽可能不改变客户端。缺点：当新增产品需要修改工厂类。

水果：

public interface Fruit {

    void juice();

}

苹果：

public class Apple implements Fruit {

    public void juice() {
        System.out.println("Apple juice");
    }

}

橙子：

public class Orange implements Fruit {

    public void juice() {
        System.out.println("orange juice");
    }

}

枚举：

public enum FruitEnum {
    Apple,Orange;
}

　工厂：　　　　　

public class Factory {

    public static Fruit getJuice(FruitEnum type) {
        switch (type) {
            case Apple:
                return new Apple();
            case Orange:
                return new Orange();
            default:
                break;
        }
        return null;
    }

}

　　　　工厂模式：

　　　　　　是简单工厂模式的进一步推广。保持了简单工厂的优点克服了他的缺点。

　　　　　　工厂模式的核心不再是工厂类，而将具体的创建交给了子类。

　　　　　　包含的角色：

　　　　　　　　抽象工厂角色：创建对象必须实现该接口 - 水果工厂

　　　　　　　　具体工厂角色：具体工厂对象 - 苹果工厂

　　　　　　　　抽象产品角色：产品最抽象的定义 - 水果

　　　　　　　　具体产品角色：具体产品 - 苹果

　　　　　　优点：良好的封装、优秀的可扩展性、就算产品实现改变调用接口无需改变、调用者不用担心接口内部的实现。

　　　　　　缺点：增加了复杂度、

　　　　#具体产品和抽象产品角色跟简单工厂差不多。

技术图片

　　 #具体工厂

public class AppleFactory implements FruitFactory {

    public Fruit getFruit() {
        return new Apple();
    }
}

public class OrangeFactory implements  FruitFactory{

    public Fruit getFruit() {
       return new Orange();
    }
}

　　　　 #抽象工厂：

public interface FruitFactory {

    Fruit getFruit();
}

测试

技术图片

　　#抽象工厂(Abstract Factory Pattern) Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

　　　工厂模式的升级版、更强调“一族对象”。为创建一组相关或相互依赖的对象提供一个接口、但无需指定他们的具体类。

　　　加了一个蔬菜工厂也可以生产蔬菜汁了。

技术图片

public class FactoryA implements  Factory{

    public Vegetable getVegetable(){
        return new Cucumber();
    }

    public Fruit getFruit(){
        return new Orange();
    }

}

public class FactoryB implements Factory{

    public Vegetable getVegetable() {
        return new Carrot();
    }

    public Fruit getFruit() {
        return new Apple();
    }
}

public interface Factory {

     Vegetable getVegetable();

     Fruit getFruit();

}

测试：两个工厂分别做出了不同的蔬菜汁和水果汁

技术图片

　　#建造者模式(Builder Pattern) Separate the construction of a complex object from its representation so that the sameconstruction process can create different representations.

　　　　四个角色：

　　　　　　抽象建造者（Builder）角色：抽象接口 - 规范产品的各个组成部分

　　　　　　具体建造者（Concrete Builder）角色：具体角色 - 男人

　　　　　　产品（Product）角色：要建造的复杂对象 - 人

　　　　　　导演者（Director）角色：告诉 Builder 开始建造。

　　　　优点：调用者无需知道产品的内部细节、建造者是独立的容易扩展

　　　　用：产品复杂、相同的方法不同的执行顺序。多个零件都可装在一个产品中但结果不同。就像组装计算机用不同品牌的部件都可做成计算机。

　　　　技术图片

产品：

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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "head=‘" + head + ‘\‘‘ +
                ", body=‘" + body + ‘\‘‘ +
                ", foot=‘" + foot + ‘\‘‘ +
                ‘}‘;
    }
}

View Code

建造者

public interface Builder {

    void buildHead();

    void buildBody();

    void buildFoot();

    Person buildPerson();

}

View Code

导演者

public class Director {

    public Person buildPerson(Builder builder) {
        builder.buildHead();
        builder.buildBody();
        builder.buildFoot();
        return builder.buildPerson();
    }

}

View Code

具体建造者

public class Man implements Builder {

    Person person;

    public Man() {
        person = new Person();
    }

    public void buildHead() {
        person.setHead("Man head");
    }

    public void buildBody() {
        person.setBody("Man body");
    }

    public void buildFoot() {
        person.setFoot("Man foot");
    }

    public Person buildPerson() {
        return person;
    }

}

View Code

测试：

技术图片

#原型模式 Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype

　　用原型实例创建指定对象种类，并且通过复制原型创建新对象。比如说现在要给家长写一封信每封信的内容相同区别在于称呼不同。写1000封信？

　　用：类的初始化复杂、消耗很多资源

　　在JAVA中仅需两步：

　　　　实现Cloneable接口；覆盖clone()方法；

public class Mail implements Cloneable {

    private String receiver;
    private String title;
    private String content1;
    private String content2;
    private String content3;

    public Mail clone(){
        Mail mail = new Mail();
        try {
            mail = (Mail) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return mail;
    }

    public String getReceiver() {
        return receiver;
    }

    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent1() {
        return content1;
    }

    public void setContent1(String content1) {
        this.content1 = content1;
    }

    public String getContent2() {
        return content2;
    }

    public void setContent2(String content2) {
        this.content2 = content2;
    }

    public String getContent3() {
        return content3;
    }

    public void setContent3(String content3) {
        this.content3 = content3;
    }

    @Override
    public String toString() {
        return "Mail{" +
                "receiver=‘" + receiver + ‘\‘‘ +
                ", title=‘" + title + ‘\‘‘ +
                ", content1=‘" + content1 + ‘\‘‘ +
                ", content2=‘" + content2 + ‘\‘‘ +
                ", content3=‘" + content3 + ‘\‘‘ +
                ‘}‘;
    }
}