创建型设计模式，顾名思义，它是Java用来创建对象的结构

目录

单例模式

简单工厂模式

抽象工厂模式

生成器模式

原型模式

单例模式

单例模式确保一个类的对象只能再类本省创建，外部类不可调用此类的构造函数来创建对象，示例如下：

/**
 * 单例设计模式
 * @author Swing
 */
public class Test {
    //make constructor private
    private Test(){
        System.out.println("I am a test");
    }
    //static function to return a instance
    public static Test getInstance(){
        return new Test();
    }
    public static void main(String[] args) {
        Test test=Test.getInstance();
    }
}


简单工厂模式



/**
 * 宠物接口
 */
interface Pet {
    void color();
}

/**
 * 工厂模式
 *
 * @author Swing
 */
public class Test {
    public static void main(String[] args) {
        Pet petRabbit = PetFactory.getPet("Rabbit");
        petRabbit.color();
        Pet petDog = PetFactory.getPet("dog");
        petDog.color();
        Pet petCat = PetFactory.getPet("cat");
        petCat.color();
    }
}

/**
 * 兔子类
 */
class Rabbit implements Pet {
    @Override
    public void color() {
        System.out.println("I am a white Rabbit");
    }
}

/**
 * 小狗类
 */
class Dog implements Pet {
    @Override
    public void color() {
        System.out.println("I am a yellow Dog");
    }
}

/**
 * 小猫类
 */
class Cat implements Pet {
    @Override
    public void color() {
        System.out.println("I am a black Cat");
    }
}

/**
 * 宠物工厂
 */
class PetFactory {
    public static Pet getPet(String petName) {
        if (petName == null) return null;
        if (petName.equalsIgnoreCase("rabbit")) return new Rabbit();
        else if (petName.equalsIgnoreCase("dog")) return new Dog();
        else if (petName.equalsIgnoreCase("cat")) return new Cat();
        return null;
    }
}



 

抽象工厂模式

抽象工厂模式又称工厂的工厂，使用一个抽象工厂来创建多个工厂，每个工厂再生产它对应的产品，一上面的例子为基础，假设宠物工厂还有上级部门，叫做动物组织，动物组织旗下还有一个与宠物工厂平级的部门叫做野生动物工厂，则此时设计模式应优化为



代码示例：

/**
 * 宠物接口
 */
interface Pet {
    void color();
}

/**
 * 野生动物接口
 */
interface Wild {
    void eat();
}

/**
 * 动物组织接口
 */
interface AnimalOrganization {
    Pet getPet(String petName);

    Wild getWild(String wildName);
}

/**
 * 抽象工厂模式
 *
 * @author Swing
 */
public class Test {
    public static void main(String[] args) {
        //获取宠物工厂
        AnimalOrganization petFactory = AnimalOrganizationFactory.getAnimalOrganization("PetFactory");
        //获取野生动物工厂
        AnimalOrganization wildFactory = AnimalOrganizationFactory.getAnimalOrganization("WildFactory");
        petFactory.getPet("rabbit").color();
        petFactory.getPet("dog").color();
        petFactory.getPet("cat").color();
        wildFactory.getWild("tiger").eat();
        wildFactory.getWild("elephant").eat();
        wildFactory.getWild("shark").eat();
    }
}

/**
 * 兔子类
 */
class Rabbit implements Pet {
    @Override
    public void color() {
        System.out.println("I am a white Rabbit");
    }
}

/**
 * 小狗类
 */
class Dog implements Pet {
    @Override
    public void color() {
        System.out.println("I am a yellow Dog");
    }
}

/**
 * 小猫类
 */
class Cat implements Pet {
    @Override
    public void color() {
        System.out.println("I am a black Cat");
    }
}

/**
 * 老虎类
 */
class Tiger implements Wild {
    @Override
    public void eat() {
        System.out.println("I am a tiger,i eat meat");
    }
}

/**
 * 大象类
 */
class Elephant implements Wild {
    @Override
    public void eat() {
        System.out.println("I am a tiger,i eat grass");
    }
}

/**
 * 鲨鱼类
 */
class Shark implements Wild {
    @Override
    public void eat() {
        System.out.println("I am a shark,i eat fish");
    }
}

