设计模式的六大原则
开闭原则是最基础的设计原则，其它的五个设计原则都是开闭原则的具体形态，依照java的语言的称谓，开闭原则是抽象类，其它的五个原则是具体实现类
开闭原则：软件实体应当对外扩展开放，对修改关闭，通俗点说就是应该在不修改原有代码的基础上，引入新功能。为了使程序的扩展性好，易于维护和升级
详细解释见百度百科开闭原则
实现方法：关键在于抽象，把系统所有的可能的行为抽象成一个抽象层，这个抽象底层规定出所有的具体实现必须提供的方法的特征，作为系统设计的抽象层，要预见所有可能的扩展，从而使得在任何扩展情况下，系统的抽象底层不需修改；同时，由于可以从抽象底层导出一个或多个新的具体实现，可以改变系统的行为，因此系统设计对扩展是开放的
单一职责原则
不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，否则就应该把类拆分
里氏替换原则
里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它
依赖倒转原则
面向接口编程，依赖于抽象而不依赖于具体
接口隔离原则
每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好
迪米特原则（最少知道原则）
一个类对自己依赖的类知道的越少越好，无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部，这样当被依赖的类变化时，才能最小的影响该类
模式
在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的，但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮传动。
模式的问题：你如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢？
解决方案：建立一个工厂来创建对象
实现
1.还没有工厂时代：接入没有革命，客户需要一辆宝马，通常做法是客户创建一辆宝马
2.简单工厂模式：后来出现工业革命，用户不用自己取创建宝马车，有一个工厂来帮他创建宝马车，想要什么车，直接工厂就能建成
3.工厂方法模式：为了满足客户，宝马系列越来越多，一个工厂不能实现生产所有的系列，于是单独分出来具体的工厂，每个工厂负责一个系列，具体工厂类只能创建一个产品，但是宝马工厂还是抽象类，需要制定某个具体的工厂才能生产出来。
4.抽象工厂模式：随着客户要求越来越高，宝马车必须配置空调
最终客户对销售员说需要一辆有空调的宝马，就不需要自己去创建，这就是工厂模式
分类
工厂模式主要为创建对象提供过度接口，以便将创建对象的具体过程屏蔽隔离起来，达到提供灵活性，工厂模式可分为三类：
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
通常将简单工厂模式看成是工厂方法的特例。
区别
工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例
抽象工厂模式
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂
每个具体工厂类可以创建多个具体产品类的实例
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个
简单工厂模式
建立一个工厂类方法来制造新的对象：
代码实现
产品类：
abstract class BMW {
public BMW() {
}
}
class BMW320 extends BMW {
public BMW320() {
System.out.println("简单工厂模式...制造BMW320");
}
}
class BMW523 extends BMW {
public BMW523() {
System.out.println("简单工厂模式...制造BMW523");
}
}工厂类：
public class Factory {
public BMW createBMW(int type) {
switch (type) {
case 320:
return new BMW320();
case 523:
return new BMW523();
default:
break;
}
return null;
}
}客户类：
public class Customer {
public static void main(String[] args) {
Factory fatcory = new Factory();
BMW bmw320 = fatcory.createBMW(320);
BMW bmw523 = fatcory.createBMW(523);
}
}运行结果：
简单工厂模式...制造BMW320
简单工厂模式...制造BMW523
Process finished with exit code 0简单工厂模式又称静态工厂模式，定义一个用于创建对象的接口
组成：
- 工厂类：模式核心，具有判断业务逻辑，用来创建产品
- 抽象产品：具有产品继承的父类或者实现的接口
- 具体产品：工厂类所创建的对象就是实例，由一个具体类实现
简单工厂模式只有一个类来对应产品，工厂类也叫全能类，对于这种局限，不利于扩展和维护，工厂方法模式就出现了
工厂方法模式
工厂方法模式去掉了简单工厂模式方法的静态属性，使得可以被子类继承，这样集中在工厂类处理的压力就可以由工厂方法模式里的不同子类来分担
组成：
- 抽象工厂：模式核心，是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现
- 具体工厂：含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象
- 抽象产品：是具体产品继承的父类或者是实现的接口
- 具体产品：具体工厂角色所创建的对象就是此角色的实例
工厂方法模式使用继承自抽象工厂角色的多个子类来替代简单工厂模式的全能类，这样使结构更加灵活
代码实现
产品类：
abstract class BMW {
public BMW() {
}
}
class BMW320 extends BMW {
public BMW320() {
System.out.println("工厂方法模式...制造BMW320");
}
}
class BMW523 extends BMW {
public BMW523() {
System.out.println("工厂方法模式...制造BMW523");
}
}工厂类：
interface FactoryBMW {
BMW createBMW();
}
class FactoryBMW320 implements FactoryBMW {
@Override
public BMW320 createBMW() {
return new BMW320();
}
}
class FactoryBMW523 implements FactoryBMW {
@Override
public BMW523 createBMW() {
return new BMW523();
}
}客户类：
public class Customer {
public static void main(String[] args) {
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
BMW320 bmw320 = factoryBMW320.createBMW();
FactoryBMW523 factoryBMW523 = new FactoryBMW523();
BMW523 bmw523 = factoryBMW523.createBMW();
}
}运行结果：
工厂方法模式...制造BMW320
工厂方法模式...制造BMW523
Process finished with exit code 0工厂方法模式对对象的创建进行了包装
抽象工厂模式
一般用于具有产品树(产品层次结构)和产品族的场景下
例子背景：
随着客户的要求越来越高，宝马车需要不同配置的空调和发动机等配件。于是这个工厂开始生产空调和发动机，用来组装汽车。这时候工厂有两个系列的产品:空调和发动机。宝马320系列配置空调和发动机，宝马230系列配置空调和发动机
概念
抽象工厂模式是工厂模式的升级版，用来创建一组相关或者相互依赖的对象，例如宝马320使用的电机和空调型号，宝马523使用的另外的型号，就需要使用工厂模式，在生产320系列时候就不需要执行型号进行生产.每个抽象产品都有两个具体的产品
抽象工厂模式和工厂方法模式的区别
在于需要创建对象的复杂程度上，抽象工厂模式是三个里面最抽象，最具一般性的，给客户端提供一个接口，可以创建多个产品族中的产品对象
使用抽象工厂模式需要满足条件：
1.系统中有多个产品族，而系统一次只能消费其中的一族产品
抽象工厂模式的各个角色：
抽象工厂角色：方法的核心，是具体工厂角色必须实现的接口或继承的父类，在java中由抽象类或接口来实现
具体工厂角色：含有和具体业务逻辑相关的代码，由应用程序调用对应具体产品的对象，在java中由具体的类来实现
抽象产品角色：具体产品继承的父类或者实现的接口，在java中一般由抽象类和接口来实现
具体产品角色：具体工厂角色所创建的对象就是此角色，在java中一般由具体的类来实现
代码实现
产品类：
Engine抽象类
// 抽象产品
public abstract class Engine {
}
// 具体产品
class Engine320 extends Engine {
public Engine320() {
System.out.println("抽象工厂模式...制造Engine320");
}
}
class Engine523 extends Engine {
public Engine523() {
System.out.println("抽象工厂模式...制造Engine523");
}
}AirCondition抽象类
// 抽象产品
public abstract class AirCondition {
}
// 具体产品
class AirCondition320 extends AirCondition {
public AirCondition320() {
System.out.println("抽象工厂模式...制造AirCondition320");
}
}
class AirCondition523 extends AirCondition {
public AirCondition523() {
System.out.println("抽象工厂模式...制造AirCondition523");
}
}工厂类：
// 抽象工厂
public interface AbstractFactory {
public Engine createEngine(); // 制造发动机
public AirCondition createAirCondition(); // 制造空调
}
// 具体工厂
// 为宝马320系列生产配件
class FactoryBMW320 implements AbstractFactory {
@Override
public Engine createEngine() {
return new Engine320();
}
@Override
public AirCondition createAirCondition() {
return new AirCondition320();
}
}
// 为宝马523系列生产配件
class FactoryBMW523 implements AbstractFactory {
@Override
public Engine createEngine() {
return new Engine523();
}
@Override
public AirCondition createAirCondition() {
return new AirCondition523();
}
}客户类：
public class Customer {
public static void main(String[] args) {
// 生产宝马320系列配件
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
factoryBMW320.createEngine();
factoryBMW320.createAirCondition();
// 生产宝马523系列配件
FactoryBMW523 factoryBMW523 = new FactoryBMW523();
factoryBMW523.createEngine();
factoryBMW523.createAirCondition();
}
}运行结果：
抽象工厂模式...制造Engine320
抽象工厂模式...制造AirCondition320
抽象工厂模式...制造Engine523
抽象工厂模式...制造AirCondition523
Process finished with exit code 0原文传送门：https://blog.csdn.net/jason0539/article/details/23020989