Java常用设计模式（转载）

设计模式是编程解决实际问题或类似问题的最佳实践，Java编程中处处都是对象，对象需要创建，对象间需要相互调用，对象的模板是类，类与类需要相互关联引用，如何通用解决上述问题，经过长时间的编程实践总结出来的统筹方法就是设计模式，可以理解设计模式就是如何写出高效程序解决某类问题。

设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计模式的六大原则

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）

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

创建类模式

一、简单工厂模式
定义一接口，不同实现类完成不同功能，提供统一构造这些具体类的工厂类。

package com.test.demo;

public interface ISendMsg {
	public boolean sendMsg(String msg);
}


package com.test.demo;

public class SmsSendMsg implements ISendMsg{

	@Override
	public boolean sendMsg(String msg) {
		System.out.println("发送短信...");
		return true;
	}

}

package com.test.demo;

public class WeiXinSendMsg implements ISendMsg{

	@Override
	public boolean sendMsg(String msg) {
		System.out.println("发送微信...");
		return true;
	}

}



package com.test.demo;

public class SendMsgFactory {
	public static ISendMsg sendMsg(String type,String msg)
	{
		if("sms".equals(type))
		{
			ISendMsg send = new SmsSendMsg();
			return send;
		}
		if("weixin".equals(type))
		{
			ISendMsg send = new WeiXinSendMsg();
			return send;
		}
		return false;
	}
	
	public static void main(String[] args)
	{
		ISendMsg send1 = SendMsgFactory.sendMsg("weixin",);
		ISendMsg send2 = SendMsgFactory.sendMsg("sms");
	}
}

简单工厂类不能体现开闭原则，如果再增加一个发送邮件的实现类，需要修改工厂类

package com.test.demo;

public class MailSendMsg implements ISendMsg{

	@Override
	public boolean sendMsg(String msg) {
		System.out.println("发送微信...");
		return true;
	}

}

package com.test.demo;

public class SendMsgFactory {
	public static boolean sendMsg(String type,String msg)
	{
		if("sms".equals(type))
		{
			ISendMsg send = new SmsSendMsg();
			return send.sendMsg(msg);
		}
		if("weixin".equals(type))
		{
			ISendMsg send = new WeiXinSendMsg();
			return send.sendMsg(msg);
		}
		if("mail".equals(type))
		{
			ISendMsg send = new MailSendMsg();
			return send.sendMsg(msg);
		}
		return false;
	}
	
	public static void main(String[] args)
	{
		SendMsgFactory.sendMsg("weixin", "Hello WeiXin");
		SendMsgFactory.sendMsg("sms", "Hello ShortMsg");
	}
}

二、抽象工厂模式

通过添加工厂接口，相当于抽象工厂实现，当系统扩展时，需要设计具体实现类和对应的工厂实现

package com.test.demo;

public interface ISendMsg {
	public boolean sendMsg(String msg);
}

package com.test.demo;

public interface Provider {
	public ISendMsg create();
}

package com.test.demo;

public class SmsSendMsg implements ISendMsg{

	@Override
	public boolean sendMsg(String msg) {
		System.out.println("发送短信...");
		return true;
	}

}

package com.test.demo;

public class SmsFactory implements Provider{

	@Override
	public ISendMsg create() {
		return new SmsSendMsg();
	}

}

package com.test.demo;

public class WeiXinSendMsg implements ISendMsg{

	@Override
	public boolean sendMsg(String msg) {
		System.out.println("发送微信...");
		return true;
	}

}


package com.test.demo;

public class WeiXinFactory implements Provider{

	@Override
	public ISendMsg create() {
		return new WeiXinSendMsg();
	}

}

package com.test.demo;

public class MailSendMsg implements ISendMsg{

	@Override
	public boolean sendMsg(String msg) {
		System.out.println("发送微信...");
		return true;
	}

}

package com.test.demo;

public class MailFactory implements Provider{

	@Override
	public ISendMsg create() {
		return new MailSendMsg();
	}

}

package com.test.demo;

public class Tester {

