码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间: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 + ‘\‘‘ +
                ‘}‘;
    }
}
View Code

技术图片

 

 

 

总结:

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

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

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

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

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

 

 

 

    

 

 

   

 

 

 

 

  

 

 

 

 

 

 

 

 

@

 

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

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

原文地址:https://www.cnblogs.com/DarGi2019/p/12779029.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!