常用设计模式
Posted 技术很low的瓜贼
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了常用设计模式相关的知识，希望对你有一定的参考价值。
文章目录
JAVA常用设计模式
一、概念：
- 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结
二、分类：
- 创建型模式：单例设计模式，工厂方法模式，抽象工厂模式…
- 结构型模式：装饰器模式，代理模式…
- 行为型模式：模板设计模式…
三、模式:
1.单例设计模式
- 该模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象
- 懒汉式
package 设计模式.单例模式;
/**
* 单例设计模式
* 懒汉式写法
*/
public class Singleton
// 2.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
private static Singleton sin = null;
// 1.私有化构造方法，使用private关键字进行修饰
private Singleton()
/**
* 懒汉式存在线程同步问题，建议使用饿汉式
* @return
*/
// 3.提供共有的get方法负责将上述对象返回出去，使用public static关键字修饰
public static /*synchronized*/ Singleton getInstance()
/*synchronized (Singleton.class)
if (null != sin)
sin = new Singleton();
return sin;
*/
// 优化代码
if (null == sin)
synchronized (Singleton.class)
if (null != sin)
sin = new Singleton();
return sin;
- 饿汉式
package 设计模式.单例模式;
/**
* 单例设计模式
* 饿汉式
*/
public class Singleton2
// 2.声明本类类型的引用指向本类类型的对象，并直接加载
private static Singleton2 sin2 = new Singleton2();
// 1.私有化构造方法使用private关键字修饰
private Singleton2()
// 3.提供公有的get方法返回上述对象，使用public static关键字修饰
public static Singleton2 getInstance()
return sin2;
2.普通工厂模式
- 普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建
- 类图结构
- 代码：
package 设计模式.普通工厂模式;
/**
* 普通工厂方法模式就是建立一个工厂类，对实现了统一接口的不同实现类进行实例的创建
* 缺点：如果传递的字符串出现错误，不能正确的创建对象，而且可能出现空指针异常
*/
public class SendFactory
public Sender produce(String type)
if ("mail".equals(type))
return new MailSender();
if ("sms".equals(type))
return new SmsSender();
return null;
package 设计模式.普通工厂模式;
public interface Sender
void send();
package 设计模式.普通工厂模式;
public class MailSender implements Sender
@Override
public void send()
System.out.println("正在发送邮件");
package 设计模式.普通工厂模式;
public class SmsSender implements Sender
@Override
public void send()
System.out.println("正在发送短信");
package 设计模式.普通工厂模式;
public class SendFactoryTest
public static void main(String[] args)
SendFactory sf = new SendFactory();
Sender mail = sf.produce("mail");
mail.send();
3.多个工厂方法模式
- 结局了普通方法模式中如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常的问题
- 类图结构
- 代码：
package 设计模式.多个工厂方法模式;
/**
* 改善了普通工厂模式的缺点
* 缺点：为了能够正确创建对象，需要先创建工厂类的对象才能调用工厂类中的生产方法
*/
public class SendFactory
public Sender produceMail()
return new MailSender();
public Sender produceSms()
return new SmsSender();
package 设计模式.多个工厂方法模式;
public interface Sender
void send();
package 设计模式.多个工厂方法模式;
public class MailSender implements Sender
@Override
public void send()
System.out.println("正在发送邮件");
package 设计模式.多个工厂方法模式;
public class SmsSender implements Sender
@Override
public void send()
System.out.println("正在发送短信");
package 设计模式.多个工厂方法模式;
public class SendFactoryTest
public static void main(String[] args)
SendFactory sf = new SendFactory();
sf.produceMail().send();
4.静态工厂方法模式
- 避免了创建方法之前必须要先创建对象，
- 类图结构
- 代码：
package 设计模式.静态工厂方法模式;
/**
* 解决了多个工厂模式的缺点
* 缺点：，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则
*/
public class SendFactory
public static Sender produceMail()
return new MailSender();
public static Sender produceSms()
return new SmsSender();
package 设计模式.静态工厂方法模式;
public interface Sender
void send();
package 设计模式.静态工厂方法模式;
public class MailSender implements Sender
@Override
public void send()
System.out.println("正在发送邮件");
package 设计模式.静态工厂方法模式;
public class SmsSender implements Sender
@Override
public void send()
System.out.println("正在发送短信");
package 设计模式.静态工厂方法模式;
public class SendFactoryTest
public static void main(String[] args)
Sender sd = SendFactory.produceMail();
sd.send();
5.抽象工厂模式
- 解决了工厂模式中的问题（若拓展产品，则需要修改工厂类，违背了开闭原则）
- 类图结构
工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建
- 代码：
package 设计模式.抽象工厂模式;
public interface Sender
void send();
package 设计模式.抽象工厂模式;
public class MailSender implements Sender
@Override
public void send()
System.out.println("正在发送邮件");
package 设计模式.抽象工厂模式;
public class SmsSender implements Sender
@Override
public void send()
System.out.println("正在发送短信");
package 设计模式.抽象工厂模式;
import 设计模式.多个工厂方法模式.Sender;
/**
* 解决了静态工厂模式的缺点，增加产品无需违背开闭原则
*/
public interface Provider
Sender produce();
package 设计模式.抽象工厂模式;
import 设计模式.多个工厂方法模式.MailSender;
import 设计模式.多个工厂方法模式.Sender;
public class MailSendFactory implements Provider
@Override
public Sender produce()
return new MailSender();
package 设计模式.抽象工厂模式;
import 设计模式.多个工厂方法模式.Sender;
import 设计模式.多个工厂方法模式.SmsSender;
public class SmsSendFactory implements Provider
@Override
public Sender produce()
return new SmsSender();
package 设计模式.抽象工厂模式;
import 设计模式.多个工厂方法模式.Sender;
public class SendFactoryTest
public static void main(String[] args)
Provider provider = new MailSendFactory();
Sender produce = provider.produce();
produce.send();
6.装饰器模式
- 装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例
- 类图结构
- 代码：
package 设计模式.装饰器模式;
public interface Sourceable
void method();
package 设计模式.装饰器模式;
public class Source implements Sourceable
@Override
public void method()
System.out.println("还没有化妆");
package 设计模式.装饰器模式;
/**
* 装饰器模式：给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例
* 可以实现一个类功能的拓展
* 可以动态增加功能，还可以动态撤销
*/
public class Decorator implements Sourceable
private Sourceable source;
public Decorator(Sourceable source)
this.source = source;
@Override
public void method()
source.method();
System.out.println("这是化妆以后的样子");
package 设计模式.装饰器模式;
public class SourceTest
public static void main(String[] args)
Sourceable sourceable = new Source();
sourceable.method();
// 装饰后打印
Sourceable sourceable1 = new Decorator(sourceable);
sourceable1.method();
意义：
- 可以实现一个类功能的扩展。
- 可以动态的增加功能，而且还能动态撤销（继承不行）。
- 缺点：产生过多相似的对象，不易排错。
7. 代理模式
- 代理模式就是找一个代理类替原对象进行一些操作
- 类图结构
- 如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式
- 使用代理模式，可以将功能划分的更加清晰，有助于后期维护
- 代理模式和装饰器模式的比较
- 装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。
- 装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问
- 代码：
package 设计模式.代理模式;
public class Source implements Sourceable
@Override
public void method()
System.out.println("代理模式");
package 设计模式.代理模式;
public interface Sourceable
void method();
package 设计模式.代理模式;
public class Proxy implements Sourceable
private Source source;
public Proxy()
source = new Source();
@Override
public void method()
source.method();
System.out.println("代理模式的实现");
package 设计模式.代理模式;
public class ProxyTest
public static void main(String[] args)
Sourceable sb = new Source();
sb.method();
Sourceable sb1 = new Proxy();
sb1.method();
8.模板方法模式
- 模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果
- 类图结构
- 将多个子类共有且逻辑基本相同的内容提取出来实现代码复用
- 不同的子类实现不同的效果形成多态，有助于后期维护
- 代码：
package 设计模式.模板方法模式;
/**
* 模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果
* 意义：将多个子类共有逻辑基本相同的内容提取出来实现代码复用
* 不同的子类实现不同的效果形成多态，有助于后期维护
*/
public abstract class AbstractCalculator
public int splitExpression(String exp, String op)
String[] split = exp.split(op);
return calculate(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
public abstract int calculate(int ia, int ib);
package 设计模式.模板方法模式;
public class Minus extends AbstractCalculator
@Override
public int calculate(int ia, int ib)
return ia - ib;
package 设计模式.模板方法模式;
public class Plus extends AbstractCalculator
@Override
public int calculate(int ia, int ib)
return ia + ib;
package 设计模式.模板方法模式;
public class Test
public static void main(String[] args)
AbstractCalculator ac = new Plus();
int i = ac.splitExpression("2+1", "\\\\+");
System.out.println(i);
以上是关于常用设计模式的主要内容，如果未能解决你的问题，请参考以下文章