模板方法模式

通过抽象类实现模块化

简介：

前期准备工作及功能放在抽象类中，让子类去实现它特有的功能。

比如，咱们需要创建一个用户类，再创建一个抽象类，在抽象类写好判断方法，用户类继承方法即可，在用户类中只需实现它特有的功能。

代码块

public class test1 {
    public static void main(String[] args){
        yonghu yh = new yonghu();
        yh.yanzheng("admin","add");
    }
}
abstract class chouxiang{			//抽象类
    public void yanzheng(String name,String mod){
        if("admin".equals(name)){
            zhixing(mod);
        }else{
            System.out.println("你没有操作权限");
        }
    }
    public abstract void zhixing(String mod);	
}

class yonghu extends chouxiang{			//用户类
  	//继承方法并实现
    public void zhixing(String mod){	
        if ("add".equals(mod)){
            System.out.println("执行添加");		//这里我们可以代替相关代码
        }else if("del".equals(mod)){
            System.out.println("执行删除");		//这里我们可以代替相关代码
        }
    }
}

//最后输出结果为：执行添加

优点

• 用户类专心做自己相关的功能即可，用户是否有权限这些判断让抽象类来实现，
• 形成一个简单的骨架，代码清晰易懂，容易维护。

策略模式

简介：

策略模式定义了一系列算法，讲每一种算法封装起来并可以相互替换使用，策略模式让算法独立于使用它的客户应用而独立变化。

代码块

public class test2 {
    public static void main(String[] args) {
        user us = new user();
        us.setIsave(new Netsave());
        us.add("user");
    }
}

interface Isave{        //接口
    public void save(String data);
}
class Filesave implements Isave{		//实现接口的类（实现文件保存）
    public void save(String data){
        System.out.println("把数据保存到文件中。。。"+data);
    }
}
class Netsave implements Isave{			//实现接口的类（实现网络保存）
    public void save(String data){
        System.out.println("把数据保存到网络上。。。"+data);
    }
}
abstract class chouxiangsave{		//抽象类

    private Isave isave;		//定义接口类
  	//setIsave方法是让我们选择子类，也就是文件保存还是网络保存。
    public void setIsave(Isave isave){		
        this.isave = isave;
    }
  	//add方法是通过咱们选择的保存类型，把数据保存到相应的位置
  	//比如上面的setIsave选择的是文件保存，那这里把数据保存到文件中。
    public void add(String data){
        System.out.println("检查数据合法性...");
        isave.save(data);
        System.out.println("数据保存完毕。。。");
    }
}
class user extends chouxiangsave{

}

代码分析

此代码巧妙的把接口，抽象类运用的非常完美。接下来我们说一下代码的结构

• 创建一个接口Isave类，里面有save方法

                interface Isave{        //接口
                    public void save(String data);
                }

• save方法由Filesave和Netsave两个类来实现
• 再创建一个抽象类chouxiangsave，

                这个类的作用是整理组合并构建接口类

• 在chouxiangsave类中定义一个接口，Isave

                private Isave isave;        //定义接口类

• 通过setIsave方法，给出一个选择窗口，让我们选择保存数据类型

                //setIsave方法是让我们选择子类，也就是文件保存还是网络保存。
                 public void setIsave(Isave isave){        
                       this.isave = isave;
                  }

• 通过add方法，根据上一步选择的保存类型，保存到相应的位置。

        //add方法是通过咱们选择的保存类型，把数据保存到相应的位置
      //比如上面的setIsave选择的是文件保存，那这里把数据保存到文件中。
                    public void add(String data){
                        System.out.println("检查数据合法性...");
                        isave.save(data);
                        System.out.println("数据保存完毕。。。");
                    }

• 再创建一个chouxiangsave的子类user类，让它继承chouxiangsave类

所有工作完成之后，在main方法中：

• 先创建user类，

                user us = new user();

• 后选择保存类型，选择类型时要new一个Filesave类或Netsave类

                us.setIsave(new Netsave());

• 再把数据保存。直接把数据传递就可以了。

                us.add("user");

知识点

• 少用继承，多用组合
• 抽象类和接口组合

简单工厂模式

简介：

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，简单工厂模式是工厂模式家族种最简单实用的模式

代码块：

public class test3 {
    public static void main(String[] args) {
        Shengchan ft = Factory.ch("phone");
        ft.work();
    }
}

class Factory{		//工厂
    public static Shengchan ch(String name){
        if ("phone".equals(name)){
            return new Phone();		//如果要求生产手机，返回new Phone
        }else if("computer".equals(name)){
            return new Computer();	//如果要求生产电脑，返回new Computer
        }
        return null;		//如果要求生产别的东西，返回null
    }
}

interface Shengchan{		//生产机器
    public void work();
}
class Phone implements Shengchan{		//产品（手机）
    public void work(){
        System.out.println("手机在工作。。。");
    }
}
class Computer implements Shengchan{	//产品电脑
    public void work(){
        System.out.println("电脑在工作。。。");
    }
}

代码分析：

此代码主要是通过工厂类Factory来控制生产物品的种类，main方法只需提供要生产的产品即可，工厂根据提供的产品进行分类，根据要求生产不同产品，生产机器(接口Shengchan)提供方法，各条生产线（Phone类和Computer类）根据产品类型生产自己特定的产品即可。

• 首先编写Shengchan接口，

                interface Shengchan{        //生产机器
                    public void work();
                }

• 再编写phone类和Computer类并实现接口中的work方法

class Phone implements Shengchan{        //产品（手机）
    public void work(){
        System.out.println("手机在工作。。。");
    }
}
class Computer implements Shengchan{    //产品电脑
    public void work(){
        System.out.println("电脑在工作。。。");
    }
}

