话不多说奔主题，精神抖擞就是干！
Java中共包含23种设计模式，大致分为三种类型：
1. 创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
3. 行为型模式：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式。
下面介绍常用的几种：
1. 单例模式：是个程序一般都会用到这个模式。比如日志类，整个项目工程可能只需要创建一次，重复创建也只是返回第一次创建的实例的引用。
public class SingleTon {
//快加载
private static final SingleTon singleTon = new SingleTon();
private SingleTon() {};
public static SingleTon GetInstance() { return singleTon; }
}
public class SingleTon {
private static volatile SingleTon singleTon = null;
private SingleTon() {};
//懒加载
public static SingleTon GetInstance() {
if (null == singleTon) {
synchronized (SingleTon.class) {
if (null == singleTon) {
singleTon = new SingleTon();
}
}
}
return singleTon;
}
}
*要点：构造函数私有化，new前判空加锁。
2. 工厂模式：集中化生产同一类产品(存在差异化)，比如造车厂，我可能只造小轿车，但是小轿车可能有不同的颜色搭配，还有经济型、标准型、豪华型等性能搭配。
2.1 简单工厂
public class Car {
public Color color; //颜色
public Car (Color color) { this.color = color; }
}
public class PianYiCar extends Car {
public PianYICar(Color color) { super.color = color; }
}
public class XiaoZiCar extends Car {
public XiaoZiCar (Color color) { super.color = color; }
}
public class GuiCar extends Car {
public GuiCar (Color color) { super.color = color; }
}
public class CarFactory {
public Car Create(Type type, Color color) {
switch(type) {
case ‘经济型‘: return new PianYiCar (color);
case ‘标准型‘: return new XiaoZiCar (color);
case ‘豪华型‘: return new GuiCar(color);
default: return new Car(color);
}
}
}
*要点：简单工厂，其实就是条件工厂，根据不同条件去创建同一类型的差异化对象。
2.2 工厂方法：定义一个工厂类该类定义了一些标准方法但没有具体实现，通过不同的子类继承这个工厂父类并实现其标准方法去创造相同(存在差异化)或不同类型的对象。
public abstract class CarFactory {
public abstract Car CreateCar(Color color);
}
public class PianYiCarFactory {
@Override
public Car CreateCar(Color color) {new PianYiCar(color); }
}
public class XiaoZiCarFactory {
@Override
public Car CreateCar(Color color) {new XiaoZiCar(color); }
}
public class GuiCarFactory {
@Override
public Car CreateCar(Color color) {new GuiCar(color); }
}
*要点：具体实施的工作不再由父工厂去完成，父工厂定义了行业标准，而子工厂根据老大说的标准，各自去完成自己的事情。
3. 适配器模式
3.1 类适配器
先讲个小故事。大家在日常生活里，有没有遇到过这种情况，我的手机快没电了想要充电，但是手头只有一个二插头的充电器和一个三插头的插线板，woc，怎么办？好急啊！在线等~
那这种情况下我们是不是可以采取一些极端手段，比如把二插头的充电器的两只腿掰弯，这样是不是就能插进三插头的插线板里充电了呢？哈哈哈，没错，我真是个天才！
public Interface TwoChong {
public void TwoChongDian();
}
public Interface ThreeChong {
public void ThreeChongDian();
}
public class TwoChongImpl implements TwoChong {
@Override
public void TwoChongDian() { System.out.println("充电"); }
}
//下面这个就是你掰弯后的二插头充电器了^-^
public class TwoChongImplEx extends TwoChongImpl implements ThreeChong {
@Override
public void ThreeChongDian() { super.TwoChongDain(); }
}
*要点：其实说白了，就是对现有功能的一种扩展。
3.2 对象适配器：它是对类适配器的一种衍生，因为类适配具有强绑定、强约束性，不方便扩展。
public class ThreeChongImpl implements ThreeChong {
private TwoChongImpl twoChongImpl = null;
public ThreeChongImpl(TwoChongImpl twoChongImpl) { this.twoChongImpl = twoChongImpl; }
@Override
public void ThreeChongDian() { twoChongImpl.TwoChongDian(); }
}
3.3 接口适配器：减少代码量，提高可读性。
public interface A {
public void Do();
}
public class AA implements A {
@Override
public void Do() {}
}
public class AAA extends AA {
@Override
public void Do() { System.out.println("实际工作"); }
}
4. 代理模式：代理模式分为三种，静态代理，JDK动态代理，CGLIB动态代理。代理模式是Spring中面向切面编程的核心。
4.1 静态代理
public interface Wo {
public void Travel();
}
public class WoImpl implements Wo {
@Override
public void Travel() { Sysyem.out.println("去旅行"); }
}
public class MyProxyImpl implements Wo {
private WoImpl woImpl = null;
public MyProxyImpl(WoImpl woImpl) { this.woImpl = woImpl; }
@Override
public void Travel() {
Sysyem.out.println("订去返机票");
Sysyem.out.println("打车去机场");
woImpl.Travel();
}
}
*要点：所谓代理就是在你执行某个动作前后，帮你做一些准备动作和收尾动作。静态代理类只能用于一个类的代理，扩展性差。
4.2 JDK动态代理
public class MyProxyImpl {
public static Wo getMyProxyByJDK(Wo wo) {
Wo myProxy = (Wo) Proxy.newProxyInstance(wo.getClass().getClassLoader(),
wo.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("订去返机票");
System.out.println("打车去机场");
Object obj = method.invoke(wo, args);
return obj;
}
});
return myProxy ;
}
}
5. 模板方法模式
先讲个小故事。大家在日常生活里，有空的时候都会自己做点饭吃。那么今天我想做个炒饭吃，明天我想做个炒面吃。其实炒饭和炒面基本上做法是一样的，只是主要食材不一样。
那么我只要能把炒饭做好了，炒面自然不在话下。
public abstract class ChaoTemplate {
public void Do() {
DaoYou();
KaiHuo();
ReYou();
DaoShiCai();
FanChao();
GuanHuo();
}
public void DaoYou() { System.out.println("倒油"); }
public void KaiHuo() { System.out.println("开火"); }
public void ReYou() { System.out.println("热油"); }
public abstract void DaoShiCai();
public void FanChao() {System.out.println("翻炒"); }
public void GuanHuo() { System.out.println("关火"); }
}
public class ChaoFan extends ChaoTemplate {
@Override
public void DaoShiCai() { System.out.println(" 倒米饭"); }
}
public class ChaoMian extends ChaoTemplate {
@Override
public void DaoShiCai() { System.out.println("倒面条"); }
}
public class Test {
public static main(String[] args) {
ChaoFan chaoFan = new ChaoFan();
ChaoMian chaoMian = new ChaoMian();
chaoFan.Do();
chaoMian.Do();
}
}
*要点：其实就是将相同的动作提取出来放到父类里去实现，子类实现各自的不同工作。减少重复劳动。
6. 策略模式：与工厂模式类似，个人感觉是将简单工厂与工厂方法结合使用的一种模式。使用时跟多态很像。
public abstract class Saler {
public abstract void Sale();
}
public class PuTongSaler extends Saler {
@Override
public void Sale() { System.out.println("我是普通销售，我只卖袜子"); }
}
public class GaoJiSaler extends Saler {
@Override
public void Sale() { System.out.println("我是高级销售，我卖车子"); }
}
public class SuperSaler extends Saler {
@Override
public void Sale() { System.out.println("我是销售经理，你想要什么我都有"); }
}
public class MySaler {
private Saler saler = null;
public MySaler (Type type) {
switch(type) {
case ‘PuTong‘: saler = new PuTongSaler(); break;
case ‘GaoJi‘: saler = new GaoJiSaler(); break;
case ‘Super‘: saler = new SuperSaler(); break;
}
}
public void Sale() { saler.Sale(); }
}
public class Test {
public static void main(String[] args) {
mySaler = new MySaler(‘PuTong‘);
mySaler.Sale();
mySaler = new MySaler(‘GaoJi‘);
mySaler.Sale();
mySaler = new MySaler(‘Super‘);
mySaler.Sale();
}
}
欢迎看官儿们留言补充和指正，谢谢下次见！
原文：https://www.cnblogs.com/chenyixun/p/13140307.html