java 设计模式浅析（持续学习更新）

1 单例模式

单例模式指的是在java程序执行过程中被调用的对象有且只有一个，如工具类，缓存，数据库连接等等。

单例模式又分出两种：饿汉模式，懒汉模式，两者最主要的区别是饿汉模式在类加载时就创建对象，懒汉模式是在调用时创建对象。

示例主要代码

//饿汉模式
public class Singleton{
//创建唯一实例
private static Singleton  singleton = new Singleton();
//构造函数私有化，不允许外部实例化对象
private void Singleton(){

}
public static Singleton  getSingleton(){
return singleton;
}
}
<pre name="code" class="java">//懒汉模式
public class Singleton{
//定义唯一实例
private static Singleton  singleton;
//构造函数私有化，不允许外部实例化对象
private void Singleton(){

}
//synchronized保证线程安全
 public synchronized static Singleton  getSingleton(){
if(singleton == null){
singleton = new Singleton();
} 
return singleton;
}
}

2模版方法模式

模版方法模式指的是在java程序设计的时候将业务方法中相同步骤抽象出来创建成模版，具体子类延迟执行，模版中可添加钩子使得子类灵活执行

示例主要代码

/**
* @类功能说明： 学习java
* @作者：sao_ma
* @版本：V1.0
*/
public abstract class LearningJava {
/**
* 方法功能说明：学习java模版方法，定义成final防止子类修改
*
*/
public final void LearningJavaTemplate() {
// 步骤一
LearningJavaSE();
// 步骤二
LearningJavaWeb();
// 步骤三
Coding();
// 步骤四
if(isOverTimeCoding()){
OverTimeCoding();
}
// 步骤五
HolyShit();
}

// 定义抽象方法 子类实现
protected abstract void Coding();

// 定义抽象方法 子类实现
protected abstract void OverTimeCoding();

private void HolyShit() {
// TODO Auto-generated method stub
System.out.println("升职加薪，当上总经理，赢取百富美，走上人生巅峰");
}

private void LearningJavaWeb() {
System.out.println("java web知识获取");

}

private void LearningJavaSE() {
// TODO Auto-generated method stub
System.out.println("java基础知识获取");
}
/**
* 方法功能说明：  钩子方法是否没日没夜编码
*/
protected boolean isOverTimeCoding(){
return false;
}
}

/**
* @类功能说明：  子类继承模版类实现抽象方法
* @作者：Travel
* @版本：V1.0
*/
public class CodeFarmer extends LearningJava {
private boolean isOverTimeCoding;
public CodeFarmer(boolean isOverTimeCoding) {
// TODO Auto-generated constructor stub
this.isOverTimeCoding = isOverTimeCoding;
}

/* (non-Javadoc)
* @see com.utils.LearningJava#Coding()
*/
@Override
protected void Coding() {
// TODO Auto-generated method stub
System.out.println("敲代码，努力工作！！！");
}

/* (non-Javadoc)
* @see com.utils.LearningJava#OverTimeCoding()
*/
@Override
protected void OverTimeCoding() {
// TODO Auto-generated method stub
System.out.println("没日每夜的敲代码，加油加油！！！");
}
//重写钩子方法控制模版中子类方法是否执行
        protected boolean isOverTimeCoding(){
return isOverTimeCoding;
}
}

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
LearningJava learningJava = new CodeFarmer(true);
learningJava.LearningJavaTemplate();
learningJava = new CodeFarmer(false);
learningJava.LearningJavaTemplate();
}

}

3适配器模式

适配器模式主要作用是将目标接口转换成满足客户需求的接口，使得原本不兼容的接口能够正常工作，适配器模式分为类适配和对象适配

示例主要代码

1类适配

public class Source {

public void method1() {
System.out.println("this is original method!");
}
}

public interface Targetable {

/* 与原类中的方法相同 */
public void method1();

/* 新类的方法 */
public void method2();
}

public class Adapter extends Source implements Targetable {

@Override
public void method2() {
System.out.println("this is the targetable method!");
}
}

public class AdapterTest {

public static void main(String[] args) {
Targetable target = new Adapter();
target.method1();
target.method2();
}
}

输出：

this is original method!

this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能。

2对象适配

public class Wrapper implements Targetable {

private Source source;

public Wrapper(Source source){
super();
this.source = source;
}
@Override
public void method2() {
System.out.println("this is the targetable method!");
}

@Override
public void method1() {
source.method1();
}
}

public class AdapterTest {

public static void main(String[] args) {
Source source = new Source();
Targetable target = new Wrapper(source);
target.method1();
target.method2();
}
}

输出结果是一样的，只是这里将Adapter换成了Wrapper

3策略模式

策略模式指的是将常用方法抽象成一个策略接口通过对策略接口不同类实现不同功能供调用

示例代码

/**
* @类功能说明： 策略接口
* @作者：sao_ma
* @版本：V1.0
*/
public interface Istrategy {
/**
* 方法功能说明： 做事方法
*/
public void doing();
}

/**
* @类功能说明：  选择框架
* @作者：sao_ma
* @版本：V1.0
*/
public class ChoiceFrame implements Istrategy {

/* (non-Javadoc)
* @see com.strategy.Istrategy#doing()
*/
@Override
public void doing() {
// TODO Auto-generated method stub
System.out.println("选择框架");
}

}

/**
* @类功能说明：  编码
* @作者：sao_ma
* @版本：V1.0
*/
public class Coding implements Istrategy {

/* (non-Javadoc)
* @see com.strategy.Istrategy#doing()
*/
@Override
public void doing() {
// TODO Auto-generated method stub
System.out.println("编码");
}

}

/**
* @类功能说明：  上线
* @作者：sao_ma
* @版本：V1.0
*/
public class GoOnline implements Istrategy {

/* (non-Javadoc)
* @see com.strategy.Istrategy#doing()
*/
@Override
public void doing() {
// TODO Auto-generated method stub
System.out.println("上线");
}

}

/**
* @类功能说明：  控制策略
* @作者：sao_ma
* @版本：V1.0
*/
public class Center {
private Istrategy istrategy;

public Center(Istrategy istrategy) {
this.istrategy = istrategy;
};
public void doing(){
istrategy.doing();
}
}

public class Test {
public static void main(String[] args) {
Center center = new Center(new ChoiceFrame());
center.doing();
center = new Center(new Coding());
center.doing();
center = new Center(new GoOnline());
center.doing();
}
}

这个策略实现的开发项目需要选择框架、编码、上线，特点是高内聚低耦合，如果有需求只需要继续添加策略实现即可如为我们的项目添加测试阶段等等。