Java模板设计模式&工厂设计模式&代理设计模式

模板设计模式

1.定义

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

2.实现

abstract class Beverage{
    final void prepareRecipe(){
        boilwater();
        brew();
        pourInCup();
        addCondiments();
    }
    abstract void addCondiments();
    abstract void brew();

    void boilwater(){
        System.out.println("烧水");
    }
    void pourInCup(){
        System.out.println("倒入杯中");
    }

}
class Coffee extends Beverage{
    @Override
    void addCondiments() {
        System.out.println("加糖和牛奶");
    }
    @Override
    void brew() {
        System.out.println("冲咖啡");
    }
}
class Tea extends Beverage{
    @Override
    void addCondiments() {
        System.out.println("加柠檬");
    }
    @Override
    void brew() {
        System.out.println("泡茶");
    }
}

public class test{
public static void main(String[]args){
    Tea tea = new Tea();
    tea.prepareRecipe();
    System.out.println("------------------");
    Coffee coffee = new Coffee();
    coffee.prepareRecipe();
    }
}

3.钩子方法

abstract class Beverage{
    final void prepareRecipe(){
        boilwater();
        brew();
        pourInCup();
        if(customerWant())
        addCondiments();
    }
    abstract void addCondiments();
    abstract void brew();

    void boilwater(){
        System.out.println("烧水");
    }
    void pourInCup(){
        System.out.println("倒入杯中");
    }
// 钩子方法
// 超类中通常是默认实现
// 子类可以选择性的覆写此方法
    boolean customerWant(){
        return true;
    }
}
class Coffee extends Beverage{
    @Override
    void addCondiments() {
        System.out.println("加糖和牛奶");
    }
    @Override
    void brew() {
        System.out.println("冲咖啡");
    }
}
class Tea extends Beverage{
    @Override
    void addCondiments() {
        System.out.println("加柠檬");
    }
    @Override
    void brew() {
        System.out.println("泡茶");
    }
    public boolean customerWant(){
        String answer = getUserInput();
        if (answer.equals("y")){
            return true;
        }else
            return false;
    }
    private String getUserInput(){
        String answer = null;
        System.out.println("请问您需要加柠檬吗？y/n");
        Scanner scanner = new Scanner(System.in);
        answer = scanner.nextLine();
        return answer;
    }
}

public class test{
public static void main(String[]args){
    Tea tea = new Tea();
    tea.prepareRecipe();
    System.out.println("------------------");
    Coffee coffee = new Coffee();
    coffee.prepareRecipe();
    }
}

工厂设计模式

一、简单工厂模式

1.特点

一个抽象产品类（接口）——computer
多个具体产品类——MacBook、surface
一个工厂（new操作在此工厂中进行）——客户端通过工厂类获取具体实例

2.结构图

3.实现

interface IComputer{
    void buyComputer();
}
class Factory{
    //此时Factory产生实例化对象没有意义，对外提供工具方法
    public static IComputer getInstance(String classname){
        if("MacBook".equals(classname)){
            return new Macbook();
        }else if("surface".equals(classname)){
            return new surface();
        }else
            return null;
    }
}
class Macbook implements IComputer{
    @Override
    public void buyComputer() {
        System.out.println("买macbook");
    }
}
class surface implements IComputer{
    @Override
    public void buyComputer() {
        System.out.println("买suface电脑");
    }
}
public class test{
public static void main(String[]args){
    IComputer computer = Factory.getInstance("MacBook");
    computer.buyComputer();
    }
}

二、工厂方法模式

1.特点

定义一个用来创建对象的接口，让子类决定实例化哪一个类。针对每个产品（产品族）提供一个工厂类，客户端需要判断使用哪个工厂。
a.一个抽象产品类
b.多个具体产品类
c.一个抽象工厂（针对抽象产品类）
d多个具体工厂（每个产品族拥有自己的工厂）

2.结构图

3.实现

interface IComputer{
    void buyComputer();
}
interface IComputerFactory{
    IComputer createComputer();
}
class MsFactory implements IComputerFactory{
    @Override
    public IComputer createComputer() {
        return new surface();
    }
}
class AppleFactory implements IComputerFactory{

    @Override
    public IComputer createComputer() {
        return new Macbook();
    }
}
class Macbook implements IComputer{
    @Override
    public void buyComputer() {
        System.out.println("买macbook");
    }
}
class surface implements IComputer{
    @Override
    public void buyComputer() {
        System.out.println("买suface电脑");
    }
}
public class test{
public static void main(String[]args){
    IComputer computer = new  MsFactory().createComputer();
    computer.buyComputer();
    }
}

代理设计模式

1.特点

两个子类共同实现同一个接口，其中一个子类负责真实业务实现，另外一个子类完成辅助真实业务主题的操作。

2.本质

所有的真实业务操作都会有一个与之辅助的工具类（功能类）共同完成。

3.实现

interface ISubject{
    void buyComputer();
}
class RealSubject implements ISubject{
    @Override
    public void buyComputer() {
        System.out.println("买一台笔记本电脑");
    }
}
class ProxySubject implements  ISubject{
    private ISubject iSubject;
    public ProxySubject(ISubject iSubject){
        this.iSubject = iSubject;
    }
    public void produceComputer(){
        System.out.println("生产一台笔记本电脑");
    }
    public  void afterSale(){
        System.out.println("笔记本售后");
    }
    @Override
    public void buyComputer() {
        this.produceComputer();
        this.iSubject.buyComputer();
        this.afterSale();
    }
}
class Factory {
    public static ISubject getInstance(){
        return new ProxySubject(new RealSubject()) ;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        ISubject subject = Factory.getInstance() ;
        subject.buyComputer() ;
    }
}