	public static void main(String[] args)
	{
		Provider smsPvdr = new SmsFactory();
		smsPvdr.create().sendMsg("短信服务...");
		
		Provider wxPvdr = new WeiXinFactory();
		wxPvdr.create().sendMsg("微信服务...");
	}
}

三、单例模式
最安全实现单例模式是使用内部类

package com.test.demo;

public class Singleton {
	/* 私有构造方法，防止被实例化 */ 
	private Singleton() {
		
	}
	
	/* 此处使用一个内部类来维护单例 */ 
	private static class SingletonFactory {  
		private static Singleton instance = new Singleton();  
	}

	/* 获取实例 */  
	public static Singleton getInstance() {  
		return SingletonFactory.instance;  
	}
}

四、Builder模式
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

package com.test.demo;

public class HtmlPage {
	private String top = null;
	private String left = null;
	private String main = null;
	private String bottom = null;
	public String getTop() {
		return top;
	}
	public void setTop(String top) {
		this.top = top;
	}
	public String getLeft() {
		return left;
	}
	public void setLeft(String left) {
		this.left = left;
	}
	public String getMain() {
		return main;
	}
	public void setMain(String main) {
		this.main = main;
	}
	public String getBottom() {
		return bottom;
	}
	public void setBottom(String bottom) {
		this.bottom = bottom;
	}
	
	
}

package com.test.demo;

public interface IHtmlBuilder {
	public void buildTopPart();
	public void buildLeftPart();
	public void buildMainPart();
	public void buildBottomPart();
	
	public HtmlPage getPage();
}

package com.test.demo;

public class EasyuiBuilder implements IHtmlBuilder{
	private HtmlPage page = null;
	
	public EasyuiBuilder()
	{
		page = new HtmlPage();
	}

	@Override
	public void buildTopPart() {
		page.setTop("Easyui top part");
	}

	@Override
	public void buildLeftPart() {
		page.setLeft("Easyui left part");
	}

	@Override
	public void buildMainPart() {
		page.setMain("Easyui main part");
	}

	@Override
	public void buildBottomPart() {
		page.setBottom("Easyui bottom part");
	}

	@Override
	public HtmlPage getPage() {
		return page;
	}

}

package com.test.demo;

public class VueBuilder implements IHtmlBuilder{
	private HtmlPage page = null;
	
	public VueBuilder()
	{
		page = new HtmlPage();
	}

	@Override
	public void buildTopPart() {
		page.setTop("Vue top part");
	}

	@Override
	public void buildLeftPart() {
		page.setLeft("Vue left part");
	}

	@Override
	public void buildMainPart() {
		page.setMain("Vue main part");
	}

	@Override
	public void buildBottomPart() {
		page.setBottom("Vue bottom part");
	}

	@Override
	public HtmlPage getPage() {
		return page;
	}
}

package com.test.demo;

public class Director {
	private IHtmlBuilder builder = null;

	public void setBuilder(IHtmlBuilder builder) {
		this.builder = builder;
	}
	
	public void build()
	{
		builder.buildTopPart();
		builder.buildLeftPart();
		builder.buildMainPart();
		builder.buildBottomPart();
	}
	
	public HtmlPage getPage() {
		return builder.getPage();
	}
	
}

五、原型模式
该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

package com.test.demo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ProtoType implements Cloneable,Serializable{
	private static final long serialVersionUID = 2743227770097456357L;

	/* 浅复制 */  
	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();  
	}

}

结构型模式

适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
在这里插入图片描述

六、适配器模式
类适配器模式：扩展一个类的功能方法，通过继承这个类再实现一个接口

package com.test.demo;

public class SourceObj {
	public void method1()
	{
		System.out.println("method1...");
	}
}

package com.test.demo;

public interface Targetable {
	public void method1();
	public void method2();
}

package com.test.demo;

public class Adapter extends SourceObj implements Targetable{

	@Override
	public void method2() {
		System.out.println("method2...");
	}

}

package com.test.demo;

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

对象的适配器模式
基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承SourceObj类，而是持有Source类的实例，以达到解决兼容性的问题。

package com.test.demo;

public class SourceObj {
	public void method1()
	{
		System.out.println("method1...");
	}
}

