重载的参数匹配规则
看例程：有了论斤卖的商品，数量变成 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 LittleSuperMarket {
public String superMarketName;
public String address;
public int parkingCount;
public double incomingSum;
public MerchandiseV2[] merchandises;
public int[] merchandiseSold;
/**
* 初始化小超市
*
* @param superMarketName
* @param address
* @param parkingCount
* @param merchandiseCount 商品种类数
* @param count 每种商品缺省库存
*/
public void init(String superMarketName, String address, int parkingCount,
int merchandiseCount, int count) {
this.superMarketName = superMarketName;
this.address = address;
this.parkingCount = parkingCount;
merchandises = new MerchandiseV2[merchandiseCount];
for (int i = 0; i < merchandises.length; i++) {
// 创建并给商品的属性赋值
MerchandiseV2 m = new MerchandiseV2();
m.name = "商品" + i;
m.count = count;
m.purchasePrice = Math.random() * 200;
m.soldPrice = m.purchasePrice * (1 + Math.random());
m.id = "ID" + i;
// 用创建的商品，给商品数组的第i个引用赋值，all和小超市的商品数组引用指向的是同一个数组对象
merchandises[i] = m;
}
merchandiseSold = new int[merchandises.length];
}
// 简单的访问成员变量
public String getSuperMarketName() {
return superMarketName;
}
public String getAddress() {
return address;
}
public int getParkingCount() {
return parkingCount;
}
public double getIncomingSum() {
return incomingSum;
}
public void setSuperMarketName(String superMarketName) {
this.superMarketName = superMarketName;
}
public void setAddress(String address) {
this.address = address;
}
public void setParkingCount(int parkingCount) {
this.parkingCount = parkingCount;
}
public void setIncomingSum(double incomingSum) {
this.incomingSum = incomingSum;
}
public void setMerchandises(MerchandiseV2[] merchandises) {
this.merchandises = merchandises;
}
public void setMerchandiseSold(int[] merchandiseSold) {
this.merchandiseSold = merchandiseSold;
}
// 一些特殊的逻辑
/**
* 得到利润最高的商品
*
* @return
*/
public MerchandiseV2 getBiggestProfitMerchandise() {
MerchandiseV2 curr = null;
for (int i = 0; i < merchandises.length; i++) {
MerchandiseV2 m = merchandises[i];
// 这个逻辑有问题吗？相同的利润怎么判断？
if (curr == null || curr.calculateProfit() < m.calculateProfit()) {
curr = m;
}
}
return curr;
}
/**
* 根据索引获取商品
*
* @param merchandiseIndex
* @return
*/
public MerchandiseV2 getMerchandiseOf(int merchandiseIndex) {
if (merchandiseIndex < 0 || merchandiseIndex >= merchandises.length) {
return null;
}
return merchandises[merchandiseIndex];
}
/**
* 赚钱
* @param toBeAdded
*/
public void addIncomingSum(double toBeAdded) {
this.incomingSum += toBeAdded;
}
/**
* 花钱
* @param toBeSpent
* @return
*/
public boolean spendMoney(double toBeSpent) {
if (toBeSpent > incomingSum) {
return false;
}
incomingSum -= toBeSpent;
return true;
}
}
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;
}
}
}
无论是否重载参数类型可以不完全匹配的规则是"实参数可以自动类型转换成形参类型"
重载的特殊之处是，参数满足自动自动类型转换的方法有好几个，重载的规则是选择最"近"的去调用
方法调用的时候，参数就不必完全类型一样，实参数可以自动类型转换成形参类型即可