/**
 * 宠物工厂
 */
class PetFactory implements AnimalOrganization {
    public Pet getPet(String petName) {
        if (petName == null) return null;
        else if (petName.equalsIgnoreCase("rabbit")) return new Rabbit();
        else if (petName.equalsIgnoreCase("dog")) return new Dog();
        else if (petName.equalsIgnoreCase("cat")) return new Cat();
        return null;
    }

    @Override
    public Wild getWild(String wildName) {
        return null;
    }
}

/**
 * 野生动物工厂
 */
class WildFactory implements AnimalOrganization {
    @Override
    public Pet getPet(String petName) {
        return null;
    }

    @Override
    public Wild getWild(String wildName) {
        if (wildName == null) return null;
        else if (wildName.equalsIgnoreCase("tiger")) return new Tiger();
        else if (wildName.equalsIgnoreCase("elephant")) return new Elephant();
        else if (wildName.equalsIgnoreCase("shark")) return new Shark();
        return null;
    }
}

/**
 * 动物组织工厂
 */
class AnimalOrganizationFactory {
    public static AnimalOrganization getAnimalOrganization(String animalOrganizationName) {
        if (animalOrganizationName == null) return null;
        else if (animalOrganizationName.equalsIgnoreCase("PetFactory")) return new PetFactory();
        else if (animalOrganizationName.equalsIgnoreCase("WildFactory")) return new WildFactory();
        return null;
    }
}



生成器模式

此模式就是先创建一些简单的对象，然后再用这些简单的对象组装成复杂的对象，依次上推，形成更复杂的对象，其中再Swing窗口设计时常用这种模式，举个简单的例子：

代码示例：

import javax.swing.*;
import java.awt.*;

/**
 * 朱窗口类
 */
public class Test extends JFrame {
    MainPanel mainPanel=new MainPanel();
    public static void main(String[] args) {
        Test test=new Test();
        test.setDefaultCloseOperation(EXIT_ON_CLOSE);
        test.setBounds(0,0,330,200);
        Container container=test.getContentPane();
        container.add(test.mainPanel);
        test.setVisible(true);
    }
}

/**
 * 主面板类
 */
class MainPanel extends JPanel{
    JButton jButton=new JButton("QQ号：");
    JTextField jTextField=new JTextField("2650312797  加个朋友呗！");
    public MainPanel(){
        this.setLayout(null);//绝对布局
        jButton.setBounds(100,20,100,30);
        this.add(jButton);
        jTextField.setBounds(70,70,160,30);
        this.add(jTextField);
    }
}



原型模式

如果创建一个对象比较麻烦，我们可以使类实现Cloneable接口，并重写clone()方法，实现对象的复制

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        People people = new People(12, "Jack");
        People clonePeople = (People) people.clone();
        System.out.println(people.equals(clonePeople));
        System.out.println(people.toString());
        people.setName("Mike");
        System.out.println(clonePeople.toString());
        System.out.println(people.toString());
    }
}

/**
 * 可克隆的类，Object类本身并不实现接口Cloneable ，因此在类别为Object的对象上调用clone方法将导致运行时抛出异常
 * 所有数组都被认为是实现接口Cloneable ，并且数组类型T[]的clone方法的返回类型是T[]
 */
class People implements Cloneable {
    int id;
    String name;

    public People(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "People{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}



 

 

本文继续介绍23种设计模式系列之单例模式。

概念：

　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。

　　单例模式有以下特点：

　　1、单例类只能有一个实例。

　　2、单例类必须自己创建自己的唯一实例。

　　3、单例类必须给所有其他对象提供这一实例。
　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。



一、懒汉式单例

 

//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

 

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全，如果你第一次接触单例模式，对线程安全不是很了解，可以先跳过下面这三小条，去看饿汉式单例，等看完后面再回头考虑线程安全的问题：

 

1、在getInstance方法上加同步

 

public static synchronized Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
}

 

 

 

2、双重检查锁定

 

public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
    }

 

3、静态内部类

 

