设计模式之间的关系
设计模式分类
创建型模式(5种)
处理对象创建,试图根据实际情况使用合适的方式创建对象。
- 将系统使用的具体类封装。
- 隐藏具体类实例创建和组合方式。
包含:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式(7种)
借由一以贯之的方式来了解元件间的关系,以简化设计。
包含: 适配器模式、 装饰器模式、 代理模式、 外观模式、 桥接模式、 组合模式、 享元模式。
行为型模式(11种)
用来识别对象之间的常用交流模式并加以实现。
包含: 策略模式、 模板方法模式、 观察者模式、 迭代子模式、 责任链模式、 命令模式、 备忘录模式、 状态模式、 访问者模式、 中介者模式、 解释器模式。
其它(2种)
并发型模式、 线程池模式。
设计模式六大原则(SOLID)
单一职责原则(Single Responsibility Principle)
一个类只负责一个职责。
- 代码的粒度降低了,类的复杂度降低了。
- 可读性提高了,每个类的职责都很明确,可读性自然更好。
- 可维护性提高了,可读性提高了,一旦出现 bug ,自然更容易找到他问题所在。
- 改动代码所消耗的资源降低了,更改的风险也降低了。
开闭原则(Open Closed Principle)
对扩展开放,对修改关闭。
在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。
实现“开-闭”原则的关键步骤就是抽象化。
里氏代换原则(Liskov Substitution Principle)
面向对象设计的基本原则之一。 任何基类可以出现的地方,子类一定可以出现。
LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。
里氏代换原则是对“开-闭”原则的补充。
基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。
迪米特法则(最少知道原则)(Law of Demeter)
一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
接口隔离原则(Interface Segregation Principle)
使用多个隔离的接口,比使用单个接口要好。
降低依赖,降低耦合。
依赖倒置原则(Dependence Inversion Principle)
开闭原则的基础。 针对接口编程,依赖于抽象而不依赖于具体。
设计模式(23种)
工厂方法模式(Factory Method)
核心精神是封装类中变化的部分,提取其中个性化善变的部分为独立类,通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。
核心结构有四个角色,分别是工厂;抽象产品;具体产品。
public interface ShirtProducer {
void produceShirt();
}
public class ManShirtProducer implements ShirtProducer {
@Override
public void produceShirt() {
System.out.println("produce man shirt.");
}
}
public class WomanShirtProducer implements ShirtProducer {
@Override
public void produceShirt() {
System.out.println("produce woman shirt.");
}
}
简单工厂模式
建立一个工厂类,对实现了同一接口的一些类进行实例的创建。
public class SimpleShirtFactory {
public ShirtProducer produce(String shirtType) {
if ("t-shirt".equals(shirtType)) {
return new WomanShirtProducer();
} else {
return new ManShirtProducer();
}
}
}
简单工厂(反射)
简单工厂的改进,通过反射实现对新增产品生产的兼容,新增产品生产无需改写工厂类。
public class ReflectSimpleShirtFactory {
public ShirtProducer produce(String shirtType)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> ShirtProducer = Class.forName(shirtType);
return (ShirtProducer) ShirtProducer.newInstance();
}
}
多个工厂方法模式
对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提 供多个工厂方法,分别创建对象。
public class MultiShirtFactory {
public ShirtProducer produceManShirt() {
return new ManShirtProducer();
}
public ShirtProducer produceWomanShirt() {
return new WomanShirtProducer();
}
}
静态工厂方法模式
将多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。
public class StaticMultiShirtFactory {
public static ShirtProducer produceShirt() {
return new ManShirtProducer();
}
public static ShirtProducer produceTShirt() {
return new WomanShirtProducer();
}
}
凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。
大多数情况下,选用静态工厂方法模式。
public class ShirtFactoryMain {
public static void main(String[] args) {
System.out.println("普通工厂模式");
SimpleShirtFactory shirtFactory1 = new SimpleShirtFactory();
ShirtProducer shirtProducer1 = shirtFactory1.produce("shirt");
shirtProducer1.produceShirt();
try {
System.out.println("普通工厂模式(反射)");
ReflectSimpleShirtFactory shirtFactory11 = new ReflectSimpleShirtFactory();
ShirtProducer shirtProducer11 = shirtFactory11.produce(ManShirtProducer.class.getName());
shirtProducer11.produceShirt();
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
System.out.println("多工厂方法模式");
MultiShirtFactory shirtFactory2 = new MultiShirtFactory();
ShirtProducer shirtProducer2 = shirtFactory2.produceManShirt();
shirtProducer2.produceShirt();
System.out.println("静态工厂方法模式");
ShirtProducer shirtProducer3 = StaticMultiShirtFactory.produceShirt();
shirtProducer3.produceShirt();
}
}
抽象工厂模式(Abstract Factory)
工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则。
抽象工厂模式, 工厂方法模式的抽象化,创建多个工厂类,需要增加新的功能时,直接增加新的工厂类即可,不需要修改之前的代码。
核心结构有四个角色,分别是抽象工厂;具体工厂;抽象产品;具体产品。
- 抽象工厂
抽象工厂模式核心,与应用程序无关,任何在模式中创建的对象的工厂类必须实现这个接口。
- 具体工厂
实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建产品对象。
- 抽象产品
工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。
- 具体产品
实现了抽象产品角色所定义的接口。
public interface ShirtFactory {
ShirtProducer produce();
}
public class MailSenderFactory implements SenderFactory {
@Override
public Sender produce() {
return new MailSender();
}
}
public class ManShirtFactory implements ShirtFactory {
@Override
public ShirtProducer produce() {
return new ManShirtProducer();
}
}
public class WomanShirtFactory implements ShirtFactory {
@Override
public ShirtProducer produce() {
return new WomanShirtProducer();
}
}
public class ShirtProducerMain {
public static void main(String[] args) {
System.out.println("抽象工厂模式");
ShirtFactory shirtProvider1 = new ManShirtFactory();
ShirtProducer shirtProducer1 = shirtProvider1.produce();
shirtProducer1.produceShirt();
ShirtFactory shirtProvider2 = new WomanShirtFactory();
ShirtProducer shirtProducer2 = shirtProvider2.produce();
shirtProducer2.produceShirt();
}
}
建造者模式(Builder)
将各种产品集中起来进行管理,用来创建复合对象。
工厂模式关注创建单个产品,建造者模式关注创建符合对象、多个部分。
public class ShirtProducerBuilder {
private List<ShirtProducer> shirtProducerlist = new LinkedList<ShirtProducer>();
public void produceManShirtProducer(int count) {
for (int i = 0; i < count; i++) {
shirtProducerlist.add(new ManShirtProducer());
}
}
public void produceWomanShirtProducer(int count) {
for (int i = 0; i < count; i++) {
shirtProducerlist.add(new WomanShirtProducer());
}
}
}public class SenderBuilder {
private LinkedList<Sender> senderList = new LinkedList<Sender>();
public void