设计模式概述

————————————————————————————————
设计模式可以达到高内聚低耦合，可以有助于扩展
一般是有经验的，面向对象的工程师使用（C语言是面向过程的，没有设计模式）
是一种自发性的规范

工厂模式

首先，实现几个简单方法

无工厂模式代码：

public interface Fruit {
    void eaten();
}

public class Apple implements Fruit{
    @Override
    public void eaten() {
        System.out.println("苹果被吃了");
    }
}

public class Banana implements Fruit{
    @Override
    public void eaten() {
        System.out.println("香蕉被吃了");
    }
}

public class People {
//    想要去吃苹果香蕉
    public void eat(Fruit fruit){
        fruit.eaten();
    }
}

public class Main {
    public static void main(String[] args) {
        People zhang = new People();//People()调用构造函数,返回到zhang变量
        Apple apple = new Apple();//Apple()调用构造函数,返回到apple变量
        zhang.eat(apple);//小张吃苹果
        Banana banana = new Banana();
        zhang.eat(banana);//小张吃香蕉
    }
}

上面的模式是—>需要什么就new一>个什么样的对象—这样的话，new操作是自己写的—>如何把new的权利交给别人

实现让其他人提供水果——>创建一个工厂，提供一个方法，传入参数，进行水果的选择，这个”apple“字符串，可以是从任何地方获得的，就不用关心这个字符串是哪里来的了

简单工厂模式代码

public class FruitFactory {//静态工厂方法
    public static Fruit getFruit(String name){
        Fruit fruit;
        switch (name){
            case "apple":{
                fruit = new Apple();
                break;
            }
            case "banana":{
                fruit = new Banana();
                break;
            }
            default:{
                fruit = null;
                System.out.println("没有这种水果");
            }
        }
        return fruit;
    }
}

public class Main {
    public static void main(String[] args) {
        People zhang = new People();
        Fruit apple = FruitFactory.getFruit("apple");
//这个“apple”字符串，可以是从任何地方获得的，就不用关心这个字符串是哪里来的了
        zhang.eat(apple);
        Fruit banana = FruitFactory.getFruit("banana");
        zhang.eat(banana);
    }
}

简单工厂模式

• 优点：
  • 把创建的对象和当前程序（使用对象）分隔开
  • 高耦合变成低耦合
• 缺点：
  • 想新增加变量比较困难（比如新增一个水果peach）
    比如，想增加一个桃子

需要添加桃子的类
public class Peach implements Fruit{
    @Override
    public void eaten() {
        System.out.println("桃子被吃了");
    }
}
也需要在工厂类添加桃子的对象，这样比较复杂

所以想到了另一种解决方案就是抽象工厂

抽象工厂

做一个工厂的工厂，去创建一个创建简单工厂的工厂
（——>做一个工厂的工厂，来达到抽象工厂的功能）

抽象工厂模式（Abstract Factory Pattern）

• 是围绕一个超级工厂创建其他工厂。
• 该超级工厂又称为其他工厂的工厂。
• 这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
• 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。
• 每个生成的工厂都能按照工厂模式提供对象。
  抽象工厂优势：由工厂决定生产哪种类型，一般是针对多种类型，多个对象的时候

代码：

public interface Factory {
    Head createHead();
    Body createBody();
}

public class BlackFactory implements Factory{
    @Override
    public Head createHead() {
        return new BlackHead();
    }

    @Override
    public Body createBody() {
        return new BlackBody();
    }
}

public class RedFactory implements Factory{
    @Override
    public Head createHead() {
        return new RedHead();
    }
    @Override
    public Body createBody() {
        return new RedBody();
    }
}

public class Main {
    public static void main(String[] args) {
        People p = new People();
        Factory bf = new BlackFactory();
        //下面的由上面的工厂决定具体要实现哪种类型
        //上面是红色，下面生产的就是红色
        //上面是黑色，下面生产的就是黑色
        Body body = bf.createBody();
        Head head = bf.createHead();
    }
}

单例模式

当资源可以复用，而且程序里面只需要一个对象或枚举类等情况的时候，就可以使用单例模式。

单例模式特点：

构造函数自由化，其他地方不能创建它的对象，所以是单例
要求是线程安全的

建造者模式

多个简单对象构造出复杂对象的操作
方法：可以进行多种不一样的组合

缺点：种类太多的时候，组合太多，写代码太多

优点：组合灵活

建造者模式代码：

//条目
public interface Item {
    String name();
    Packing packing();
    double price();
}

//打包方式
public interface Packing {
    void pack();
}

//汉堡打包方式
public abstract class Burger implements Item{
    @Override
    public Packing packing() {
        return new Paper();
    }
}

//酒水种类
public abstract class Drink implements Item{
    @Override
    public Packing packing() {
        return new Bottle();
    }
}

//用瓶子包装
public class Bottle implements Packing{
    @Override
    public void pack() {
        System.out.println("用瓶子包装");
    }
}

//用纸包装
public class Paper implements Packing{
    @Override
    public void pack() {
        System.out.println("用纸包装");
    }
}

//雪花啤酒
public class XueHua extends Drink{
    @Override
    public String name() {
        return "雪花啤酒";
    }

    @Override
    public double price() {
        return 3.0;
    }
}

//素汉堡
public class SuBurger extends Burger{
    @Override
    public String name() {
        return "素汉堡";
    }
    @Override
    public double price() {
        return 5.0;
    }
}

//肉汉堡
public class MeatBurger extends Burger{
    @Override
    public String name() {
        return "肉汉堡";
    }

    @Override
    public double price() {
        return 8.0;
    }
}

//食物选择种类
public class Food {
    private ArrayList<Item> items = new ArrayList<>();
    public void addItem(Item item){
        items.add(item);
    }
    public double sumPrice(){
        return items.stream().mapToDouble(Item::price).sum();
    }
    public void showItems(){
        items.stream().forEach(e->{
            System.out.println(e.name());
            e.packing().pack();
            System.out.println(e.price());
        });
    }
}

//食物建造者
public class FoodBuilder {
    public Food SuFood(){
        Food food = new Food();
        food.addItem(new SuBurger());
        food.addItem(new XueHua());
        return food;
    }
    public Food MeatFood(){
        Food food = new Food();
        food.addItem(new MeatBurger());
        food.addItem(new XueHua());
        return food;
    }
    public Food allFood(){
        Food food = new Food();
        food.addItem(new SuBurger());
        food.addItem(new MeatBurger());
        food.addItem(new XueHua());
        return food;
    }
}

public class Main {
    public static void main(String[] args) {
        FoodBuilder builder = new FoodBuilder();
        Food haohua = builder.allFood();
        double cost = haohua.sumPrice();
        System.out.println("共花费：" + cost);
        haohua.showItems();
    }
}