java设计模式的分类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、                     访问者模式、中介者模式、解释器模式。

策略模式是一种行为型模式，对行为做抽取封装成接口，形成一个行为算法族，提高对象行为灵活切换，减少传统方式的代码冗余，提高代码的可维护性

具体方式：把不同的行为的封装成一个接口，不同行为的实现交由实现接口的子类，不同子类分别实现一种行为，在超类中放入对象的引用，对象类实现超类

问题：现在有WQL和外资合资的汽车制造厂，他们制造的汽车有福特野马，雷克萨斯，马自达，野马和雷克萨斯使用的发动机类型是涡轮发动机，马自达使用的是转子发动，野马有尾翼，雷克萨斯和马自达没有，野马是3系，马自达是5系，雷克萨斯是三系

传统解决方式：创建一个超类定发动机类型，是否有尾翼，系别的抽象方法，子类福特野马，雷克萨斯，马自达分别继承重写超类实现目的

public class tradition {
    public static void main(String[] args) {
        automobileplant wql1=new lkss();
        automobileplant wql2=new mazda();
        automobileplant wql3=new yema();
    }
}

abstract class automobileplant{
    abstract public void engine();         //发动机
    abstract public void sfempennage();   //尾翼
    abstract public void department();    //系别
        }
class lkss extends automobileplant{
    @Override
    public void engine() {
        System.out.print("雷克萨斯：涡轮发动机");
    }
    @Override
    public void sfempennage() {
        System.out.print(",没有尾翼");
    }
    @Override
    public void department() {
        System.out.println("，三系");
    }
}

class mazda extends automobileplant{
    @Override
    public void engine() {
        System.out.print("马自达：转子发动机");
    }
    @Override
    public void sfempennage() {
        System.out.print(",没有尾翼");
    }
    @Override
    public void department() {
        System.out.println("，五系");
    }
}

class yema extends automobileplant{
    @Override
    public void engine() {
        System.out.print("野马：涡轮发动机");
    }
    @Override
    public void sfempennage() {
        System.out.print(",有尾翼");
    }
    @Override
    public void department() {
        System.out.println("，三系");
    }
}

这样代码的冗余严重，如果再加其他对象类，重复代码写着都难受，有没有方法将不同的行为分别抽取出来，提高复用性，这样策略模式就来了

策略模式的解决思路：定义一类行为的集成接口，如发动机，系别，是否有尾翼，分别创建接口，再创建子类分别实现一类接口的不同行为，如：A类实现发动机，它是转子发动机，B类实现发动机接口，是涡轮发动机，再创建一个超类里面放入接口的引用，如：汽车工厂超类定义发动机等的引用，子类继承超类自己调节自己的行为

没写全，这样理解没错，

public class strategy {
    public static void main(String[] args) {
        carplant1 j=new lkssw();
        j.name();
        j.td();
        j.td1();

    }
}
//定义超类，汽车工厂类
abstract class carplant1{
    //两个接口引用，之后用多态，实现其具体子类
    engine a;
    department b;
    abstract public void  name();

    public void td(){
        if(a!=null){
            a.enginetype();
        }
    }
    public void td1(){
        if(b!=null){
            b.departmenttype();
        }
    }}

     class lkssw extends carplant1{
        public  lkssw(){
           super. a=new WQL1();
           super. b=new WQL3();
        }
        @Override
        public void name() {
            System.out.print("雷克萨斯:");
        }

    }

//把变化的行为抽象成接口(这是函数式接口)
//把发动机的行为提取，由子类实现
interface engine{
    abstract public void enginetype();
}
//WQL1,WQL2分别实现engine接口
class WQL1 implements engine{
    @Override
    public void enginetype() {
        System.out.print("使用涡轮发动机,");
    }
}
class WQL2 implements engine{
    @Override
    public void enginetype() {
        System.out.print("使用转子发动机,");
    }
}
interface department{//把系别的行为提取，由子类实现
    abstract public void departmenttype();
}
//WQL3,WQL4分别实现department接口
   class WQL3 implements department{
@Override
public void departmenttype() {
        System.out.print("三系");
        }
        }
class WQL4 implements department{
    @Override
    public void departmenttype() {
        System.out.print("四系");
    }
}

 

lambda表达式的写法

 

 

public class strategy {
    public static void main(String[] args) {
        carplant1 j=new lkssw();
        j.name();
        j.td(()->{System.out.print("涡轮发动机,");});
        j.td1(()->{System.out.print("三系");});

    }
}
//定义超类，汽车工厂类
abstract class carplant1{

    abstract public void  name();

    public void td( engine a){
        if(a!=null){
            a.enginetype();
        }
    }
    public void td1(department v){
        if(v!=null){
           v.departmenttype();
        }
    }}

     class lkssw extends carplant1{
        public  lkssw(){


        }
        @Override
        public void name() {
            System.out.print("雷克萨斯:");
        }

    }

@FunctionalInterface
interface engine{
    abstract public void enginetype();
}

@FunctionalInterface
interface department{//把系别的行为提取，由子类实现
    abstract public void departmenttype();
}