一、设计模式概念

1、定义

? Java包含23种设计模式，是一套对代码设计经验的总结，被人们反复利用，多人熟知的代码设计方式。

2、目的：

? 为了提高代码的可读性，可扩展性以及代码的复用性 ，为了解决在写代码过程中遇到的代码设计问题。

3、设计模式的六大原则

? 3.1 开闭原则： 对扩展开发，对修改关闭（尽可能对代码少修改）

? 3.2 里式替换原则： 它是面向对象基本原则之一，任何父类（基类）出现的地方，子类都可以出现，也就是子类可以替换父类的任何功能（体现了父类的可扩展性）

? 3.3 依赖倒转原则 ： 尽可能面向接口编程， 依赖接口而不依赖类

? 3.4 接口隔离原则： 一个类如果能实现多个接口，尽可能实现多个 ，为了降低依赖，降低耦合

? 3.5 最少知道原则： 一个实体尽可能少的与其他实体产生相互关联关系，将实体的功能独立

? 3.6 合成复用原则： 尽量使用合成，聚合的方式，而不使用继承

4、设计模式的分类：

1、创建型模式（5个）

? 工厂方法模式、 抽象工厂模式、单例模式， 建造者模式，原型模式

2、结构型模式（7个）

? 适配器模式，装饰模式，代理模式，外观模式，桥接模式，享元模式，组合模式

3、行为型模式（11个）

? 策略模式，模板方法模式，观察者模式，迭代子模式 ，责任链模式，命令模式，状态模式，访问者模式，中介模式，解释器模式，备忘录模式

?

5、单例模式

单例模式是创建对象的一种特殊方式，程序从始至终都只创建一个对象叫单例（单实例）

分为两类

1、懒汉式单例

public class Person {
    // 为了不让其他类直接访问该成员  懒汉式单例，在使用时创建对象
    // 1 私有静态变量
    private static Person person=null;
    //2、将构造器私有化
    private Person (){
    }
    //3 提供一个静态的方法，并可返回该类的对象
    public static Person getInstance(){
        if(person==null){ // 第一次访问
            person = new Person();
        }
        return person;
    }
    public void sayHello(){
        System.out.println("sayHello方法");
    }
}

2、饿汉式单例

public class Student {
    //1、 饿汉式单例模式，  在类加载时创建一个对象
    private static Student student = new Student();
    // 2 构造器私有化
    private Student(){
    }
    // 3 提供返回类对象的静态方法
    public static Student getInstance(){
        if(student !=null){
            return student;
        }
         return null;
    }
}

6、工厂方法模式

? 创建对象的过程不再由当前类实例化，而是由工厂类完成 ，在工厂类中只需要告知 对象类型即可。 工厂模式中必须依赖接口

1、简单工厂模式

? 以生产 “电脑 ” 为例，电脑有办公的功能 ， 可以生产一体机 或 笔记本

代码与静态工厂一样

? 2、静态工厂模式

  /**
     * 简单工厂模式
     * @param type
     * @return
     */
//创建一体机与笔记本的共同接口 Computer
public interface Computer {
    //创建方法work：电脑办公 
    public void work(); 
}
//创建私人电脑类 PersonComputer 实现接口 Computer 
public class PersonComputer implements  Computer{
    @Override  //重写 实现接口方法
    public void work() {
        System.out.println("这是笔记本电脑，正在办公");
    }
}
//创建一体机类 workComputer 实现接口方法
public class WorkComputer implements  Computer{
    @Override   //重写 实现接口方法
    public void work() {
        System.out.println("这是一体机正在办公");
    }
}
//创建工厂类 CompuerFactory
public class ComputerFactory {
    /**
     * 根据不同的类型 生产不同的产品
     * @param type
     * @return
     */
    public Computer produce(String type){
        Computer computer =null;   //定义一个空对象
        if(type.equals("personComputer")){  //判要断实现的对象
            computer = new PersonComputer();   //实现对象的赋值，获取要实现的对象
        }else if(type.equals("workComputer")){
            computer = new WorkComputer();
        }else{
            System.out.println("不能生产");
        }
        return computer;  //返回获得的对象
    }
    
