一、设计模式分类
设计模式主要分为三类：
创建模式：工厂方法模式、抽象工厂模式、单列模式、建造者模式、原型模式。（5种）
结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。（7种）
行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。（11种）
二、设计模式的六大原则：
总原则：开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类等，后面的具体设计中我们会提到这点。
1、单一职责原则
不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。
2、里氏替换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
历史替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。
5、迪米特法则（最少知道原则）（Demeter Principle）
就是说：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。
最少知道原则的另一个表达方式是：只与直接的朋友通信。类之间只要有耦合关系，就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。
6、合成复用原则（Composite Reuse Principle）
原则是尽量首先使用合成/聚合的方式，而不是使用继承。
1.简单工厂模式
简单工厂模式不属于23种模式，简单工厂模式一般分为：普通简单工厂、多方法简单工厂、静态方法简单工厂。
1.1 普通简单工厂模式
代码示例:
首先，定义一个公共接口
public interface Car{
public void run();
public void stop();
}
其次，创建实现类
public class Bmw implements Car{
@Override
public void run() {
System.out.println("Bmw启动");
}
@Override
public void stop() {
System.out.println("Bmw刹车");
}
}
public class Audi implements Car{
@Override
public void run() {
System.out.println("Audi 启动");
}
@Override
public void stop() {
System.out.println("Audi 刹车");
}
}
最后，创建工厂类
public class CarFactory {
public Car produce(String type) {
if ("bwm".equals(type)) {
return new Bwm();
} else if ("audi".equals(type)) {
return new Audi();
} else {
return null;
}
}
}
测试类如下：
public class FactoryTest {
public static void main(String[] args) {
CarFactory factory = new CarFactory();
Car car= factory.produce("audi");
car.run();
}
}
输出：Audi 启动
1.2 多方法简单工厂
多方法简单工厂是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
将上面的代码做下修改，改动下CarFactory类就行，如下：
public class CarFactory {
public Car produceBmw(){
return new Bmw();
}
public Car produceAudi(){
return new Audi();
}
}
1.3 静态方法简单工厂
将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
public class CarFactory {
public static Car produceBmw(){
return new Bmw();
}
public static Car produceAudi(){
return new Audi();
}
}
2.工厂方法模式（Factory Method）
简单工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到工厂方法模式，创建一个工厂接口和创建多个工厂实现类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
代码示例：
public interface Car{
public void run();
public void stop();
}
创建两个实现类
public class Bmw implements Car{
@Override
public void run() {
System.out.println("Bmw启动");
}
@Override
public void stop() {
System.out.println("Bmw刹车");
}
}
public class Audi implements Car{
@Override
public void run() {
System.out.println("Audi 启动");
}
@Override
public void stop() {
System.out.println("Audi 刹车");
}
}
接着，提供一个接口
public interface Provider {
public Car produce();
}
接着，创建两个工厂类
public class BmwFactory implements Provider {
@Override
public Car produce(){
return new Bmw();
}
}
public class AudiFactory implements Provider {
@Override
public Car produce(){
return new Audi();
}
}
测试类
public class Test {
public static void main(String[] args) {
Provider provider = new BmwFactory();
Car car= provider.produce();
car.run();
}
}
工厂方法模式的好处就是，如果你现在想增加一个功能：只需做一个实现类，实现Car接口，同时做一个工厂类，实现Provider接口，无需去改动现成的代码。这样做，拓展性较好！
3.抽象工厂模式
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。
代码示例：
创建两个接口
public interface IProductA {
public void method();
}
public interface IProductB {
public void method();
}
接着，创建两个实现类
public class ProductA1 implements IProductA{
public void method() {
System.out.println("我是厂商1。。。生产鼠标");
}
}
public class ProductA2 implements IProductA{
public void method() {
System.out.println("我是厂商2。。。生产鼠标");
}
}
public class ProductB1 implements IProductB{
public void method() {
System.out.println("我是厂商1。。。。生产键盘");
}
}
public class ProductB2 implements IProductB{
public void method() {
System.out.println("我是厂商2。。。生产键盘");
}
}
然后，创建两个创建两个抽象类或者是接口（这里我使用抽象类）
public abstract class ProductAFactory {
abstract IProductA getProductA1();
abstract IProductB getProductB1();
}
public abstract class ProductBFactory {
abstract IProductA getProductA2();
abstract IProductB getProductB2();
}
接着，创建两个类继承上面的两个抽象类
public class ConcreteFactoryA extends ProductAFactory{
IProductA getProductA1() {
return new ProductA1();
}
IProductB getProductB1() {
return new ProductB1();
}
}
public class ConcreteFactoryB extends ProductBFactory{
IProductA getProductA2() {
return new ProductA2();
}
IProductB getProductB2() {
return new ProductB2();
}
}
测试类
public class Test {
public static void main(String[] args) {
ProductAFactory paf=new ConcreteFactoryA();
IProductA A1=paf.getProductA1();
IProductB B1=paf.getProductB1();
A1.method();
B1.method();
ProductBFactory pbf=new ConcreteFactoryB();
IProductA A2=pbf.getProductA2();
IProductB B2=pbf.getProductB2();
A2.method();
B2.method();
}
}
工厂方法模式和抽象工厂模式的区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。