1、工厂方法模式（Factory Method）
工厂方法模式分为三种：
1.1、普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：
package com.designtype.factory.factory1;
public class MailSend implements Sender {
@Override
public void send() {
System.out.println("mail send factory1");
}
}
package com.designtype.factory.factory1;
public interface Sender {
public void send();
}
package com.designtype.factory.factory1;
public class SendFactory {
public void send(String type){
if(type.equalsIgnoreCase("sms")){
SmsSend smsSend= new SmsSend();
smsSend.send();
}else if(type.equalsIgnoreCase("mail")){
MailSend mailSend = new MailSend();
mailSend.send();
}
}
}
package com.designtype.factory.factory1;
public class SmsSend implements Sender {
@Override
public void send() {
System.out.println("sms send factory1");
}
}
1.2、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。关系图：
package com.designtype.factory.factory2;
import com.designtype.factory.factory1.Sender;
public class MailSend implements Sender {
@Override
public void send() {
System.out.println("mail send factory2" );
}
}
package com.designtype.factory.factory2;
public interface Sender {
public void send();
}
package com.designtype.factory.factory2;
public class SendFactory2 {
public static MailSend produceMailSend(){
return new MailSend();
}
public static SmsSend produceSmsSend(){
return new SmsSend();
}
}
package com.designtype.factory.factory2;
public class SmsSend implements Sender {
@Override
public void send() {
System.out.println("sms send factory2");
}
}
2、抽象工厂模式（Abstract Factory）
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
package com.designtype.factory.factory3;
import com.designtype.factory.factory1.Sender;
public class SmsSendFactory implements Provider{
@Override
public Sender makeSender() {
return new SmsSend3();
}
}
package com.designtype.factory.factory3;
import com.designtype.factory.factory1.Sender;
public class SmsSend3 implements Sender {
@Override
public void send() {
System.out.println("sms send factory3");
}
}
package com.designtype.factory.factory3;
public interface Sender {
public void send();
}
package com.designtype.factory.factory3;
import com.designtype.factory.factory1.Sender;
public interface Provider {
public Sender makeSender();
}
package com.designtype.factory.factory3;
import com.designtype.factory.factory1.Sender;
public class MailSendFactory implements Provider {
@Override
public Sender makeSender() {
return new MailSend3();
}
}
package com.designtype.factory.factory3;
import com.designtype.factory.factory1.Sender;
public class MailSend3 implements Sender {
@Override
public void send() {
System.out.println("mail send factory3" );
}
}
package com.designtype.factory;
import com.designtype.factory.factory1.SendFactory;
import com.designtype.factory.factory1.Sender;
import com.designtype.factory.factory2.SendFactory2;
import com.designtype.factory.factory3.MailSendFactory;
import com.designtype.factory.factory3.Provider;
//测试中心
public class TestCenter {
public static void main(String[] args) {
//factory1
SendFactory sendFactory = new SendFactory();
sendFactory.send("mail");
//factory2
Sender sender = SendFactory2.produceMailSend();
sender.send();
//factory3
Provider provider = new MailSendFactory();
Sender send3 = provider.makeSender();
send3.send();
}
}
其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！
3.创建者模式（builder）
将重要的动作抽象出来，形成单独的方法。抽象工厂注重的是不同的工厂生产不同的产品，builder注重的是某个产品由不同的零件组成，产品的生产工程。
Director就是负责产品组装的，是控制生产过程的；而builder是负责产品部件生产的。这样就实现了“过程”和“部件”的解耦。
抽象工厂通过不同的构建过程生成不同的对象表示，而Builder模式通过相同的构建过程生成不同的表示。
4、原型模式（Prototype）
原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。
5. 单例模式（single）
多个程序共享一个对象的形式，该对象一般用静态的构造方法以实现缓存的目标。
package com.designtype.singleton.hurgury;
/**
* 饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
* @Author : liyang
* Description
*/
public class Singleton2 {
private Singleton2(){}
private static final Singleton2 sigletone = new Singleton2();
public static final Singleton2 getInstance() {
System.out.println("this is singletone2 hurgery");
return sigletone;
}
}
package com.designtype.singleton.lazymode;
/**
* 懒汉单例
* @Author : liyang
* Description
*/
public class Singleton {
private Singleton(){
}
private static Singleton singleton = null;
// 线程不安全的，并发环境下很可能出现多个Singleton实例 加上synchronized避免
public static synchronized Singleton getInstance() {
if (singleton == null) {
System.out.println("singleton new ..");
return new Singleton();
}
return singleton;
}
}
package com.designtype.singleton.lazymode;
public class Singleton1 {
private static class LazyHolder {
private static final Singleton1 INSTANCE = new Singleton1();
}
private Singleton1 (){}
public static final Singleton1 getInstance() {
System.out.println("优于 singleton");
return LazyHolder.INSTANCE;
}
}
package com.designtype.singleton;
import com.designtype.singleton.hurgury.Singleton2;
import com.designtype.singleton.lazymode.Singleton;
import com.designtype.singleton.lazymode.Singleton1;
public class TestCenter {
public static void main(String[] args) {
//lazymode
Singleton.getInstance();
Singleton1.getInstance();
//hurgery
Singleton2.getInstance();
}
}
6.外观模式（Facade）
为子系统中的一组接口提供一个统一接口。Facade模式定义了一个高层接口，这个接口使得这子系统更容易使用。
jdbc应用典型实例
7.适配器模式（Adapter Pattern）
主要用于两个接口之间的适配，就是中间做个转换 的意思。
（更新中。。。）