浅谈设计模式之「创建型模式」
Posted Sheldon的编程笔记
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了浅谈设计模式之「创建型模式」相关的知识，希望对你有一定的参考价值。
前言
设计模式，即软件设计中的“套路”。每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题解决方案的核心，这样，你就能一次又一次的使用该方案而不必做重复的劳动。
与设计模式密切相关的是6大设计原则，请参考之前的文章《》
设计原则概括：
单一职责原则告诉我们实现类要职责单一；
里氏替换原则告诉我们不要破坏继承体系；
依赖倒置原则告诉我们要面向接口编程；
接口隔离原则告诉我们在设计接口的时候要精简单一；
迪米特法则告诉我们要降低耦合。
开闭原则是总纲，他告诉我们要对扩展开放，对修改关闭。
设计模式有23种，可以分为三类：
创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。
结构型模式：把类或对象结合在一起形成一个更大的结构。
行为型模式：类和对象如何交互，及划分责任和算法。
下面的内容转载自 http://dwz.date/fDe
1. 单例模式
单例模式确保一个类只有一个实例，自行初始化并向整个系统提供这个实例。一个类只有一个实例减少了内存开支，特别是一个对象频繁创建销毁时。单例模式可细分为2种模式，饿汉式和懒汉式，二者的区别是初始化实例的时间不同，前者是在定义时就初始化，后者是在第一次使用时初始化，这里注意多线程的并发访问。
/**
* Singleton - hungry man pattern
*/
public class Singleton {
private static Singleton singleton = new Singleton();
private Singleton() { }
public static Singleton getInstance() {
return singleton;
}
public void hello() {
System.out.println("hello singleton");
}
}
/**
* Singleton2 - idler man pattern
*/
class Singleton2 {
private static Singleton2 singleton = null;
private Singleton2() { }
public static Singleton2 getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton2();
}
}
}
return singleton;
}
public void hello() {
System.out.println("hello singleton");
}
}
2. 工厂方法模式
工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
// --------------------- man
public interface Man {
void talk();
}
public class WhiteMan implements Man {
public void talk() {
System.out.println("WhiteMan talking");
}
}
public class BlackMan implements Man {
public void talk() {
System.out.println("BlackMan talking");
}
}
// --------------------- man factory
public interface ManFactory {
Man create();
}
public class WhiteManFactory implements ManFactory {
public Man create() {
return new WhiteMan();
}
}
public class BlackManFactory implements ManFactory {
public BlackMan create() {
return new BlackMan();
}
}
// --------------------- test code
public static void main(String[] args) throws InterruptedException {
ManFactory blackFactory = new BlackManFactory();
ManFactory whiteFactory = new WhiteManFactory();
Man blackMan = blackFactory.create();
Man whiteMan = whiteFactory.create();
blackMan.talk();
whiteMan.talk();
}3. 抽象工厂模式
为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类，可以理解为工厂方法的升级版。
// --------------------- two man interface
public interface Male {
void talk();
}
public interface Female {
void talk();
}
// --------------------- black man
public class BlackMale implements Male {
public void talk() {
System.out.println("BlackMale talking...");
}
}
public class BlackFemale implements Female {
public void talk() {
System.out.println("BlackFemale talking...");
}
}
// --------------------- white man
public class WhiteMale implements Male {
public void talk() {
System.out.println("WhiteMale talking...");
}
}
public class WhiteFemale implements Female {
public void talk() {
System.out.println("WhiteFemale talking...");
}
}
// --------------------- man factory
public interface Factory {
Male createMale();
Female createFemale();
}
public class BlackFactory implements Factory{
public Male createMale() {
return new BlackMale();
}
public Female createFemale() {
return new BlackFemale();
}
}
public class WhiteFactory implements Factory {
public Male createMale() {
return new WhiteMale();
}
public Female createFemale() {
return new WhiteFemale();
}
}
// --------------------- test code
public static void main(String[] args) throws InterruptedException {
Factory blackFactory = new BlackFactory();
Factory whiteFactory = new WhiteFactory();
Male blackMale = blackFactory.createMale();
Male whiteMale = whiteFactory.createMale();
Female blackFemale = blackFactory.createFemale();
Female whiteFemale = whiteFactory.createFemale();
blackMale.talk();
whiteMale.talk();
blackFemale.talk();
whiteFemale.talk();
}
4. 建造者模式
建造者模式也叫作生成器模式，将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。比如一个User类的属性有name、age、address、email、job...等，如果想创建一个User对象，传入全部的属性有点太长了，这时可以使用建造者模式，传入一个参数就只设置对应属性的值。
/**
* Builder
*/
public class User {
private String name;
private int age;
private String phone;
private String address;
public static class Builder {
private String name;
private int age;
private String phone;
private String address;
public Builder(String name, int age) {
this.name = name;
this.age = age;
}
public Builder phone(String phone) {
this.phone = phone;
return this;
}
public Builder address(String address) {
this.address = address;
return this;
}
public User build() {
return new User(this);
}
}
public User(Builder builder) {
this.name = builder.name;
this.age = builder.age;
this.phone = builder.phone;
this.address = builder.address;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", phone='" + phone + '\'' +
", address='" + address + '\'' +
'}';
}
}
// ----------- test
public static void main(String[] args) {
User user = new User.Builder("luoxn28", 23).phone("119").build();
System.out.print(user);
}
5. 原型模式
原型模式的定义为：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式的核心是一个clone()方法，通过该方法进行对象的复制，Java提供了一个Cloneable来标示这个对象是可拷贝的，为什么说是“标示”呢？这个接口只是一个标记作用，在JVM中具有这个标记的对象才有可能被拷贝。那怎么才能从“有可能被拷贝”到“可以被拷贝”呢？方式就是覆盖clone()方法。
public class Thing implements Cloneable {
public Thing() {
System.out.println("constructor thing");
}
@Override
public Thing clone() throws CloneNotSupportedException {
Thing thing = null;
thing = (Thing) super.clone();
return thing;
}
}
// --------------------- test code
public static void main(String[] args) throws CloneNotSupportedException {
Thing thing = new Thing();
Thing cloneThing = thing.clone();
}
总结
总结一下，创建型模式分为以下5种：
单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
工厂方法（FactoryMethod）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。
下期我们接着说「结构型模式」，敬请期待。「拒绝白嫖，从我做起，点击关注，好人一生平安」。
以上是关于浅谈设计模式之「创建型模式」的主要内容，如果未能解决你的问题，请参考以下文章