一个咖啡店可以提供大杯(jorumcoffee)、中杯(mediumcoffee)、小杯(smallcoffee)的咖啡(coffee)，为了满足不同用户的口味，在咖啡中可以添加牛奶(milk)，或者

糖(sugar)，或者两者都加，顾客可以根据自己的喜好选择不同的口味。此外，咖啡店还提供了各种口味的糕点(cake)，如巧克力蛋糕(chocolate cake)、芝士蛋糕(cheese cake)等，让顾客在品尝咖啡的同时，也可以享受到美味的甜点。咖啡店的环境也非常舒适，有舒适的座位和音乐，让顾客可以放松身心，享受一段美好的时光。

相关问题

一个咖啡店可以提供大杯(JorumCoffee)、中杯(MediumCoffee)、小杯(SmallCoffee )，一个咖啡店可以提供大杯(JorumCoffee)、中杯(MediumCoffee)、小杯(SmallCoffee )的咖啡(Coffee)，为了满足不同用户的口味，在咖啡中可以添加牛奶的咖啡(Coffee)，也可以不加，应用桥接模式实现

下面是一个可能的实现代码：

interface Coffee {
    String getName();
    double getPrice();
}

class JorumCoffee implements Coffee {
    @Override
    public String getName() {
        return "Jorum Coffee";
    }

    @Override
    public double getPrice() {
        return 5.0;
    }
}

class MediumCoffee implements Coffee {
    @Override
    public String getName() {
        return "Medium Coffee";
    }

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

class SmallCoffee implements Coffee {
    @Override
    public String getName() {
        return "Small Coffee";
    }

    @Override
    public double getPrice() {
        return 1.0;
    }
}

interface Additive {
    String getName();
}

class Milk implements Additive {
    @Override
    public String getName() {
        return "Milk";
    }
}

class Plain implements Additive {
    @Override
    public String getName() {
        return "Plain";
    }
}

class CoffeeWithAdditive implements Coffee {
    private Coffee coffee;
    private Additive additive;

    public CoffeeWithAdditive(Coffee coffee, Additive additive) {
        this.coffee = coffee;
        this.additive = additive;
    }

    @Override
    public String getName() {
        return coffee.getName() + " with " + additive.getName();
    }

    @Override
    public double getPrice() {
        return coffee.getPrice() + 0.5;
    }
}

public class CoffeeTest {
    public static void main(String[] args) {
        Coffee coffee = new JorumCoffee();
        System.out.println(coffee.getName() + ": " + coffee.getPrice());
        coffee = new CoffeeWithAdditive(coffee, new Milk());
        System.out.println(coffee.getName() + ": " + coffee.getPrice());
        coffee = new CoffeeWithAdditive(coffee, new Plain());
        System.out.println(coffee.getName() + ": " + coffee.getPrice());
    }
}

这段代码实现了一个简单的咖啡店，其中有三种不同大小的咖啡，以及两种不同口味的添加剂（牛奶和不加）。通过桥接模式，可以将咖啡和添加剂分别抽象成两个独立的类，在运行时动态地组合起来，实现不同口味的咖啡。在这个例子中，构造了一个具有 Jorum 咖啡和牛奶口味的 CoffeeWithAdditive 对象，它的价格为 5.5 元。

桥接模式大杯咖啡和中杯咖啡

桥接模式是一种设计模式，它将抽象部分与其实现部分分离，使它们可以独立地变化。在咖啡店中，可以使用桥接模式来实现不同大小的咖啡杯。

假设我们有两种咖啡：大杯咖啡和中杯咖啡。它们共享相同的基本咖啡成分，但它们的大小不同。

首先，我们需要定义一个抽象咖啡类，它包含制作咖啡的基本方法：

public abstract class Coffee {
    protected CoffeeSize coffeeSize;
    
    public Coffee(CoffeeSize coffeeSize) {
        this.coffeeSize = coffeeSize;
    }
    
    public abstract void makeCoffee();
}

其中，`CoffeeSize` 是一个枚举类型，表示咖啡的大小：

public enum CoffeeSize {
    SMALL, MEDIUM, LARGE;
}

接下来，我们定义两个具体的咖啡类，它们继承自抽象咖啡类，并分别实现 `makeCoffee()` 方法：

public class LargeCoffee extends Coffee {
    public LargeCoffee(CoffeeSize coffeeSize) {
        super(coffeeSize);
    }
    
    @Override
    public void makeCoffee() {
        System.out.println("Making " + coffeeSize + " large coffee.");
    }
}

public class MediumCoffee extends Coffee {
    public MediumCoffee(CoffeeSize coffeeSize) {
        super(coffeeSize);
    }
    
    @Override
    public void makeCoffee() {
        System.out.println("Making " + coffeeSize + " medium coffee.");
    }
}

最后，我们定义一个咖啡店类，它包含制作咖啡的方法：

public class CoffeeShop {
    public void makeCoffee(Coffee coffee) {
        coffee.makeCoffee();
    }
}

现在，我们可以使用桥接模式来制作不同大小的咖啡了。例如：

CoffeeShop coffeeShop = new CoffeeShop();

Coffee largeCoffee = new LargeCoffee(CoffeeSize.LARGE);
coffeeShop.makeCoffee(largeCoffee);

Coffee mediumCoffee = new MediumCoffee(CoffeeSize.MEDIUM);
coffeeShop.makeCoffee(mediumCoffee);

输出结果为：

Making LARGE large coffee.
Making MEDIUM medium coffee.

这样，我们就使用桥接模式实现了不同大小的咖啡杯。由于抽象咖啡类与具体咖啡类分离，我们可以轻松地添加更多的咖啡类型，而不会影响现有的代码。