java — 设计模式

　　

　　设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

　　

一、设计模式的分类

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：

二、设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。

三、Java中具体的设计模式

　

1.简单工厂模式（Simple Factory）

　　根据提供给它的参数，返回的是几个可能产品中的一个类的实例。

　　

①Sender接口

package No1_SimpleFactory;

public interface Sender {
	public void send();

}

　　接口中定义了一个Send 方法。

②MailSender类，实现了Sender接口

package No1_SimpleFactory;

public class MailSender implements Sender
{
	public void send()
	{
		System.out.println("发送邮件");
	}

}

③MessageSender类，实现了Sender接口

package No1_SimpleFactory;

public class MessageSender implements Sender
{
	public void send()
	{
		System.out.println("发送短信 ");
	}

}

④创建SendFactory工厂类

package No1_SimpleFactory;

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

}

　　在SendFactory中定义了一个Sender类型的方法produce()，这个方法可以根据提供给它的参数，返回一个Sender类型的实例。

⑤测试

package No1_SimpleFactory;

public class SimpleFactoryTest
{
	public static void main(String[] args)
	{
		SendFactory factory = new SendFactory();
		Sender sender1 = factory.produce("mail");
		sender1.send();
	}
}

输出的结果为：

发送邮件
发送短信

2.多个工厂方法模式

　　在普通工厂模式中，如果传递的字符串出错，则不能创建对象，而多个工厂方法模式提供多个工厂方法，分别创建对象：

　　接口和连个实现接口的类保持不变。

④SendFactoy类

package No2_duogeFactory;

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

	public Sender produceMessage()
	{
		return new MessageSender();
	}

}

　　提供了多个工厂方法，用来分别创建对象。

⑤测试

package No2_duogeFactory;

public class FactoryTest
{
	public static void main(String[] args)
	{
		SendFactory factory = new SendFactory();
		Sender sender = factory.produceMail();
		sender.send();
		Sender sender1 = factory.produceMessage();
		sender1.send();
	}

}

输出结果：

发送邮件
发送短信

3.静态工厂模式

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

①②③接口和连个实现接口的类保持不变。

④SendFactory类

package No2_duogeFactory;

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

	public Sender produceMessage()
	{
		return new MessageSender();
	}
}

⑤测试

package No2_duogeFactory;

public class FactoryTest
{
	public static void main(String[] args)
	{
		SendFactory factory = new SendFactory();
		Sender sender = factory.produceMail();
		sender.send();
		Sender sender1 = factory.produceMessage();
		sender1.send();
	}
}

　　这三种工厂方式比较起来，大多数情况下，会选择静态工厂方法模式。

4.抽象工厂模式（Abstract Factory）

　　工厂模式存在的问题：类的创建依赖工厂类，如果需要拓展程序，就需要对工厂类进行修改，违背了闭包原则，所以抽象工厂模式，创建多个工厂类，这样一旦新增加功能，直接增加新的工厂类即可，不需要修改之前的代码。

　　

①Sender接口

public interface Sender
{
	public void Send();
}

②MailSender类实现这个接口

public class MailSender implements Sender
{
	public void Send()
	{
		System.out.println("发送邮件");
	}
}

　　

③MessageSender类实现这个接口

public class MessageSender implements Sender
{
	public void Send()
	{
		System.out.println("发送短信");
	}
}

　　

④ Provider类接口，包含以Sender作为返回类型的方法

public interface Provider
{
	public Sender produce();
}

⑤SenderMailFactory类实现这个接口，返回一个MailSender的实例

public class SendMailFactory implements Provider
{
	public Sender produce()
	{
		return new MailSender();
	}
}

　　

⑥SenderMessageFactory类实现这个接口，返回一个MessageSender的实例

public class SendMessageFactory implements Provider
{
	public Sender produce()
	{
		return new MessageSender();
	}
}

⑦测试

public class FactoryTest
{
	public static void main(String[] args)
	{
		Provider provider = new SendMailFactory();
		Sender sender = provider.produce();
		sender.Send();
	}
}

输出结果：

发送邮件

5.单例模式（Singleton）

　　单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。

　　1.某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销；

　　2.省去了new操作符，降低了系统内存的使用频率，减轻GC压力；

　　3.有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统会混乱，所以只能使用单例模式，才能保证核心交易服务器独立控制整个流程。

①最简单的单例模式的类

public class Singleton
{
	private static Singleton instance = null;

	private Singleton(){
	}

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

	public Object readResolve()
	{
		return instance;
	}
}

　　这是最简单的单例模式的类，但是没有线程安全保护，如果放入到多线程的环境中，会出现问题，为了解决这个问题，对getInstance方法加上synchronized关键字。

②对getInstance加上synchronized关键字

public class Singleton_syn
{
	//持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载
	public static Singleton_syn instance = null;

	//私有构造方法，防止被实例化
	private Singleton_syn(){
	}

	public static synchronized Singleton_syn getInstance()
	{
		if(instance == null)
		{
			instance = new Singleton_syn();
		}
		return instance;
	}

	public Object readResolve()
	{
		return instance;
	}
}

　　使用synchronized关键字锁住的是这个对象，这样的用法在性能上会下降，因为每次调用getInstance()方法的时候，都会对对象上锁。事实上，只有在第一次创建对象的时候需要枷锁，之后不需要，所以，在此处需要进行改动。