JAVA中的几种设计模式及接口的定义和使用

一、 模板设计模式
** 开闭原则（OCP）:一个软件实体如类、模块和函数应该对外扩展开放、对修改关闭；
开闭原则是java世界中最基础的设计原则**。

概述
模板方法模式是类的行为模式。准备一个抽象类，将部分逻辑以具体方法以及具体构造函数的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。这就是模板方法模式的用意。比如定义一个操作中的算法的骨架，将步骤延迟到子类中。模板方法使得子类能够不去改变一个算法的结构即可重定义算法的某些特定步骤。
模式中的角色
抽象类（AbstractClass）：实现了模板方法，定义了算法的骨架。
具体类（ConcreteClass)：实现抽象类中的抽象方法，已完成完整的算法。
实例
我们以网上购物（OnlineShopping）为例，假设要分为七步：1、浏览商品（browseGoods）2、选择商品（selectGoods）3、客服服务（callService）4、结算（comupterPrice）5、支付（orderPay）6、配送服务(sendService) 7、查看订单（showOrder）。不同的网购平台要做的事情肯定不一样，如下：
代码如下：
abstract class OnlineShopping{
public final void browseGoods(){
System.out.println(“1、浏览商品”);
}
public final void selectGoods(){
System.out.println(“2、选择商品”);
}
public abstract void callService();
public final void computerPrice(){
System.out.println(“4、结算”);
}
public abstract void orderPay();
public abstract void sendService();
public final void showOrder(){
System.out.println(“7、查看订单”);
}
final void process(){
browseGoods();
selectGoods();
if(isCallService()){
callService();
}
computerPrice();
orderPay();
sendService();
showOrder();
}
public boolean isCallService(){ //钩子方法
return true;
}
}
class JD extends OnlineShopping{
@Override
public void callService() {
System.out.println(“3、你好，京东服务”);
}

@Override
public void orderPay() {
    System.out.println("5、微信支付");
}

@Override
public void sendService() {
    System.out.println("6、京东快递");
}

}
class Taobao extends OnlineShopping{
@Override
public void callService() {
System.out.println(“3、你好，淘宝客服”);
}

@Override
public void orderPay() {
    System.out.println("5、支付宝支付");
}

@Override
public void sendService() {
    System.out.println("6、圆通速递");
}

}
public class TestDemo{
public static void main(String[] args) {
JD jd = new JD();
jd.process();
System.out.println();
Taobao taobao = new Taobao();
taobao.process();
}
}
运行结果：

二、接口的定义与使用
要点提示： 接口是一种与类相似的结构，只包含 全局常量 和 抽象方法 。
接口在许多方面都与抽象类相似，但是它的目的是指明相关或者不相关类的多个对象的共同行为。例如，使用正确的接口，可以指明这些对象是可以比较的、可食用的、以及可克隆的。
在以后的开发过程中接口优先使用。
为了区分接口和类，java采用 interface 来定义接口：

下面是一个接口的例子：
public interface IMessage {
public static final String MSG= “I am a student”;//全局常量
public abstract void print();//抽象方法
}
接口的定义与使用的注意事项：
1、定义接口使用关键字 interface 接口名称使用 I 来表示；
2、接口定义的方法默认为抽象的（abstract）；
3、接口内不能有已经实现的方法；
4、接口不能进行实例化；
5、接口可以继承多个接口，此时的接口拥有了继承的接口里面的抽象方法；
6、如果一个抽象类继承了接口，那么抽象类当中可以不实现接口的方法，但是如果再有一个普通类继承了此抽象类，那么普通类一定实现接口和接口类里面的抽象方法。
接口的应用：
public interface IMessage {
public static final String MSg = “I am a student”;//全局常量
public abstract void print();//抽象方法
}
interface INews{
public abstract String getNews();
}
class MessageImpl implements IMessage,INews{
@Override
public void print() {
System.out.println(IMessage.MSg);
}

@Override
public String getNews() {
    return IMessage.MSg;
}

}

public class TestDemo{
public static void main(String[] args) {
IMessage m = new MessageImpl();
m.print();
INews n = (INews)m;
System.out.println(n.getNews());
}
}

三、工厂设计模式
工厂模式：主要用来实例化有共同接口的类，工厂模式可以动态决定应该实例化那一个类，简单来说工厂模式就是帮助我们来new对象的，为了避免直接对对象进行创建，而且把所有的对象都集中起来管理，也可以在不改动应用程序的基础上直接添加对象，便于对象的维护。
1.简单工厂模式，又叫静态工厂，是工厂模式三中状态中结构最为简单的。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。
实例:
对于一个机器来说，它有一个共同的工作就是work，假设 RedMachine只能生产红色的球，BlueMachine只能生产蓝色的球。
代码如下：


运行结果：

2、工厂方法
假如工厂还有其它的方法，比如维修。


3、 抽象工厂模式
工厂方法模式还是只能够制造制球机器，但是有可能生产汽车，生产食物，所以工厂的抽象类提供创建一系列的对象的接口。
//抽象工厂类
public interface AbstractFactory {
Car createVehicle();
Weapon createWeapon();
Food createFood();
}

//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory implements AbstractFactory{
@Override
public Food createFood() {
return new Apple();
}
@Override
public Vehicle createVehicle() {
return new Porsche();
}
@Override
public Weapon createWeapon() {
return new AK47();
}
}

四、代理设计模式
代理模式：两个子类共同完成一个接口的功能，其中一个子类负责真实的接口功能实现，另一个子类负责辅助真实功能
的完成。
目的：为其他对象提供一种代理以控制对这个对象的访问。
代理模式的本质：所有的真实业务操作都会有一个与之辅助的工具类（功能类）共同完成。

interface Subject{
void eat();
}

class RealSubject implements Subject{

@Override
public void eat() {
    System.out.println("eat food!");
}

}

class ProxySubject implements Subject{

private Subject sub;
public ProxySubject(Subject sub) {
    this.sub = sub;
}

public void preparation() {
    System.out.println("make food!");
}

public void postProcessing() {
    System.out.println("wash up!");
}

public void eat() {
    this.preparation();
    this.sub.eat();
    this.postProcessing();
}

}

class Factory{
public static Subject getInstance() {
return new ProxySubject(new RealSubject());
}
}
public class ProxyModeTest {
public static void main(String[] args) {
Subject sub = Factory.getInstance();
sub.eat();
}
}
输出结果：
make food!
eat food!
wash up!