Singleton（单例模式）
一句话总结：一个类在Java虚拟机中只有一个对象，并提供一个全局访问点。
生活中例子：太阳、月亮、国家主席等。
解决什么问题：对象的唯一性，性能浪费太多。
项目里面怎么用：数据库连接对象，属性配置文件的读取对象。
模式结构：分为饿汉式和懒汉式（如果考虑性能问题的话，就使用懒汉式，因为懒汉式是在方法里面进行初始化的），构造器私 有化，对外提供方法加同步关键字。
框架里面使用：Struts1的Action。
JDK里面使用：java.lang.Runtime#getRuntimejava.awt.Desktop#getDesktop。
饿汉式代码：
public class HurgrySingleton {
private static HurgrySingleton hurgry=new HurgrySingleton();
private HurgrySingleton(){};
public static HurgrySingleton getSinletonHurgry(){
return hurgry;
}
} 懒汉式代码：
public class LarzySingleton {
private static LarzySingleton larzy=null;
private LarzySingleton(){};
public static synchronized Larzy getSinletonLarzy(){
if(larzy==null){
larzy=new LarzySingleton();
}
return larzy;
}
} Factory（简单的工厂模式）
一句话总结：用一个方法来代替new关键字
生活中的例子：制衣厂、面包厂等生产厂。
解决什么问题：对象产生过多，或者经常有子类替换生成。
项目里面怎么用：对于经常生成的对象，或者父子类替换的对象。
模式结构：写一个对外声明的方法，方法里面使用new关键字代替。
框架里面使用：spring的核心就是工厂模式。
JDK里面使用：newInstance。
工厂模式代码：
public class UserFactory {
public static User createUser(int i){
//如果输入的是1，就创建它的子类，否则就创建父类
if(i==1){
return new Alices();
}
return new User();
}
} Proxy（代理模式）
一句话总结：为其他对象提供一个代理，以控制对当前对象的访问。
生活中的例子：房屋中介、婚姻介绍所。
解决什么问题：不能直接访问该对象，或者太大的资源耗费多。
项目里面怎么用：权限，或者大对象的访问权限。
模式结构：代理类和被代理类实现同一个接口，用户访问的时候先访问代理对象，然后让代理对象去访问被代理对象。
框架里面使用：Spring里面的AOP实现。
JDK里面使用：java.lang.reflect.Proxy。
代理模式代码：
创建一个接口：
public interface SellHouse {
void sell(double money);
}
//----
public class Hoster implements SellHouse {
@Override
public void sell(double money) {
System.out.println("祝你居住愉快");
}
}
//----
public class Medium implements SellHouse {
SellHouse hoster=new Hoster();
@Override
public void sell(double money) {
if(money>=1000){
hoster.sell(money);
}else{
System.out.println("你的价格太低了");
}
}
}
//----
public class Renter {
public static void main(String[] args) {
SellHouse renter=new Medium();
renter.sell(500);
}
}
Adapter（适配器模式）
一句话总结：将两个原来不兼容的类兼容起来一起工作。
生活中的例子：变压器、充电器
解决什么问题：已经存在的相同功能的代码，但是接口不兼容，不能直接调用。
项目里面怎么用：在使用旧的API的时候，没有源码，和新的不能兼容。
模式结构：分为类适配器和对象适配，一般常用的就是对象适配器，因为组合由于继承。
框架里面使用：单元测试里面的asserEquels。
JDK里面使用：java.util.Arrays#asListjava.io.InputStreamReader(InputStream) java.io.outputStreamWriter(OutputStream)。
Strategy（策略模式）
一句话总结：定义一系列算法并可以互相替换。
生活中的例子：图片的格式，压缩文件的格式。
解决什么问题：做一件事情有很多种方法。
项目里面怎么用：购物车里面的付款方式。
模式结构：声明一个顶级接口，定义一个策略方法，具体的实例都要实现这个接口。
框架里面使用：hibernate的主键生成策略。
JDK里面使用：java.util.Comparator#compare。
public interface Person {
void repast();
}
//-----
public class African implements Person {
@Override
public void repast() {
System.out.println("非洲人用手吃饭");
}
}
//------
public class America implements Person {
@Override
public void repast() {
System.out.println("美国人用刀叉吃饭");
}
}
//-----
public class Chinese implements Person {
@Override
public void repast() {
System.out.println("中国人用筷子吃饭");
}
}
//-----
public class Test {
public static void main(String[] args) {
Person chinese=new Chinese();
Person america=new America();
Person african=new African();
chinese.repast();
america.repast();
african.repast();
}
} Template（模板模式）
一句话总结：父类定义流程，子类实现流程。
生活中的例子：iphone生产有多个国家，但流程只有一个。
解决什么问题：业务有多种，但都有规定的流程。
项目里面怎么用：一般基类的实现都是模板模式，BaseDAO，bBaseService。
模式结构：定义一个抽象父类定义流程，或者常用方法和常量，子类继承父类，实现具体的细节方法。
框架里面使用：hibernate里面的方言，是跨数据库的基础。
JDK里面使用：IO流里面的InputStream，Writer等。
模板模式代码：
public abstract class IPhoneTemplate {
public void createIPhone(){
setupCpu();
setupAll();
check();
box();
}
protected abstract void box();
protected abstract boolean check();
protected abstract void setupAll();
protected abstract void setupCpu();
}
//-------
public class ChinaIPhone extends IPhoneTemplate {
@Override
protected void box() {
System.out.println("box()");
}
@Override
protected boolean check() {
System.out.println("check()");
return true;
}
@Override
protected void setupAll() {
System.out.println("setupAll()");
}
@Override
protected void setupCpu() {
System.out.println("setupCpu()");
}
}
//-------
public class AfricanIPhone extends IPhoneTemplate {
@Override
protected void box() {
System.out.println("box()");
}
@Override
protected boolean check() {
System.out.println("check()");
return true;
}
@Override
protected void setupAll() {
System.out.println("setupAll()");
}
@Override
protected void setupCpu() {
System.out.println("setupCpu()");
}
}