package com.test.demo;

public interface Targetable {
	public void method1();
	public void method2();
}

package com.test.demo;

public class Adapter implements Targetable{
	private SourceObj source;
	
	public Adapter(SourceObj source)
	{
		this.source = source;
	}
	
	public void method1()
	{
		source.method1();
	}
	
	@Override
	public void method2() {
		System.out.println("method2...");
	}

}

七、装饰模式
装饰模式动态地给一个对象增加一些新的功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例

package com.test.demo;

public interface ILog {
	public void log(String msg);
}

package com.test.demo;

public class UserMng implements ILog{

	@Override
	public void log(String msg) {
		System.out.println("UserMng log...");
	}

}

package com.test.demo;

public class Decorator implements ILog{
	private UserMng umng = null;
	
	public Decorator(UserMng umng)
	{
		this.umng = umng;
	}

	@Override
	public void log(String msg) {
		System.out.println("before decorator!");  
		umng.log("Hello UserMng");  
		System.out.println("after decorator!"); 
	}

}

package com.test.demo;

public class DecoratorTest {

	public static void main(String[] args) {
		UserMng umng = new UserMng();
		Decorator deco = new Decorator(umng);
		deco.log("Hello");
	}

}

八、代理模式
代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

package com.test.demo;

public interface Sourceable {
	public void method();
}

package com.test.demo;

public class Source implements Sourceable{

	@Override
	public void method() {
		System.out.println("Source method invoke...");
	}

}
package com.test.demo;

package com.test.demo;

public class Proxy implements Sourceable{
	private Source source = null;
	
	public Proxy()
	{
		super();
		this.source = new Source();
	}

	@Override
	public void method() {
		System.out.println("before invoke");
		source.method();
		System.out.println("after invoke");
		
	}
}

package com.test.demo;

public class ProxyTest {

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

}

代理模式和装饰模式非常类似，甚至代码都类似。二者最主要的区别是：代理模式中，代理类对被代理的对象有控制权，决定其执行或者不执行。而装饰模式中，装饰类对代理对象没有控制权，只能为其增加一层装饰，以加强被装饰对象的功能，仅此而已。

九、Facade模式（门面模式）
隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用。

package com.test.demo;

public class CPU {
	public void startup(){  
		System.out.println("cpu startup!");  
	}  
	
	public void shutdown(){  
		System.out.println("cpu shutdown!");  
	}
}

package com.test.demo;

public class Disk {
	public void startup(){  
		System.out.println("memory startup!");  
	}  
	
	public void shutdown(){  
		System.out.println("memory shutdown!");  
	}
}

package com.test.demo;

public class Memory {
	public void startup(){  
		System.out.println("disk startup!");  
	}  
	
	public void shutdown(){  
		System.out.println("disk shutdown!");  
	}
}

package com.test.demo;

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!");  
	} 

}

package com.test.demo;

public class Test {

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

}

十、桥接模式
桥接模式（Bridge)是一种结构型设计模式。Bridge模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展。

package com.test.demo;

import java.sql.Connection;

public interface IGetConn {
	public Connection getConnection();
}

package com.test.demo;

import java.sql.Connection;

public abstract class Bridge {
	private IGetConn getconn;

	public IGetConn getGetconn() {
		return getconn;
	}

	public void setGetconn(IGetConn getconn) {
		this.getconn = getconn;
	}

	protected Connection getConnection()
	{
		return getconn.getConnection();
	}
}

package com.test.demo;

import java.sql.Connection;

public class MySqlConn implements IGetConn{

	@Override
	public Connection getConnection() {
		return null;
	}

}
package com.test.demo;

import java.sql.Connection;

public class OracleConn implements IGetConn{

	@Override
	public Connection getConnection() {
		return null;
	}

}
package com.test.demo;

import java.sql.Connection;

public class DetailBridge extends Bridge{
	protected Connection getConnection()
	{
		return super.getGetconn().getConnection();
	}
}

package com.test.demo;

public class BridgeTest {