public class Singleton {  
    private static class LazyHolder {  
       private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}  

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

 

 

 

 

 

 

二、饿汉式单例

 

//饿汉式单例类.在类初始化时，已经自行实例化 
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

 

 

 

 

三、登记式单例(可忽略)

//类似Spring里面的方法，将类名注册，下次从里面直接获取。
public class Singleton3 {
    private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
    static{
        Singleton3 single = new Singleton3();
        map.put(single.getClass().getName(), single);
    }
    //保护的默认构造子
    protected Singleton3(){}
    //静态工厂方法,返还此类惟一的实例
    public static Singleton3 getInstance(String name) {
        if(name == null) {
            name = Singleton3.class.getName();
            System.out.println("name == null"+"--->name="+name);
        }
        if(map.get(name) == null) {
            try {
                map.put(name, (Singleton3) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
    //一个示意性的商业方法
    public String about() {    
        return "Hello, I am RegSingleton.";    
    }    
    public static void main(String[] args) {
        Singleton3 single3 = Singleton3.getInstance(null);
        System.out.println(single3.about());
    }
}

 登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，然后返回。 

这里我对登记式单例标记了可忽略，我的理解来说，首先它用的比较少，另外其实内部实现还是用的饿汉式单例，因为其中的static方法块，它的单例在类被装载的时候就被实例化了。

 

饿汉式和懒汉式区别

从名字上来说，饿汉和懒汉，

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

另外从以下两点再区分以下这两种方式：

 

1、线程安全：

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。



 

2、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

至于1、2、3这三种实现又有些区别，

第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的，

第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。

 

什么是线程安全？

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

或者说：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。

 

应用

以下是一个单例类使用的例子，以懒汉式为例，这里为了保证线程安全，使用了双重检查锁定的方式：

 

public class TestSingleton {
	String name = null;

        private TestSingleton() {
	}

	private static volatile TestSingleton instance = null;

	public static TestSingleton getInstance() {
           if (instance == null) {  
             synchronized (TestSingleton.class) {  
                if (instance == null) {  
                   instance = new TestSingleton(); 
                }  
             }  
           } 
           return instance;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void printInfo() {
		System.out.println("the name is " + name);
	}

}

可以看到里面加了volatile关键字来声明单例对象，既然synchronized已经起到了多线程下原子性、有序性、可见性的作用，为什么还要加volatile呢，原因已经在下面评论中提到，

还有疑问可参考http://www.iteye.com/topic/652440

和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

 

 

 

public class TMain {
	public static void main(String[] args){
		TestStream ts1 = TestSingleton.getInstance();
		ts1.setName("jason");
		TestStream ts2 = TestSingleton.getInstance();
		ts2.setName("0539");
		
		ts1.printInfo();
		ts2.printInfo();
		
		if(ts1 == ts2){
			System.out.println("创建的是同一个实例");
		}else{
			System.out.println("创建的不是同一个实例");
		}
	}
}


 运行结果：



结论：由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点，不管它实现何种功能，整个应用程序都会同享一个实例对象。

对于单例模式的几种实现方式，知道饿汉式和懒汉式的区别，线程安全，资源加载的时机，还有懒汉式为了实现线程安全的3种方式的细微差别。

更多设计模式：23种设计模式系列



作者：jason0539

博客：http://blog.csdn.net/jason0539（转载请说明出处）

创建型设计模式：关注对象的创建

单例模式：对象的唯一

用变量存储对象，直接返回内存对象

原型模式：对象创建不走构造函数
SingletonPrototype prototype = (SingletonPrototype)_SingletonPrototype.MemberwiseClone();//内存copy

工厂模式：顾名思义用的很多管理对象的创建

一、创建型模式
 
在软件工程中，创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。
基本的对象创建方式可能会导致设计上的问题，或增加设计的复杂度。创建型模式通过以某种方式控制对象的创建来解决问题。
 
创建型模式由两个主导思想构成：
一是将系统使用的具体类封装起来；二是隐藏这些具体类的实例创建和结合的方式。
 
创建型模式又分为对象创建型模式和类创建型模式。
对象创建型模式处理对象的创建，类创建型模式处理类的创建。详细地说，对象创建型模式把对象创建的一部分推迟到另一个对象中，而类创建型模式将它对象的创建推迟到子类中。
 
创建型模式旨在将系统与它的对象创建、结合、表示的方式分离。这些设计模式在对象创建的类型、主体、方式、时间等方面提高了系统的灵活性。
 
创建型模式增强了对象和类之间的独立性。
 
在以下情况中，可以考虑应用创建型模式：
一个系统需要和它的对象和产品的创建相互独立。
一组相关的对象被设计为一起使用。
隐藏一个类库的具体实现，仅暴露它们的接口。
创建独立复杂对象的不同表示。
一个类希望它的子类实现它所创建的对象。
类的实例化在运行时才指定。
一个类只能有一个实例，而且这个实例能在任何时候访问到。
实例应该能在不修改的情况下具有可扩展性。
 
二、列举五大创建型设计模式
 
工厂方法模式和抽象工厂模式具体见《比较工厂三姐妹》。
 
1、工厂方法模式（Factory Method）（略）
2、抽象工厂模式（Abstract Factory）（略）
 
3、建造者模式（Builder）
 
建造者模式：将一个产品的内部表象与产品的生成过程分割开了，可以使一个建造过程生成具有不同的内部表象的产品对象。简而言之，将一个复杂对象的创建与它的表示分离，使同样的创建过程可以创建不同的表示。
 
结构图：

举例：建造小人（《大话设计模式》中的例子）
 
优缺点：采用建造者模式可以轻松地改变产品的内部表示。建造者模式将构造代码和表示代码分开。建造过程可以更精细地控制，生成器模式强调的是产品的构造过程，产品各部分具有依赖关系非常重要。需要注意的是，不同建造器产生的对象可能不属于同一类型，因此使用生成器的客户必须知道产品的具体类型。这意味着建造器经常不能互换，不同的建造器针对的客户程序也不相同。
注：与抽象工厂模式的比较：建造者模式关注于将构造对象的过程和构造的各个部分分开，而抽象工厂关注于构建一个产品系列。实际上，最大的区别是生成器模式创建的产品不一定有共同的父类，只要有类似的构造过程即可。实际上我们常见到的文件资源管理器的实现完全可以使用建造者模式。
建造者模式和工厂模式很相象，但是它们有很明显的区别。那就是工厂模式只是根据给的参数不同，工厂"生产"并返回不同的对象。建造者模式除了根据不同参数"生产"不同对象外，这些不同的对象还包含着不同的数据。建造者模式比工厂模式复杂就复杂在多"数据"这一部分。
4、单例模式（Singleton）
 
单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
 
结构图：

举例：有些类也需要计划生育。（《大话设计模式》中的例子）
 
优点：对唯一实例的受控访问。
缩小名空间。
 
注：单例提供了全局惟一的访问入口，因此易于控制可能发生的冲突。
与全局变量的比较：单例模式维护自身的实例化，在使用时是安全的。一个全局对象无法自行维护，也就无法避免重复创建多个实例，系统资源会被大量占用。更糟糕的是在很多情况下会出现逻辑问题，当这些对象访问相同的资源（例如串口时）时，会发生访问冲突。
 
5、原型模式（Prototype）
 
原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。子类实现克隆。
 
结构图：

举例：复印简历（《大话设计模式》中的例子）
优点：引入Prototype模式后不再需要一个与具体产品等级结构平行的工厂方法类，减少了类的构造，同时客户程序可以在运行时刻建立和删除原型（自定义界面时，此点尤其重要）。
此处引入的知识点式浅拷贝与深拷贝的问题：
 
浅拷贝(Shallow Copy影子克隆)：只复制对象的基本类型,对象类型,仍属于原来的引用。
深拷贝(Deep Copy 深度克隆)：不紧复制对象的基本类,同时也复制原对象中的对象.完全产生新对象。
 
差别就是在对于引用类型的实现深拷贝和浅拷贝的时候的机制不同，前者是MemberwiseClone 方法实现，后者是通过继承实现ICloneable接口中提供的Clone方法，实现对象的深拷贝。
 
注：原型模式同工厂模式，同样对客户隐藏了对象的创建工作，但是，与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的，达到了"隔离类对象的使用者和具体类型（易变类）之间的耦合关系"的目的。
 
本文链接：http://blog.csdn.net/caozhangyingfei0109/article/details/8608240
本文作者：廊坊师范学院信息技术提高班九期张薄