sell.java

这是一个面向对象编程教学案例的设计,同时附带一个餐厅计费程序的例子,并用java实现.同时附带类框图,说明模型的关系.

package com.fiberhome.ason.otnp.inputer.kang;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

/*   这是一个餐厅计费的小例子；餐厅经营普通食品，海鲜，酒水三大类食品，其享受的折扣不同；
 折扣分为 进餐等待折扣：  普通食品 8折，酒水 九折，海鲜不打折；
 VIP折扣：       总价8折；
 代金券折扣：    总价消费100，可使用50代金券；
 进餐等待折扣 和 VIP折扣 同时满足时，按照VIP计算；
 */

public class Sell
{
    public static void main(String[] args)
    {
        BillIO billIO = new BillIO();
        Discount discount=new NormalDiscount();
        Menu menu = new Menu(billIO);
        Count count = new Count(billIO,discount);
        boolean flag = true;
        while (flag)
        {
            DiscountCondition discountCondition = new DiscountCondition(billIO);
            ConsumeFoods consumeFoods=new ConsumeFoods(menu,billIO);
            count.printBill(consumeFoods, discountCondition);
            flag = billIO.getContinueState();
        }
    }

}

class Count
{
    // 折扣处理规则
    private Discount discount;

    private Output output;

    public Count(Output out,Discount dst)
    {
        initial(out,dst);
    }

    private void initial(Output out,Discount dst){
        output = out;
        discount = dst;
    }
    // 显示帐单
    public void printBill(ConsumeFoods consumeFoods,
            DiscountCondition discountCondition)
    {
        List<FoodStuff> consumeList=consumeFoods.getConsumeList();
        // 总消费费用
        double account = CountAccount(consumeList);
        // 折扣
        Map<String, Double> discountMap = countDiscount(consumeList,
                discountCondition);
        // 实际支付费用
        double payment = countPayment(account, discountMap);
        output.prtBill(consumeList, account, discountMap, payment);

    }

    // 根据消费清单，计算打折前消费总价格
    private double CountAccount(List<FoodStuff> consumeFoods)
    {

        double totalPrice = 0;
        for (FoodStuff food : consumeFoods)
        {
            totalPrice += food.getPrice();
        }
        return totalPrice;
    }

    private Map<String, Double> countDiscount(List<FoodStuff> consumeFoods,
            DiscountCondition discountCondition)
    {

        Map<String, Double> discountMap = new LinkedHashMap<String, Double>();
        double account = CountAccount(consumeFoods);
        if (discountCondition.isVIP())
        {
            discountMap.put(DiscountCondition.VIPStr, discount
                    .countVIPDiscount(account));
        }
        else if (discountCondition.isWaiting())
        {
            discountMap.put(DiscountCondition.WAITINGStr, discount
                    .countWaitingDiscount(consumeFoods));
        }
        // 如果使用了代金券，计算，打印能使用的金额，
        if (discountCondition.getToken() > 0)
        {
            discountMap.put(DiscountCondition.TOKENStr, discount
                    .countTokenDiscount(account, discountCondition.getToken()));
        }
        return discountMap;
    }

    private double countPayment(double account, Map<String, Double> discountMap)
    {

        for (String str : discountMap.keySet())
        {
            account -= discountMap.get(str);
        }
        return account;
    }
}

class ConsumeFoods
{
    private Menu menu;

    private Input input;
    
    private List<FoodStuff> consumeList;

    public ConsumeFoods(Menu m, Input in)
    {
        initial(m, in);
        InputConsumeFoods();
    }
    
    private void initial(Menu m, Input in){
        menu=m;
        input=in;
        consumeList=new ArrayList<FoodStuff>();
    }

    private void InputConsumeFoods()
    {
        menu.printtMenu();
        consumeList = createConsumeFoods(input.getConsumeINF(menu));
    }

    private List<FoodStuff> createConsumeFoods(Map<String, Integer> foodMap)
    {

        List<FoodStuff> consumeFoods = new ArrayList<FoodStuff>();
        for (String str : foodMap.keySet())
        {
            if (foodMap.get(str) != null)
            {
                for (int i = 0; i < foodMap.get(str).intValue(); i++)
                {
                    consumeFoods.add(Factory.createFood(str));
                }
            }
        }
        return consumeFoods;
    }

    public List<FoodStuff> getConsumeList()
    {
        return consumeList;
    }
}

// 餐厅菜单
class Menu
{
    private Map<String, FoodStuff> menuMap;

    private Output output;

    public Menu(Output out)
    {

        initialOutput(out);
        initialMenu();
    }

    private void initialOutput(Output out)
    {
        output = out;
    }

