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

水深无声 2021-12-04 09:31 375阅读 0赞

### 文章目录 ###

*  模板设计模式
 *   *   *  1.定义
         *  2.实现
         *  3.钩子方法
 *  工厂设计模式
 *   *  一、简单工厂模式
     *   *  1.特点
         *  2.结构图
         *  3.实现
     *  二、工厂方法模式
     *   *  1.特点
         *  2.结构图
         *  3.实现
 *  代理设计模式
 *   *   *  1.特点
         *  2.本质
         *  3.实现

# 模板设计模式 #

### 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.结构图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70]

### 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.结构图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 1]

### 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() ;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70]: /images/20211204/961fd4f5a7ec446c8b8e7729e6cfd310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BlcmZlY3RtYXRjaF9H_size_16_color_FFFFFF_t_70 1]: /images/20211204/cf266692dcbe4c168cfe1b839f367af8.png