     /**
     *  静态工厂方法
     * @param type
     * @return
     */
    public static Computer produce(String type){
        // 定义一个接口的引用    通过接口new 一个实现类的对象
        // 提高扩展性
        Computer computer=null;
         if(type.equals("workComputer")){
             computer = new WorkComputer();
         }else if(type.equals("personComputer")){
             computer = new PersonComputer();
         }else{
             System.out.println("不能创建对象");
         }
         return computer;
    }
}
//测试实现 简单工厂模式与静态工厂方法
public class Test1 {
 public static void main(String[] args) {
         // 通过工厂类创建对象
        ComputerFactory factory = new ComputerFactory();//通过工厂创建对象
        // 要对象 找工厂  （简单工厂模式）
        Computer computer1 = factory.produce("workComputer"); //通过工厂方法获取要调用的对象
        computer1.work();  //由返回获得的对象调用它的方法  
        // 创建笔记本
        Computer computer2 = factory.produce("personComputer");
        computer2.work();
     
        //静态的方法调用，不需要通过工厂new对象来调用方法，可直接调用工厂方法获取要实现的对象 （静态工厂模式）
        Computer computer3 = ComputerFactory2.produce("workComputer");
        computer3.work();
 }
}

? 3、工厂方法模式

//创建BMWCar类与AudiCar类共同接口Car
public interface Car {
    public void  showInfo();
}
//创建AudiCar类
public class AudiCar implements Car {
    @Override
    public void showInfo() {
        System.out.println("这是一台奥迪汽车。。");
    }
}
//创建BMWCar类
public class BMWCar implements Car {
    @Override
    public void showInfo() {
        System.out.println("这是一台宝马汽车。");
    }
}
/**
生产汽车的工厂接口 CarFactory
**/
public interface CarFactory {
    public Car produce();
}
//创建工厂接口的实现类AudiCarFactory
public class AudiCarFactory implements  CarFactory {
    @Override
    public Car produce() {
        return  new AudiCar();// 这里AudiCar是Car的实现类（要调用方法需要的对象）；返回要调用的对象
    }
}
//创建工厂接口的实现类BMWCarFactory
public class BMWCarFactory implements CarFactory {
    @Override
    public Car produce() {
        return new BMWCar();// 因为BWMCar是Car的实现类
    }
}
//测试
 public class Test1 {
        public static void main(String[] args) {
            //先创建 汽车工厂 对象 
            CarFactory bmwFactory = new BMWCarFactory();
            // 通过工厂对象调用方法produce()来获取要调用的对象（返回值）
            Car bmw = bmwFactory.produce();  
            bmw.showInfo();    //通过获取的对象调用它的方法
    
            //这个模式对于同一级别的产品，可扩展性高
            //可以扩展不同品牌的汽车，此时不需要修改代码，只需要增加代码即可
            // 创建一个新的品牌汽车  大众汽车
    
            CarFactory dazhongFactory = new DazhongCarFactory();
            Car car = dazhongFactory.produce();
            car.showInfo();
        }
    }

7、抽象工厂模式

? 对于在工厂方法的基础上，对同一个品牌的产品有不同的分类，并对分类产品创建的过程 ，一个汽车产品 会分为不同的种类（迷你汽车 ， SUV汽车 ）

/**
 * 迷你汽车接口
 */
