设计模式学习 创建型

Posted dargi2019

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式学习 创建型相关的知识，希望对你有一定的参考价值。

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 + ‘‘‘ +
                ‘}‘;
    }
}
View Code

技术图片

 

 

 

总结：

单例模式：一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

工厂模式：通过一个共同的对象- 工厂类指定 新建哪个对象：更注重创建的方法

抽象工厂：工厂模式的升级版更注重一系列：更注重完整性

建造者模式：将一个复杂对象的构建分步骤执行、一步一步构造最终的对象：更注重创建的过程

原型模式：创建重复的对象，同时又能保证性能

 

 

 

　　　　

 

 

　　　

 

 

 

 

　　

 

 

 

 

 

 

 

 

@

 

以上是关于设计模式学习 创建型的主要内容，如果未能解决你的问题，请参考以下文章

编程拾遗系列设计模式-创建型模式

PHP中逻辑性core问题解决创建型分销模式和二次分销的模式

设计模式学习笔记-创建型模式总结

一起来学设计模式-----创建型模式之简单工厂

201621123054《Java程序设计》第九周学习总结

201621123062《java程序设计》第九周作业总结