• 编写一个工厂类Factory
• 在工厂类中编写一个以返回值为接口类，参数为产品的方法 
• 在方法中判断产品类型，根据类型返回相应的生产线（Phone类或Computer类） 

class Factory{		//工厂
    public static Shengchan ch(String name){
        if ("phone".equals(name)){
            return new Phone();		//如果要求生产手机，返回new Phone
        }else if("computer".equals(name)){
            return new Computer();	//如果要求生产电脑，返回new Computer
        }
        return null;		//如果要求生产别的东西，返回null
    }
}

所有准备工作完成之后在main方法中：

• 创建生产类，新建工厂类并赋给生产类

• 开始生产工作

静态代理模式

简介：

        为其他对象提供一种代理以控制对这个对象的访问。说白了就是”真实对象”的代表，在访问对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。

代码块：

public class test4 {
    public static void main(String[] args) {
        jiekou jk = new user2();
        jiekou dl = new daili((user2) jk);
        dl.work();
    }
}

class daili implements jiekou{		//代理类
    public user2 s2;
    public daili(user2 s2){
        this.s2 = s2;
    }
    public void work(){
        int kaishi = 0;
        s2.work();
        int jieshu = 5;
        System.out.println("共用时"+(jieshu - kaishi));
    }
}

interface jiekou{		//接口类
    public void work();
}
class user2 implements jiekou{		//用户类
    public void work(){
        System.out.println("工人在工作...");
        System.out.println("工人工作完毕。");
    }
}

代码分析：

        此代码主要是把用户类中的一些特殊功能交给代理类来完成，比如，工人在工作，需求是计算工人工作时间，此时咱们创建一个代理类，在代理类中创建用户类，让代理类也去实现接口，并在类中实现，实现过程中调用用户类中的work方法，并在调用的代码前后放上计时器，从而得到工人工作时间。

1. 编写接口，接口中创建work方法
2. ​ 编写用户类，并实现接口work方法
3. ​ 编写代理类，在类中创建用户类
4. ​ 代理类实现接口中的work方法
5. ​ 在方法中调用用户类work方法

所有准备做好之后在man方法中：

• 创建用户类，（可用接口创建）

                jiekou jk = new user2();

• ​ 创建代理类，并把刚创建的用户类递给代理类

                jiekou dl = new daili((user2) jk);

• ​ 通过代理类调用work方法

                dl.work();

适配器模式

简介：

        将一个类的接口转换成客户希望的另一个接口，适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

代码块：

public class test5 {
    public static void main(String[] args) {
        PowerA pwa = new PowerAcharu();
        work(pwa);
        PowerB pwB = new PowerBcharu();
        //work(pwB);		//无法传递参数，因为在静态方法work中的参数必须为PowerA类型
        peizhiqi pzq = new peizhiqi(pwB);
        work(pzq);
    }
    public static void work(PowerA pwa){
        pwa.charu();
    }
}
class peizhiqi implements PowerA{
    private PowerB pwb;
    public peizhiqi(PowerB pwb){
        this.pwb = pwb;
    }
    public void charu(){
        System.out.println("电源B正在工作。。。");
    }
}

interface PowerB{
    public void charu();
}
class PowerBcharu implements PowerB{
    public void charu(){
        System.out.println("电源B正在工作");
    }
}

interface PowerA{
    public void charu();
}
class PowerAcharu implements PowerA{
    public void charu(){
        System.out.println("电源A正在工作");
    }
}

代码分析：

        此代码解决了在两个接口当中，无法兼容的问题。就比如在main方法中想通过work方法执行接口B,但work方法只给接口A提供了参数，这个时候我们就用"适配器"类，把接口B转换成A，在main方法中调用并递给work方法，此时work方法也能接受接口B了。

1. 先创建PowerA接口，
2. ​ 让PoweAcharu类实现接口PowerA
3. ​ 在test类中编写一个静态方法work,参数为PowerA
4. ​ 在work方法中调用charu方法
5. ​ 在main方法中创建PowerA类
6. ​ 调用work方法并发刚创建的类递过去。

此时出现第二个接口接口B。

1. 创建PowerB接口
2. ​ 让PowerBcharu类实现接口PowerB
3. ​ 在main方法中创建PowerB类
4. ​ 调用work方法并把创建的B类递过去

这个时候代码报错了，是因为work方法中参数只能是PowerA,所以：

1. 创建peizhiqi类，并实现接口PowerA
2. ​ 在类中创建接口PowerB
3. ​ 创建构造方法。
4. ​ 重写方法。

        此时peizhiqi类实现的是PowerA类，所以也算是PowerA，但在实现过程中创建的是PowerB,所以我们把配置器创建的数据可以理解为用PowerA封装起来的PowerB,所以work方法可以使用

        在main方法中：

• 创建peizhiqi类，并把上次创建的PowerB传递过去

                peizhiqi pzq = new peizhiqi(pwB);

• 调用work方法并把PowerB封装好的peizhiqi传递给work方法。

                work(pzq);

适配器的另一种用法：

        当我们创建的接口中有多个方法，要实现它的类需要实现接口中的所有方法，而该类只想实现接口方法中的一种或部分方法，可以用适配器来实现接口，并实现方法时用空方法来实现，然后让类继承适配器，想用哪个方法，直接重写就可以了。

代码块：

interface jiekou2{
    public void run();
    public void cry();
    public void swim();
}
abstract class shipeiqi implements jiekou2{
    public void run(){}
    public void cry(){}
    public void swim(){}
}
class Animal extends shipeiqi{
    //重写run()方法
    public void run(){
        System.out.println("动物在奔跑。。。");
    }
}