? 创建型模式的主要关注点是“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。
(1)、定义
? 指一个类只有一个实例，且该类能自行创建这个实例的一种模式
(2)、特点
(3)、结构
(4)、实现
方式一：懒汉式单例
? 该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。
? 多线程程序存在线程非安全的问题。但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
public class LazySingleton{
private static volatile LazySingleton instance=null; //保证 instance 在所有线程中同步
private LazySingleton(){} //private 避免类在外部被实例化
public static synchronized LazySingleton getInstance(){
if(instance==null){
instance=new LazySingleton();
}
return instance;
}
}
方式二：饿汉式单例
? 该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。
public class HungrySingleton{
private static final HungrySingleton instance=new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance(){
return instance;
}
}
(1)、定义
? 用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。
(2)、结构
Prototype(抽象原型类)：声明克隆方法的接口，是所有具体原型类的公共父类，它可是抽象类也可以是接口，甚至可以是具体实现类。
ConcretePrototype(具体原型类)：它实现抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象。
Client(客户端)：在客户类中，让一个原型对象克隆自身从而创建一个新的对象。
(3)、实现
方式一：浅克隆
? Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类。
//具体原型类
class Realizetype implements Cloneable{
Realizetype(){
System.out.println("具体原型创建成功！");
}
public Object clone() throws CloneNotSupportedException{
System.out.println("具体原型复制成功！");
return (Realizetype)super.clone();
}
}
//原型模式的测试类
public class PrototypeTest{
public static void main(String[] args)throws CloneNotSupportedException{
Realizetype obj1=new Realizetype();
Realizetype obj2=(Realizetype)obj1.clone();
System.out.println("obj1==obj2?"+(obj1==obj2));
}
}
(1)、定义
? 定义一个创建对象的工厂接口，将对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。
? “工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
(2)、特点
优点：
缺点：
? 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。
(3)、结构
工厂方法模式的主要角色如下。
(4)、实现
public class AbstractFactoryTest{
public static void main(String[] args){
AbstractFactory af=new ConcreteFactory1();
Product a=af.newProduct();
a.show();
}
}
//抽象产品：提供了产品的接口
interface Product{
public void show();
}
//具体产品1
class ConcreteProduct1 implements Product{
public void show(){
System.out.println("具体产品1显示...");
}
}
//具体产品2
class ConcreteProduct2 implements Product{
public void show(){
System.out.println("具体产品2显示...");
}
}
//抽象工厂：提供了厂品的生成方法
interface AbstractFactory{
public Product newProduct();
}
//具体工厂1
class ConcreteFactory1 implements AbstractFactory{
public Product newProduct(){
System.out.println("具体工厂1生成-->具体产品1...");
return new ConcreteProduct1();
}
}
//具体工厂2
class ConcreteFactory2 implements AbstractFactory{
public Product newProduct(){
System.out.println("具体工厂2生成-->具体产品2...");
return new ConcreteProduct2();
}
}
(1)、定义
? 是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。
(2)、特点
使用抽象工厂模式一般要满足以下条件。
抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。
缺点：
? 当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
(3)、结构
? 抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。
(4)、实现
//抽象工厂：提供了产品的生成方法。
interface AbstractFactory{
public Product1 newProduct1();
public Product2 newProduct2();
}
//具体工厂：实现了产品的生成方法。
class ConcreteFactory1 implements AbstractFactory{
public Product1 newProduct1(){
System.out.println("具体工厂 1 生成-->具体产品 11...");
return new ConcreteProduct11();
}
public Product2 newProduct2(){
System.out.println("具体工厂 1 生成-->具体产品 21...");
return new ConcreteProduct21();
}
}
(1)、定义
? 指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示。将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
(2)、特点
优点：
缺点：
(3)、结构
建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成。
(4)、实现
class Product{
private String partA;
private String partB;
private String partC;
public void setPartA(String partA){
this.partA=partA;
}
public void setPartB(String partB){
this.partB=partB;
}
public void setPartC(String partC){
this.partC=partC;
}
public void show(){
//显示产品的特性
}
}
public abstract class Builder{
//创建产品对象
protected Product product=new Product();
public abstract void buildPartA();
public abstract void buildPartB();
public abstract void buildPartC();
//返回产品对象
public Product getResult(){
return product;
}
}
public class ConcreteBuilder extends Builder{
public void buildPartA(){
product.setPartA("建造 PartA");
}
public void buildPartB(){
product.setPartA("建造 PartB");
}
public void buildPartC(){
product.setPartA("建造 PartC");
}
}
class Director{
private Builder builder;
public Director(Builder builder){
this.builder=builder;
}
//产品构建与组装方法
public Product construct(){
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
return builder.getResult();
}
}
public class Client{
public static void main(String[] args){
Director director=new Director(new ConcreteBuilder());
Product product=director.construct();
product.show();
}
}
原文：https://www.cnblogs.com/ciyelc/p/13039366.html