	public static void main(String[] args) {
		Bridge bdg = new DetailBridge();
		
		//调用第一个实现类
		bdg.setGetconn(new MySqlConn());
		bdg.getConnection();
		
		//调用第二个实现类
		bdg.setGetconn(new OracleConn());
		bdg.getConnection();
	}

}

十一、组合模式
组合模式允许你将对象组合成树形结构来表现”部分-整体“的层次结构，使得客户以一致的方式处理单个对象以及对象的组合。

package com.test.demo;

import java.util.ArrayList;
import java.util.List;

public class TreeNode {
	private Integer id = null;
	private String name = null;
	private List<TreeNode> child = new ArrayList<TreeNode>();
	
	public TreeNode(String name)
	{
		this.name =name;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<TreeNode> getChild() {
		return child;
	}
	public void setChild(List<TreeNode> child) {
		this.child = child;
	}
	public void remove(TreeNode tn)
	{
		this.child.remove(tn);
	}
	public void add(TreeNode tn)
	{
		this.child.add(tn);
	}
}

package com.test.demo;

public class Tree {
	private String name = null;
	private TreeNode root = null;
	
	public Tree(String name)
	{
		this.name = name;
		root = new TreeNode(name);
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public TreeNode getRoot() {
		return root;
	}
	public void setRoot(TreeNode root) {
		this.root = root;
	}
	
}

行为模式

十二、观察者模式
在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。

package com.test.demo;

public interface Observerable {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObserver();
}

package com.test.demo;

public interface Observer {
	public void update(String message);
}

package com.test.demo;

import java.util.ArrayList;
import java.util.List;

public class MailServer implements Observerable{
	private List<Observer> list;
	private String msg = null;
	
	public MailServer()
	{
		list = new ArrayList<Observer>();
	}
	
	@Override
	public void registerObserver(Observer o) {
		list.add(o);
	}

	@Override
	public void removeObserver(Observer o) {
		list.remove(o);
	}

	@Override
	public void notifyObserver() {
		for(Observer o:list)
			o.update(msg);
	}

	public void setMsg(String msg)
	{
		this.msg = msg;
	}
}

package com.test.demo;

public class User implements Observer{
	private String name = null;
	
	public User(String name)
	{
		this.name = name;
	}

	@Override
	public void update(String message) {
		System.out.println(name + " 收到消息 msg="+message);
	}

}

package com.test.demo;

public class Tester {

	public static void main(String[] args) {
		MailServer mail = new MailServer();
		
		User u1 = new User("Java");
		mail.registerObserver(u1);
		
		User u2 = new User("Python");
		mail.registerObserver(u2);
		
		mail.setMsg("Hello All");
		mail.notifyObserver();
		
		mail.removeObserver(u2);
		
		mail.setMsg("It is fine day!");
		mail.notifyObserver();
	}

}

十三、责任链模式
责任链模式，有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。

package com.test.demo;

public interface Handler {
	public void operator();
}
package com.test.demo;

public abstract class AbstractHandler {
	private Handler handler;  
	
	public Handler getHandler() {  
		return handler;  
	}  
	
	public void setHandler(Handler handler) {  
		this.handler = handler;  
	}
}

package com.test.demo;

public class MyHandler extends AbstractHandler implements Handler{
	private String name;  
	
	public MyHandler(String name) {  
		this.name = name;  
	}  
	
	@Override  
	public void operator() {  
		System.out.println(name+"deal!");  
		if(getHandler()!=null){  
			getHandler().operator();  
		}  
	}
}

package com.test.demo;

public class Test {
	public static void main(String[] args) {  
		MyHandler h1 = new MyHandler("h1");  
		MyHandler h2 = new MyHandler("h2");  
		MyHandler h3 = new MyHandler("h3");  
		
		h1.setHandler(h2);  
		h2.setHandler(h3);  
		
		h1.operator();  
	}
}

转自：https://blog.csdn.net/qixiang_chen/article/details/88381325?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~first_rank_v2~rank_v25-13-88381325.nonecase&utm_term=java%E6%B6%88%E6%81%AF%E4%B8%AD%E5%BF%83%E8%AE%BE%E8%AE%A1