其实在作为一个java coder 在写代码的过程中可能会比较随意，这显然不是很好的，我们还是适当可以优化优化，没有最好只有更好。
1、谈谈模板模式在项目中的使用
为什么要用它？模板模式我的理解就是把大部分逻辑在父类中实现，只有一小部分逻辑是根据各个子类来千变万化的。上例子：
public abstract class AbstractTemplate {
public void templateMethod(){
abstractMethod();
hookMethod();
concreteMethod();
}
protected abstract void abstractMethod();
protected void hookMethod(){}
}
public class ConcreteTemplate extends AbstractTemplate{
//基本方法的实现
@Override
public void abstractMethod() {
//业务相关的代码
}
}
总结：模板方法的目的就是该往上提的上到父类上去，该下放的就放到子类中去，如分页功能中判断页码部分就是通用的放在父类中，分页完后处理逻辑是不一样的放到每个子类中。
2、谈谈门脸模式在项目中的使用
为什么要用它？门脸模式我认为的就是尽量把功能块之间松耦合，小到类的功能调用大到各种系统之间的调用，如我最好只暴露一个对外系统给外部门或者外公司的人使用，所有对外的功能都放在这个对外系统中，至于对外系统中的接口在内部运转外部不需要知道。说白点就是一个前台，你去医院看病只需要找前台就好了，她会告诉你眼科、五官科、厕所在哪，而你不需要盲目的去直接到处乱跑乱走找你要去的地方。说远了，上例子：
public class ModuleA {
public void testA(){
System.out.println("调用ModuleA中的testA方法");
}}
public class ModuleB {
public void testB(){
System.out.println("调用ModuleB中的testB方法");
}}
public class Facade {
public void test(){
ModuleA a = new ModuleA();
a.testA();
ModuleB b = new ModuleB();
b.testB();
}
}
总结：门脸模式用于解耦还是不错的。
3、谈谈策略模式在项目中的使用
为什么要用它？编程首选面向接口编程、其次再是抽象类编程。策略模式就是把实体之间的共同的行为抽象为接口。说到这里我想谈谈我自己对于接口和抽象类的理解，接口表示实体之间共同的行为，抽象类可以表示共同的行为以外还可以有自己的特性，如fly这么个动作飞机可以有鸟类也可以有，这个时候fly（）应该是定义在接口中，像飞机可以载人，不同的机型可能载的人(客机、战斗机)不一样。小鸟可以讲鸟语，不能的鸟讲的语种可能(燕子、鸵鸟)不一样，这个时候载人、讲鸟语这种就可以定义在抽象类中，然后每个小种类去实现抽象类。还是上策略模式的例子吧：
public interface Strategy {
/**
* 策略方法
*/
public void strategyInterface();
}
public class ConcreteStrategyA implements Strategy {
@Override
public void strategyInterface() {
//相关的业务
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void strategyInterface() {
//相关的业务
}
}
public static void main(String[] args) {
Strategy strategyA = new ConcreteStrategyA();
strategyA.strategyInterface();
Strategy strategyB= new ConcreteStrategyB();
strategyB.strategyInterface();
}
总结：策略模式能清晰定义接口，另外还有一个好处就是很多地方可以传参Strategy strategy来实现不同实体之间的多态性，毕竟多态表现在同一个类里面是重载，父子类中则是重写实现。
4、谈谈责任链模式在项目中的使用
何为链？就是环环相扣有序执行，一个常用的场景是web service中的过滤器你可以配置多个过滤器来实现多重过滤。但我觉得它可以有另外一个衍生就是在于可以将所有的实现类随意组装后面会讲到。上例子：
public abstract class Handler {
protected Handler successor = null;
public Handler getSuccessor() {
return successor;
}
public void setSuccessor(Handler successor) {
this.successor = successor;
}
/**
* 处理聚餐费用的申请
* @param user 申请人
* @param fee 申请的钱数
* @return 成功或失败的具体通知
*/
public abstract String handleFeeRequest(String user , double fee);
}
public class ProjectManager extends Handler {
@Override
public String handleFeeRequest(String user, double fee) {
String str = "";
//项目经理权限比较小，只能在500以内
if(fee < 500)
{
//为了测试，简单点，只同意张三的请求
if("张三".equals(user))
{
str = "成功：项目经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";
}else
{
//其他人一律不同意
str = "失败：项目经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
}
}else
{
//超过500，继续传递给级别更高的人处理
if(getSuccessor() != null)
{
return getSuccessor().handleFeeRequest(user, fee);
}
}
return str;
}
}
public class DeptManager extends Handler {
@Override
public String handleFeeRequest(String user, double fee) {
String str = "";
//部门经理的权限只能在1000以内
if(fee < 1000)
{
//为了测试，简单点，只同意张三的请求
if("张三".equals(user))
{
str = "成功：部门经理同意【" + user + "】的聚餐费用，金额为" + fee + "元";
}else
{
//其他人一律不同意
str = "失败：部门经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";
}}
else{
//超过1000，继续传递给级别更高的人处理
if(getSuccessor() != null){
return getSuccessor().handleFeeRequest(user, fee);
}}
return str;
}
}
public static void main(String[] args) {
//先要组装责任链
Handler h2 = new DeptManager();
Handler h3 = new ProjectManager();
h3.setSuccessor(h2);
//开始测试
String test1 = h3.handleFeeRequest("张三", 300);
System.out.println("test1 = " + test1);
String test2 = h3.handleFeeRequest("李四", 300);
System.out.println("test2 = " + test2);
}
上面是很纯的责任链模式，其实用的场景不是特别多，因为它是走一遭下来只有一个功能会调用不满足情况的时候会继续找下一链这样遍历效率也不高。下面我就来讲讲衍生的责任链模式，就是通常讲的不是很纯的责任链模式：
public interface IHandler {
void process();
}
public class Test1Handler implements IHandler {
@Override
public void process() {
System.out.println("执行test1过程");
}
}
public class Test2Handler implements IHandler {
@Override
public void process() {
System.out.println("执行test2过程");
}
}
public static void main(String[] args) {Listlist = new ArrayList<>(2);
list.add(new Test1Handler());
list.add(new Test2Handler());
for(IHandler handler : list){
handler.process();
}
list.clear();
list.add(new Test2Handler());
list.add(new Test1Handler());
for(IHandler handler : list){
handler.process();
}}
sys结果：
行test1过程
执行test2过程
执行test2过程
执行test1过程
对于具体的实现可以借助集合、配置文件来灵活组装执行。
总结：我们在写代码的过程中也不一定严格按照23种模式去写，有的时候也会有一些变通。
最后总结：我想我不会把所有的模式都列出来我也不会照抄过来，只是列出一些在实际的项目中常用的，切记不要因为模式而模式那样感觉会太重了。设计模式的宗旨是啥？我认为提高拓展性、降低耦合、易维护、可读性强。
最后的最后，献丑了！！！
