Java 抽象类 Drink 示例：创建不同饮料类型，实现味觉描述和异常处理

本文将详细介绍如何使用 Java 抽象类 Drink 创建咖啡、啤酒和牛奶三种饮料类型，并通过实现味觉描述、异常处理和测试类来展示抽象类和继承的应用。

1. 建立抽象类 Drink

public abstract class Drink {
    public static final int COFFEE = 1;
    public static final int BEER = 2;
    public static final int MILK = 3;

    public abstract void taste();

    public static Drink getDrink(int drinkType) throws DrinkNotFoundException {
        switch (drinkType) {
            case COFFEE:
                return new Coffee('星巴克');
            case BEER:
                return new Beer('黄色');
            case MILK:
                return new Milk('新鲜');
            default:
                throw new DrinkNotFoundException('没有相应的饮料类型');
        }
    }
}

声明了三个常量 COFFEE、BEER 和 MILK 分别代表不同的饮料类型。
声明了抽象方法 taste()，该方法负责输出饮料的味道。
声明了静态方法 getDrink(int drinkType)，根据传入的参数创建不同的饮料对象，并返回该对象，建议使用 switch 语句。该方法要求声明 DrinkNotFoundException，当没有相对应的饮料类型时，抛出该异常。

2. 建立 Drink 的具体子类

2.1 Coffee 类

public class Coffee extends Drink {
    private String brand;

    public Coffee(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public void taste() {
        System.out.println('这是一杯' + brand + '咖啡，味道浓郁，带有一丝苦涩。');
    }
}

私有属性 brand 代表咖啡品牌。
带有 brand 属性参数的构造方法。
提供相应的 setter 和 getter 方法。
实现了 taste() 方法，要求在控制台打印咖啡的味道特征。

2.2 Beer 类

public class Beer extends Drink {
    private String color;

    public Beer(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public void taste() {
        System.out.println('这是一杯' + color + '啤酒，味道苦涩，带有一点点酸味。');
    }
}

私有属性 color 代表啤酒颜色。
带有 color 属性参数的构造方法。
提供相应的 setter 和 getter 方法。
实现了 taste() 方法，要求在控制台打印啤酒的味道特征。

2.3 Milk 类

public class Milk extends Drink {
    private String state;

    public Milk(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public void taste() {
        System.out.println('这是一杯' + state + '牛奶，味道甜美，带有一点点奶香。');
    }
}

私有属性 state 代表牛奶状态。
带有 state 属性参数的构造方法。
提供相应的 setter 和 getter 方法。
实现了 taste() 方法，要求在控制台打印牛奶的味道特征。

3. 建立异常类 DrinkNotFoundException

public class DrinkNotFoundException extends Exception {
    public DrinkNotFoundException(String message) {
        super(message);
    }
}

继承 Exception 类。
在 Drink 类的 getDrink(int drinkType) 方法中声明引发 DrinkNotFoundException 异常，当传入的参数没有相对应的饮料类型时，抛出异常。

4. 建立 Test 测试类

public class Test {
    public static void main(String[] args) {
        try {
            int drinkType = Integer.parseInt(args[0]);
            Drink drink = Drink.getDrink(drinkType);
            drink.taste();
        } catch (DrinkNotFoundException e) {
            System.out.println('没有相应的饮料类型');
        } catch (NumberFormatException e) {
            System.out.println('饮料类型必须是数字');
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println('请传入饮料类型');
        }
    }
}

编写 main 方法，通过命令行传参的方式传入某种饮料的类型。
在 main 方法中，调用 Drink 类的 getDrink 方法，获得相应的饮料对象。注意捕获 DrinkNotFoundException。
然后调用该饮料对象的 taste() 方法，输出该饮料的味道。

5. 编译程序并运行

$ java Test 1
这是一杯星巴克咖啡，味道浓郁，带有一丝苦涩。
$ java Test 2
这是一杯黄色啤酒，味道苦涩，带有一点点酸味。
$ java Test 3
这是一杯新鲜牛奶，味道甜美，带有一点点奶香。
$ java Test 4
没有相应的饮料类型
$ java Test a
饮料类型必须是数字
$ java Test
请传入饮料类型

通过以上代码和测试结果，我们可以看出，使用抽象类和继承可以很好地实现不同饮料类型创建、味觉描述和异常处理，并通过测试类验证其正确性。