1.设计模式：
设计模式就是代码设计经验
2.设计模式的类型：
分为三大类：创建型模式，结构型模式，行为模式
创建型模式：
单例模式：某个类只能有一个实例，提供一个全局的访问点。
工厂模式：一个工厂类根据传入的参数决定创建出那一种产品类的实例。
抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。
建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。
原型模式：通过复制现有的实例来创建新的实例。
结构型模式
适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。
组合模式：将对象组合成树形结构以表示“”部分-整体“”的层次结构。
装饰模式：动态的给对象添加新的功能。
代理模式：为其他对象提供一个代理以便控制这个对象的访问。
亨元模式：通过共享技术来有效的支持大量细粒度的对象。
外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。
桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。
行为型模式
模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。
解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。
策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。
状态模式：允许一个对象在其对象内部状态改变时改变它的行为。
观察者模式：对象间的一对多的依赖关系。
备忘录模式：在不破坏封装的前提下，保持对象的内部状态。
中介者模式：用一个中介对象来封装一系列的对象交互。
命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。
责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。
迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。
3.单例模式：
1.一个类只有一个实例
2.只提供一个全局访问点
3.自我实例化（ 一个对象在其自身的定义中创建自己的实例 ）
懒汉模式在第一次调用时才创建实例，适合节省资源，但需要考虑线程安全问题。
饿汉模式在类加载时就创建实例，确保线程安全，但会占用更多资源，可能在不需要时也会初始化。
饿汉模式1：
很形象，通过getxxx静态方法把静态对象返回出去
这里的对象是私有的，防止外头的人修改，起到保护的作用
返回对象
public class UserMassage {//这是饿汉模式1//创建静态对象，自我实例化public static final UserMassage usermassage = new UserMassage();//提供全局访问点public static UserMassage getUsermassage(){return usermassage;}public void show(){System.out.println("我是单例模式");}}饿汉模式2：
public class UserMassage2 {//饿汉模式2public static final UserMassage2 usermassage;static {usermassage = new UserMassage2();}public void show(){System.out.println("我是单例模式");}
}懒汉模式：
先把静态对象设为null
判断静态对象是否为null
为null则生产一个返回
不为null则用这个对象
public class LayManModel {//懒汉模式//私有静态变量保存实例private static LayManModel layManModel;//提供公共的获取实例的方法public static LayManModel getInstance() {//使用synch保证线程安全if (layManModel == null) {synchronized (LayManModel.class) {if (layManModel == null) {layManModel = new LayManModel();}}}return layManModel;}public void show () {System.out.println("我是懒汉模式");}}测试代码：
1.== 用来判断地址从而判断是否是同一个对象
2.通过全局访问点来创建对象
public class Main2 {public static void main(String[] args) {LayManModel layManModel1 = LayManModel.getLayManModel();LayManModel layManModel2 = LayManModel.getLayManModel();System.out.println(layManModel1 == layManModel2);layManModel1.show();}
}优点：
在内存中只有一个实例，避免频繁的创建和销毁实例
缺点：
没有接口，不能继承
注意事项：getUserMassage() 方法中需要使用同步锁 synchronized (UserMassage.class) 防止多线程
同时进入造成 UserMassage被多次实例化
4.工厂模式：
优点
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定
程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事 。
面条接口：
public interface MianTiao {//面条抽象类public abstract void des();}三种产品：三种面条
拉面：
public class LaMian implements MianTiao{@Overridepublic void des() {System.out.println("我是拉面，兰州的拉面");}
}泡面：
public class PaoMian implements MianTiao{@Overridepublic void des() {System.out.println("我是泡面，大家都不爱吃的泡面");}
}烩面：
public class HuiMian implements MianTiao{@Overridepublic void des() {System.out.println("我是烩面，河南人爱吃的烩面");}
}测试方法：
public class Main {//传入我要生产面public static void main(String[] args) {MianTiao miantiao = SimpleNoodlesFactory.createNoodles(LA_MIAN);miantiao.des();}
}工厂：
public class SimpleNoodlesFactory {//简单面条工厂protected static final int PAO_MIAN = 1;protected static final int LA_MIAN = 2;protected static final int HUI_MIAN = 3;//这个方法是关键，用来生产的public static MianTiao createNoodles(int type) {switch (type) {case PAO_MIAN:return new PaoMian();case LA_MIAN:return new LaMian();default:return new HuiMian();}}
}抽象工厂：
因为工厂和工厂不一样，这个是面条工厂，我们随着企业的扩大需要包子工厂，生产工厂的工厂就是抽象工厂，也叫二级工厂。
5.装饰模式：
装饰模式是用来替代继承的一种设计模式。它通过一种无须定义子类的方式来给对象动态增加职责，使
用对象之间的关联关系取代类之间的继承关系。降低了系统的耦合，可以动态的增加或者删除对象的职 责
接口：
public interface Showable {//展示接口public abstract void show();
}装饰器：
public abstract class Decorator implements Showable{Showable showable ;//持有一个善于展示自己某个家伙//抽象装饰器//构造函数public Decorator(Showable showable){this.showable = showable;}//无需实现因为现在装饰器还不知道如何修饰public abstract void show();
}装饰对象：
public class Girl implements Showable{@Overridepublic void show() {System.out.print("女友的素颜");}
}装饰功能：
描眉：
public class MiaoMei extends Decorator{public MiaoMei(Showable showable) {super(showable);}//重写接口化妆后展示 描眉@Overridepublic void show() {System.out.print("描眉（");showable.show();System.out.print("）");}
}涂口红：
public class TuKouHong extends Decorator{public TuKouHong(Showable showable) {super(showable);}@Overridepublic void show() {System.out.print("涂口红（");showable.show();System.out.print("）");}
}测试方法：
这个装饰模式就是套的方式
和I/O流中的创建可像
public class Main {public static void main(String[] args) {//创建女友对象Girl girl = new Girl();//将女友放入描眉类MiaoMei lyw = new MiaoMei(girl);TuKouHong cmy = new TuKouHong(lyw);cmy.show();}
}6.代理模式：
代理模式 指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关 业务的处理。
/*
* 定义Network接口
*/
public interface Network {
public void browse(); // 定义浏览的抽象方法
}
/*
* 真实的上网操作
*/
public class Real implements Network {
//重写抽象方法
public void browse() {
System.out.println("上网浏览信息！");
}
}
/*
* 代理上网
*/
public class Proxy implements Network {
private Network network;
// 设置代理的真实操作
public Proxy(Network network) {
this.network = network; // 设置代理的子类
}
// 身份验证操作 其他操作
public void check() {
System.out.println("检查用户是否合法！");
}
//代码实现上网
public void browse() {
this.check(); // 调用具体的代理业务操作
this.network.browse(); // 调用真实的上网操作
}
}
public static void main(String args[]) {
Network net = null; // 定义接口对象
net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
net.browse(); // 调用代理的上网操作
}7.观察者模式
就是举个例子：订报纸
报纸厂家和订阅报纸的人之间这种一对多的就可以称为观察者模式
报纸厂家是被观察者
订阅报纸的人是观察者
当你订阅了 一份报纸，每天都会有一份最新的报纸送到你手上，有多少人订阅报纸，报社就会发多少份报纸，报社 和订报纸的客户就是上面文章开头所说的“一对多”的依赖关系
奶厂：
接口：
public interface Subject {//订阅void attach(Observer observer);//取消订阅void detach(Observer observer);//通知变动void notifyChanged();}实例：
public class RealSubject implements Subject{//奶厂//本奶厂下订奶的人集合private List<Observer> observerList = new ArrayList<Observer>();//添加订阅者@Overridepublic void attach(Observer observer) {observerList.add(observer);}//删除订阅者@Overridepublic void detach(Observer observer) {observerList.remove(observer);}//消息通知订阅者@Overridepublic void notifyChanged() {for (Observer observer : observerList) {observer.update();}}}
订牛奶的：
接口：
package ObserverTest;public interface Observer {/*** 接收变动通知*/void update();
}
实例：
package ObserverTest;public class RealObject implements Observer{//奶厂@Overridepublic void update() {System.out.println("通知");}
}
测试方法：
public class mainTest {public static void main(String[] args) {Subject subject = new RealSubject(); //创建奶厂Observer observer = new RealObject();//创建订阅人subject.attach(observer);//订阅人订阅 subject奶厂subject.notifyChanged();//奶厂发布消息 订阅者接收}
}奶厂可以管理订牛奶的，删除，添加或者发布消息
订牛奶的只能接收消息
总结：
通过定义一个抽象接口 Subject（奶厂），我们可以将 奶厂 和 订奶的人 的行为统一起来。