    // 初始化菜单
    private void initialMenu()
    {

        menuMap = new LinkedHashMap<String, FoodStuff>();
        for (Eum_NormalFood normal : Eum_NormalFood.values())
        {
            menuMap.put(normal.id, Factory.createNormalFood(normal.id, normal
                    .toString(), normal.price));
        }

        for (Eum_SeaFood sea : Eum_SeaFood.values())
        {
            menuMap.put(sea.id, Factory.createNormalFood(sea.id,
                    sea.toString(), sea.price));
        }

        for (Eum_WineFood wine : Eum_WineFood.values())
        {
            menuMap.put(wine.id, Factory.createNormalFood(wine.id, wine
                    .toString(), wine.price));
        }

    }

    public void printtMenu()
    {
        output.prtMenu(menuMap);
    }
    
    public Map<String,FoodStuff> getMenuMap(){
        return menuMap;
    }
}

// 用户享受的折扣条件
// VIP和等待折扣不能同时使用；如果条件同时具备，按高折扣算（既按VIP算）
class DiscountCondition
{
    public static final String VIPStr = "VIP折扣";

    public static final String WAITINGStr = "进餐等待折扣";

    public static final String TOKENStr = "代金券折扣";

    // 就餐等待折扣
    private boolean waiting = false;

    // VIP折扣
    private boolean VIP = false;

    // 代金券，消费总价按满100，允许使用50代金券
    private double token = 0;

    // 对外公开的构造方法，从控制台输入
    public DiscountCondition(Input in)
    {

        initial(in);
    }

    private void initial(Input in)
    {

        boolean t_waiting;
        boolean t_VIP;
        double t_token;

        // 从控制台得到输入字符串
        String str = in.getDiscountINF();
        Scanner sc = new Scanner(str);
        t_waiting = (sc.nextInt() == 1) ? true : false;
        t_VIP = (sc.nextInt() == 1) ? true : false;
        t_token = sc.nextDouble();

        if (t_VIP)
            VIP = t_VIP;
        else if (t_waiting)
            waiting = t_waiting;

        token = t_token;
    }

    public double getToken()
    {

        return token;
    }

    public boolean isVIP()
    {

        return VIP;
    }

    public boolean isWaiting()
    {

        return waiting;
    }
}
abstract class Discount{
    abstract public double countWaitingDiscount(List<FoodStuff> consumeFoods);
    abstract public double countVIPDiscount(double totalAccount);
    abstract public double countTokenDiscount(double totalAccount, double token);
}

// 折扣处理规则类
class NormalDiscount extends Discount
{
    // 进餐等待折扣是普通食品优惠2折，酒水优惠1折；
    public double countWaitingDiscount(List<FoodStuff> consumeFoods)
    {

        final double NormalFoodRate = 0.2;
        final double WineFoodRate = 0.1;
        double waitingDiscount = 0;
        for (FoodStuff food : consumeFoods)
        {
            if (food instanceof NormalFood)
            {
                waitingDiscount += food.getPrice() * NormalFoodRate;
            }
            else if (food instanceof WineFood)
            {
                waitingDiscount += food.getPrice() * WineFoodRate;
            }
        }
        return waitingDiscount;
    }

    // VIP用户折扣是总价的2折；
    public double countVIPDiscount(double totalAccount)
    {

        final double Rate = 0.2;
        double VIPDiscount = totalAccount * Rate;
        return VIPDiscount;
    }

    // 代金券的使用是消费总额满100允许使用50；
    public double countTokenDiscount(double totalAccount, double token)
    {

        final int RequiredAccount = 100;
        final int ConcumeAccount = 50;
        int n = Math.round((float) totalAccount) / RequiredAccount;
        // 允许消费的值大于代金券则全额使用带金券，否则只能使用允许的数额
        return (ConcumeAccount * n > token) ? token : ConcumeAccount * n;

    }
}

// 食品顶级类
class FoodStuff
{
    private String name;

    private double price;

    // 食品代号，输入时用代号输入食品类别；
    private String id;

    public FoodStuff(String id, String name, double price)
    {

        this.name = name;
        this.price = price;
        this.id = id;
    }

    public String getName()
    {

        return name;
    }

    public double getPrice()
    {

        return price;
    }

    public String getId()
    {

        return id;
    }
}

// 普通食品
class NormalFood extends FoodStuff
{
    public NormalFood(String id, String name, double price)
    {

        super(id, name, price);
    }
}

// 海鲜
class SeaFood extends FoodStuff
{
    public SeaFood(String id, String name, double price)
    {

        super(id, name, price);
    }
}

// 酒水
class WineFood extends FoodStuff
{
    public WineFood(String id, String name, double price)
    {

        super(id, name, price);
    }
}

// 这里用枚举类模拟配置文件，用户通过编辑配置文件来编辑菜单中食品的数量和种类，价格；
enum Eum_NormalFood
{
    Steak("101", 30), // 牛排
    Chicken("102", 35), // 鸡排
    Corn("103", 10); // 玉米

    String id;

    double price;

    Eum_NormalFood(String id, double price)
    {

        this.id = id;
        this.price = price;
    }

    public String toString()
    {

        switch (this)
        {
            case Steak:
                return "牛排 ";
            case Chicken: