标签: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 + ‘\‘‘ + ‘}‘; } }
建造者
public interface Builder { void buildHead(); void buildBody(); void buildFoot(); Person buildPerson(); }
导演者
public class Director { public Person buildPerson(Builder builder) { builder.buildHead(); builder.buildBody(); builder.buildFoot(); return builder.buildPerson(); } }
具体建造者
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; } }
测试:
#原型模式 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 + ‘\‘‘ + ‘}‘; } }
总结:
单例模式:一个类只有一个实例,而且自行实例化并向整个系统提供这个实例
工厂模式:通过一个共同的对象- 工厂类指定 新建哪个对象:更注重创建的方法
抽象工厂:工厂模式的升级版更注重一系列:更注重完整性
建造者模式:将一个复杂对象的构建分步骤执行、一步一步构造最终的对象:更注重创建的过程
原型模式:创建重复的对象,同时又能保证性能
@
标签:res only 数据库连接 bsp 现在 decide prot efault 完成
原文地址:https://www.cnblogs.com/DarGi2019/p/12779029.html