2.22.重载的参数匹配规则

重载的参数匹配规则
看例程：有了论斤卖的商品，数量变成 double 类型。有论整个卖的，有
散装称重卖的，事情开始复杂起来

看例程：方法调用的时候，参数就不必完全类型一样，对于数字类型的参
数，实参数可以自动类型转换成形参类型即可

看例程：重载时如果参数类型不完全匹配怎么办

public class MerchandiseV2AppMain {
    public static void main(String[] args) {
        MerchandiseV2 merchandise = new MerchandiseV2();

        merchandise.init("书桌", "DESK9527", 40, 999.9, 500);

        // >> TODO 使用int调用参数为double的方法
        int count = 3;
//        merchandise.buyDouble(count);

        System.out.println("测试使用不完全匹配的参数调用重载方法");
        // >> TODO 依次使用byte, short, int, long, float, double 类型的参数调用buy方法，哪个方法会被调用呢？
        // >> TODO 无论是否重载参数类型可以不完全匹配的规则是"实参数可以自动类型转换成形参类型"
        // >> TODO 重载的特殊之处是，参数满足自动自动类型转换的方法有好几个，重载的规则是选择最"近"的去调用
        double countForOverride  = 11;
        merchandise.buy(countForOverride);


    }
}

public class MerchandiseV2 {

    public String name;
    public String id;
    // TODO 把count改成double，兼容散装称重的商品
    public double count;
    public double soldPrice;
    public double purchasePrice;

    public void init(String name, String id, int count, double soldPrice, double purchasePrice) {
        this.name = name;
        this.id = id;
        this.count = count;
        this.soldPrice = soldPrice;
        this.purchasePrice = purchasePrice;
    }

    public void describe() {
        System.out.println("商品名字叫做" + name + "，id是" + id + "。 商品售价是" + soldPrice
            + "。商品进价是" + purchasePrice + "。商品库存量是" + count +
            "。销售一个的毛利润是" + (soldPrice - purchasePrice));
    }

    public double calculateProfit() {
        double profit = soldPrice - purchasePrice;
//        if(profit <= 0){
//            return 0;
//        }
        return profit;
    }

    // >> TODO 方法调用的时候，参数就不必完全类型一样，实参数可以自动类型转换成形参类型即可
    public double buyDouble(double count){
        System.out.println("buyDouble(double)被调用了");
        if (this.count < count) {
            return -1;
        }
        this.count -= count;
        double totalCost = count * soldPrice;
        return totalCost;
    }


    // TODO 论斤卖的商品，数量是double。我们把count成员变量改成double类型
    public double buy(double count){
        System.out.println("buy(double)被调用了");
        if (this.count < count) {
            return -1;
        }
        this.count -= count;
        double totalCost = count * soldPrice;
        return totalCost;
    }

    public double buy() {
        System.out.println("buy()被调用了");
        return buy(1);
    }

    public double buy(int count) {
        System.out.println("buy(int)被调用了");
        return buy(count, false);
    }

    public double buy(int count, boolean isVIP) {
        System.out.println("buy(int,boolean)被调用了");
        if (this.count < count) {
            return -1;
        }
        this.count -= count;
        double totalCost = count * soldPrice;
        if (isVIP) {
            return totalCost * 0.95;
        } else {
            return totalCost;
        }
    }

}

无论是否重载参数类型可以不完全匹配的规则是"实参数可以自动类型转换成形参类型"
重载的特殊之处是，参数满足自动自动类型转换的方法有好几个，重载的规则是选择最"近"的去调用

方法调用的时候，参数就不必完全类型一样，实参数可以自动类型转换成形参类型即可