设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式。设计模免去我们自己再思考和摸索。就像是经典 的棋谱，不同的棋局，我们用不同的棋谱。”套路”
1.单例设计模式
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对 某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构 造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生 类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无 法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象 的变量也必须定义成静态的。
懒汉式暂时还存在线 程安全问题，讲到多 线程时，可修复
单例设计模式：
1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
2. 区分饿汉式 和 懒汉式
饿汉式：
* 坏处：对象加载时间过长。
* 好处：饿汉式是线程安全的
* 懒汉式：好处：延迟对象的创建。
* 目前的写法坏处：线程不安全。--->到多线程内容时，再修改
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须声明为静态的（如果非静态，要调用获取对象方法 需要造对象。需要造对象，又需要调用获取对象方法 造成死循环）
private static Bank instance = new Bank();
//3.提供公共的静态的方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
//懒汉式
class Order{
//1.私有化类的构造器
private Order(){
}
//2.声明当前类对象，没有初始化
//4.此对象也必须声明为static的
private static Order instance = null; //区分构建
//3.声明public、static的返回当前类对象的方法
public static Order getInstance(){
if(instance == null){
instance = new Order();
}
return instance;
}
}
也可以用以下：加 final
class Bank{
private Bank(){
}
public static final Bank instance = new Bank();
}
2.多态的应用:模板方法设计模式(TemplateMethod)
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模 板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象 类的行为方式。
解决的问题:
当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以 把不确定的部分暴露出去，让子类去实现。
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用， 这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽 象出来，供不同子类实现。这就是一种模板模式。
模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的 影子，比如常见的有:
数据库访问的封装
Junit单元测试
JavaWeb的Servlet中关于doGet/doPost方法调用 Hibernate中模板程序
Spring中JDBCTemlate、HibernateTemplate等
办理具体的业务 钩子方法
像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码
例子：
代理模式（接口的应用）
代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其 他对象提供一种代理以控制对这个对象的访问。
被代理类
代理类（代理类中包含被代理类的操作，同时还可以做其他操作）
应用场景:
安全代理:屏蔽对真实角色的直接访问。
远程代理:通过代理类处理远程方法调用(RMI)
延迟加载:先加载轻量级的代理对象，真正需要再加载真实对象
比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有 100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理 模式，当需要查看图片时，用proxy来进行大图片的打开。
分类
静态代理(静态定义代理类) 动态代理(动态生成代理类)
JDK自带的动态代理，需要反射等知识
动态代理：不显示的把代理类写出来，在代码执行中动态的生成代理类对象。
例子：
interface Star {
void confer();// 面谈
void signContract();// 签合同
void bookTicket();// 订票
void sing();// 唱歌
void collectMoney();// 收钱
}
//被代理类
class RealStar implements Star {
public void confer() {
}
public void signContract() {
}
public void bookTicket() {
}
public void sing() {
System.out.println("明星：歌唱~~~");
}
public void collectMoney() {
}
}
//代理类
class Proxy implements Star {
private Star real;
public Proxy(Star real) {
this.real = real;
}
public void confer() {
System.out.println("经纪人面谈");
}
public void signContract() {
System.out.println("经纪人签合同");
}
public void bookTicket() {
System.out.println("经纪人订票");
}
public void sing() {
real.sing();
}
public void collectMoney() {
System.out.println("经纪人收钱");
}
}
public class StaticProxyTest {
public static void main(String[] args) {
Proxy s = new Proxy(new RealStar());
s.confer();
s.signContract();
s.bookTicket();
s.sing();
s.collectMoney();
}
}
工厂模式（接口的应用）
工厂模式:实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离 起来，达到提高灵活性的目的。 其实设计模式和面向对象设计原则都是为了使得开发项目更加容易扩展和维 护，解决方式就是一个“分工”。
简单工厂模式:用来生产同一等级结构中的任意产品。(对于增加新的产品， 需要修改已有代码)
缺点:对于增加新产品，不修改代码的话，是无法扩展的。违反了开闭原则(对 扩展开放;对修改封闭)。
工厂方法模式:用来生产同一等级结构中的固定产品。(支持增加任意产品)
简单工厂模式与工厂方法模式真正的避免了代码的改动了?没有。在简单工厂模 式中，新产品的加入要修改工厂角色中的判断语句;而在工厂方法模式中，要么 将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死(就像 上面的例子一样)。而且产品对象创建条件的改变必然会引起工厂角色的修改。 面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在 Spring 中完美的体现了出来。
抽象工厂模式:用来生产不同产品族的全部产品。(对于增加新的产品，无能为力;支持增加产品族)
抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且 抽象工厂模式是三个里面最为抽象、最具一般性的。 抽象工厂模式的用意为:给客户端提供一个接口，可以创建多个产品族中的产品 对象。