23种设计模式慢慢来自我理解_慢谈设计模式-优快云博客

本文深入解析了工厂方法、抽象工厂、单例等十种经典设计模式，并提供了详细的代码示例，帮助读者理解每种模式的应用场景及其优势。

http://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

一、工厂方法模式（大多数建议第三种）

1、普通工厂模式：就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建

public class SendFactory {
public Sender produce(String type) {
if ("mail".equals(type)) {
return new MailSender();
} else if ("sms".equals(type)) {
return new SmsSender();
} else {
System.out.println("请输入正确的类型!");
return null;
}
}
}

2、多个工厂方法模式：普通工厂模式的改进，普通工厂方法中如果传递字符串出错，则不能正确的创建对象；工厂方法模式是提供多个工厂方法，分别创建对象

public class SendFactory {

public Sender produceMail(){

return new MailSender();
}
public Sender produceSms(){
return new SmsSender();
}
}

3、静态工厂方法模式：将上面的多个工厂模式里的方法置为静态的，不需要创建实例，直接调用即可

public class SendFactory {
public static Sender produceMail(){
return new MailSender();
}
public static Sender produceSms(){
return new SmsSender();
}
}

二、抽象工厂模式：（避免了像工厂方法模式，如果拓展就要改工厂类）这个就是分两步， 1 定义一个造工厂的对象接口，让类实现

2 再定义造出对象干什么事情的接口，让类实现

public class Test {
public static void main(String[] args) {
Provider provider = new SendMailFactory(); //对象工厂
Sender sender = provider.produce(); //工厂造出对象
sender.Send(); //对象干对应的事情
}
}

三、单例模式：目的是保证在 JVM中保证该对象只有一个实例存在这样可以节省资源，减轻GC压力（紧介绍我认为最优的模式）

public class SingletonTest {
private static SingletonTest instance = null;
private SingletonTest() {
}
private static synchronized void syncInit() {
if (instance == null) {
instance = new SingletonTest();
}
}
public static SingletonTest getInstance() {
if (instance == null) {
syncInit();
}
return instance;
}
}

四、建造者模式：工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属

性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的

public class Builder {
private List<Sender> list = new ArrayList<Sender>();
public void produceMailSender(int count){
for(int i=0; i<count; i++){
list.add(new MailSender());
}
}
public void produceSmsSender(int count){
for(int i=0; i<count; i++){
list.add(new SmsSender());
}
}
}
测试类：
1. public class Test {
3. public static void main(String[] args) {
4. Builder builder = new Builder();
5. builder.produceMailSender(10);
6. }
7. }

五、原型模式：该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是

通过clone()实现的，先创建一个原型类

很简单，一个原型类，只需要实现Cloneable接口，覆写clone方法，此处clone方法可以改成任意的名称，因为Cloneable接口是个空接口，你可以任意定义实现类的方法名，如cloneA或者cloneB，因为此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法，而在Object类中，clone()是native的

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底

此处，写一个深浅复制的例子：

public class Prototype implements Cloneable, Serializable {
private static final long serialVersionUID = 1L;
private String string;
private SerializableObject obj;
/* 浅复制 */
public Object clone() throws CloneNotSupportedException {
Prototype proto = (Prototype) super.clone();
return proto;
}
/* 深复制 */
public Object deepClone() throws IOException, ClassNotFoundException {
/* 写入当前对象的二进制流 */
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
/* 读出二进制流产生的新对象 */
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
public SerializableObject getObj() {
return obj;
}
public void setObj(SerializableObject obj) {
this.obj = obj;
}
}
class SerializableObject implements Serializable {
private static final long serialVersionUID = 1L;
}

六、适配模式

1、类的适配模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

（接口A 有两个b 、c 两个方法，A的实现类B实现A的b方法，没有实现A的c方法因为B继承了C类，C类中有c方法）

public class AdapterTest {
public static void main(String[] args) {
Targetable target = new Adapter();
target.method1();
target.method2();
}
}

2、对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就

行。

（接口A 有两个b 、c 两个方法，A的实现类B实现A的b 、c 方法，但B类中有C类的实例对象，实现的 c 方法中具体是C类对象的方法）

3、接口适配器模式：借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，

所以我们写一个类，继承该抽象类，重写我们需要的方法就行

（避免一个类要是实现其实现接口的所有方法）

public class WrapperTest {
public static void main(String[] args) {
Sourceable source1 = new SourceSub1();
Sourceable source2 = new SourceSub2();
source1.method1();
source1.method2();
source2.method1();
source2.method2();
}
}

7、装饰模式：顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例

public class Decorator implements Sourceable {
private Sourceable source;
public Decorator(Sourceable source){
super();
this.source = source;
}
@Override
public void method() {
System.out.println("before decorator!");
source.method();
System.out.println("after decorator!");
}
}

测试类：

public class DecoratorTest {
public static void main(String[] args) {
Sourceable source = new Source();
Sourceable obj = new Decorator(source);
obj.method();
}
}

八、代理模式：代理模式就是多一个代理类出来，替原对象进行一些操作（想先AOP 切面就容易理解了，其实也类似装饰模式）

public class Proxy implements Sourceable {
private Source source;
public Proxy(){
super();
this.source = new Source();
}
@Override
public void method() {
before();
source.method();
atfer();
}
private void atfer() {
System.out.println("after proxy!");
}
private void before() {
System.out.println("before proxy!");
}
}

测试类：

public class ProxyTest {

public static void main(String[] args) {
Sourceable source = new Proxy();
source.method();
}
}

输出：

before proxy!
the original method!
after proxy!

九、外观模式：外观模式是为了解决类与类之家的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，

而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口

（其实就是将多个类及类的方法整合到一个类中同一管理，下面举例：电脑的启动关闭（cup，内存，硬盘））

public class Computer {
private CPU cpu;
private Memory memory;
private Disk disk;
public Computer(){
cpu = new CPU();
memory = new Memory();
disk = new Disk();
}
public void startup(){
System.out.println("start the computer!");
cpu.startup();
memory.startup();
disk.startup();
System.out.println("start computer finished!");
}
public void shutdown(){
System.out.println("begin to close the computer!");
cpu.shutdown();
memory.shutdown();
disk.shutdown();
System.out.println("computer closed!");
}
}

User类如下：

public class User {
public static void main(String[] args) {
Computer computer = new Computer();
computer.startup();
computer.shutdown();
}
}

输出：

start the computer!
cpu startup!
memory startup!
disk startup!
start computer finished!
begin to close the computer!
cpu shutdown!
memory shutdown!
disk shutdown!
computer closed!

十、桥接模式： 将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，

在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，

每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。