public interface MiniCar {
    public void showInfo();
}
//SUV汽车接口
public interface SUVCar {
    public void showInfo();
}
//迷你接口实现类（奥迪汽车：AudiMiniCar）
public class AudiMiniCar implements  MiniCar {
    @Override
    public void showInfo() {
        System.out.println("这是奥迪迷你汽车 ");
    }
}
//迷你接口实现类（宝马汽车：BMWMiniCar）
public class BMWMiniCar implements  MiniCar {
    @Override
    public void showInfo() {
        System.out.println("这是宝马Cooper迷你汽车");
    }
}
//SUV汽车接口实现类（奥迪汽车：AudiMiniCar）
public class AudiSUVCar implements  SUVCar {
    @Override
    public void showInfo() {
        System.out.println("这是一辆 奥迪SUV汽车");
    }
}
//SUV汽车接口实现类（宝马汽车：BMWMiniCar）
public class BMWSUVCar implements  SUVCar {
    @Override
    public void showInfo() {
        System.out.println("这宝马的SUV系列");
    }
}

//工厂接口
public interface CarFactory {
    //生成不同型号的汽车 ，两条产品线
    public MiniCar produceMiniCar();
    public SUVCar produceSUVCar();
}
//工厂接口的实现类（奥迪汽车：AudiCarFactoryr）
public class AudiCarFactory implements  CarFactory {
    @Override
    public MiniCar produceMiniCar() {  //迷你型汽车方法
        return new AudiMiniCar();  //返回对象AudiMiniCar()
    }
    @Override
    public SUVCar produceSUVCar() {  //SUV型汽车方法
        return new AudiSUVCar(); //返回对象AudiMiniCar()
    }
}
//工厂接口的实现类（宝马汽车：BMWCarFactory）
public class BMWCarFactory implements  CarFactory {
    // 生成迷你汽车的方法，返回MiniCar
    @Override
    public MiniCar produceMiniCar() {//迷你型汽车方法
        return new BMWMiniCar(); //返回对象BMWMiniCar()
    }
    //生成SUV汽车的方法， 返回SUVCar
    @Override
    public SUVCar produceSUVCar() {//SUV型汽车方法
        return new BMWSUVCar(); //返回对象BMWMiniCar()
    }
}
//测试：
public class Test1 {
    public static void main(String[] args) {
        //创建宝马迷你汽车  找工厂（创建工厂对象）
        CarFactory factory = new BMWCarFactory(); 
        MiniCar car = factory.produceMiniCar(); //通过工厂对象调用方法获取目标对象
        car.showInfo(); //通过获取的对象调用方法
    }
}

总结： 对于简单工厂， 工厂方法模式和抽象工厂的区别和用途

1、对于简单工厂（静态和非静态），用于生产同一结构中的任意产品，对于新增产品不适用。

2、对于工厂方法，在简单工厂的基础上，生产同一个等级结构中的固定产品，可以支持新增产品。

3、抽象工厂： 用于生产不同种类（品牌）的相同类型（迷你，SUV） ，对于新增品牌可以，不支持新增类型。

8、模板方法

? 定义：

? 模板方法是一种行为模式，父类的一个方法定义完成这个方法的步骤，但不具体实现具体细节，由子类完成各个步骤的实现，在创建子类对象时，最终的实现过程是子类的方法。

? 模板方法的准备：

? 1、继承关系

? 2、父类是抽象类 ：抽象类实现了模板方法，定义了算法的估计

3、子类继承抽象类：实现抽象方法，完成完整的算法

public abstract class AbstractPerson {
    /**
     *  定义一个模板方法，用于实现这个方法的基本“骨架”
     *  每一步骤的具体实现由子类完成
     */
    public void preparedSchool(){   
        getUp();
        dressing();
        eat();
    }
    //起床
    public abstract void getUp();
    //穿衣服
    public abstract void dressing();
    //吃早餐
    public abstract void eat();
}

public class Teacher extends  AbstractPerson {
    @Override
    public void getUp() {
        System.out.println("老师起床，7点半起床");
    }
    @Override
    public void dressing() {
        System.out.println("老师要衣服得体，穿工装");
    }
    @Override
    public void eat() {
        System.out.println("老师吃早餐。");
    }
}

public class Test1 {
    public static void main(String[] args) {
          Student stu = new Student();//创建学生类对象
          stu.preparedSchool();
          Teacher teacher = new Teacher(); //创建老师类对象
          teacher.preparedSchool();
    }
}