模式设计（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样（百度百科）。本文将介绍几种简单的设计模式。
单例设计模式：
解决一个类在内存中只有一个对象，多个程序使用统一配置信息对象时，需要保证该对对象的唯一性。
保证对象唯一性的实现步骤：
1.将构造函数私有化：为了避免其他程序过多建立该对象，禁止其他程序调用该对象。
2.在类中创建一个本类对象：为了让其他程序可以访问该类对象
3.提供一个方法可以获取到该对象的方法：方便其他程序访问自定义的本类对象。
饿汉式：
所谓饿汉式就是一进内存 就创建了对象
class single{ private single(){}1.将构造函数私有化 private static single s=new single();2.在类中创建一个本类对象 public static single getInstance(){3.提供一个方法可以获取到该对象的方法 return s; } }
调用方式
public class SingleDemo { public static void main(String[] args) { single ss=single.getInstance(); } }
懒汉式：
所谓的饿汉式就是什么时候调用什么时候才创建对象,已达到对象的延时加载效果。
class single{ private single(){} private static single s=null; public static single getInstance(){ { if （s==null）{ s=single.getInstance(); } } return s; } }
两种方式的比较：
饿汉式是比较常用的一种方式，因为它是线程安全的，而懒汉式相对来说使用的较少，因为线程不安全。当然也可以使用同步来保证线程安全
装饰设计模式
顾名思义，所谓的装饰模式就是为了增强一个类的功能，所以在在其他类的基础上进行装饰（包装）。
当想要对已有的独享进行功能增强时，可以定义类，将已有的对象传入，基于已经有的功能，并提供加强功能，那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能（在IO流中使用比如BufferedReader等等）。
代码演示：
已知类：
Person() { public void chifan() { } }
增强类：
superPerson() { private Person p; superPerson(Person p) { this.p=p; } public void superchifan() { p.chifan(); ......... }
自定义装饰类
package com.io; import java.io.*; public class MyBufferedReader { private Reader r; public MyBufferedReader(Reader r) { super(); this.r = r; } //可以一次读取一行的方法 public String myReadLine() throws IOException { //定义一个临时容器。StringBulider容器，应用于存储字符数组 StringBuilder sb=new StringBuilder(); int ch=0; while((ch=r.read())!=-1){ if(ch=='\r') continue; if(ch=='\n') return sb.toString(); else sb.append((char)ch); } if(sb.length()!=0) return sb.toString(); return null; } //复写reader中的抽象方法 //复写close方法 public void close() throws IOException { r.close(); } //复写read方法 public int read (char[] c,int off,int len) throws IOException{ return r.read(c, off, len); } }
模板设计模式
在我们定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么就把这不确定的部分暴露出去，由该类的子类完成，这方思想就是模板设计模式
示例
abstract class GetTime { public final void getTime(){ long start = System.currentTimeMillis(); runcode(); long end = System.currentTimeMillis(); System.out.print("程序运行时间（毫秒）:"+(end-start)); public abstract void runcode(); } } class SubTime extends GetTime { public void runcode(){ for (int x =0;x<100 ;x++ ) { System.out.println(x); } } }
GetTime类中getTime方法时为了获取某个程序运行的时间，因为不知道会运行什么程序，所以把程序封装进一个抽象类中，当我们引用这个方法时，就必须得复写其中的抽象方法runcode，同时继承了getTime这个方法，从而达到检测不同程序运行时间的效果。这就是模板设计模式。
注意：不确定的部分不是非得是抽象的，因为原有类中可能有默认的方法，我们在使用时，只需把它覆盖即可，写我们需要的内容即可。所以，不确定部分，可以是抽象的，也可以不是抽象的。
简单工厂模式
构建一个工厂出来，在里面进行生产，用的时候直接拿
我的总结：
好处:屏蔽不同子类实现的差异，提高代码的可拓展性和可维护性;
package reviewDemo;
//简单工厂模式
interface Phone{//制定标准，都要实现send()方法
public void send();
}
class Iphone implements Phone{
@Override
public void send() {
System.out.println("Iphone手机在发短信");
}
}
class AndroidPhone implements Phone{
@Override
public void send() {
System.out.println("AndroidPhone手机在发短信");
}
}
class MyPhone implements Phone{
@Override
public void send() {
System.out.println("MyPhone手机在发短信");
}
}
class Factory{
public static void show(String type){//传入参数，根据不同的类型个性化定制
if(type.equals("")){//为空的情况，不用往下执行
System.out.println("对不起，类型为空！,请重新输入！");
return;
}
Phone p = null;
if("Iphone".equals(type)){//判断类型
p = new Iphone();
}else if("AndroidPhone".equals(type)){
p = new AndroidPhone();
}else{
p = new MyPhone();
}
p.send();
}
}
public class FactoryDemo17 {
public static void main(String[] args) {
new Factory().show("Iphone");//调用方法
new Factory().show("AndroidPhone");
new Factory().show("MyPhone");
new Factory().show("YourPhone");
new Factory().show("");
}
}
输出：
Iphone手机在发短信
AndroidPhone手机在发短信
MyPhone手机在发短信
MyPhone手机在发短信
对不起，类型为空！
享元模式
-128~127之间的特殊性。为什么要这样设计，好处？
——> 享元模式（Flyweight Pattern）：享元模式的特点是，复用我们内存中已存在的对象，降低系统创建对象实例。
自动装箱：
Integer num1 = 12;
自动拆箱：
System.out.println(num1 + 12);
基本数据类型的对象缓存：
Integer num1 = 12;
Integer num2 = 12;
System.out.println(num1 == num2);
Integer num3 = 129;
Integer num4 = 129;
System.out.println(num3 == num4);//false
Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12);
System.out.println(num5 == num6);//false
我的总结：对于享元模式，将最常用的封装以便于我们可以复用！