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 child = new ArrayList();
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 getChild() {
return child;
}
public void setChild(List 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 list;
private String msg = null;
public MailServer()
{
list = new ArrayList();
}
@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();
}
}