函数方法重载以及类的封装

一、什么方法

类中如果不定义方法，只定义成员变量，那么一个类就没有了功能，只是简单的数据封装，创建一个对象之后，所有对这些数据的操作都要在每个用到这些数据的地方写代码；类通过成员变量和方法描述世界。成员变量是描述-类事物的属性,是数据;方法是描述一类事物的行为和功能,是对数据的操作。

• 方法中的代码可以通过操作一个对象的成员变量完成一个功能；
• 方法是Java中代码执行的单元,是代码的载体。所有的代码,都必须属于某一个方法；
• 方法是Java中代码执行的单元，是代码的载体。所有的代码都必须属于某一个方法；
• 方法就是一串语句,加上数据输入this 自引用和参数,执行后得到一一个返回值。所以使用一个对象调用一个方法,可以叫做调用对象的方法,也可以叫做“在这个对象上调用方法( invoke a method on an object ) ；
• 方法不是对象的-部分,它是类的一部分。每个对象可以给成员变量赋不同的值.但是无法让方法有不同的行为。同理,无论在一个类中定义多少方法 ,都不会让影响创建- -个对象所占用的内存；

  • 方法的特殊之处

    • 有名字
    • 有返回值
    • 有参数
    • 有this自引用
    • 明确的属于某一个类
    • 可以(也只能)通过对象引用来调用

二、封装

用类定义成员变量,并把操作成员变量的代码都放在类里,就是封装。

• 初始化成员变量；
• 简单访问和设置成员变量的值( Java Bean )；
• 可以集中管控自己的成员变量别人不可以乱来，避免出现非法的状态，比如库存为负数；
• 代码逻辑可以公用,避免代码重复,修改的时候只需改一处；
• 类封装的好可以更好的抽象一类事务。

三、方法的签名和重载

• 方法重载

  • 方法签名:方法名+依次参数类型。注意,返回值不属于方法签名。方法签名是一个方法在一个类中的唯一 标识；
  • 同一个类中方法可以重名,但是签名不可以重复。一个类中如果定义了名字相同,签名不同的方法,就叫做方法的重载
    具体代码如下：

package com.geekbang.supermarket;
public class MerchandiseV2Overload {

    public String name;
    public String id;
    public int 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 重载的方法可以调用别的重载方法，当然也可以调用别的不重载的方法。
    // >> TODO 实际上，像这种补充一些缺省的参数值，然后调用重载的方法，是重载的一个重要的使用场景。
    // >> TODO 在这里我们举的例子就是这样的，但是不是语法要求一定要这样。重载的方法的方法体内代码可以随便写，
    //    TODO 可以不调用别的重载方法
    public double buy() {
        return buy(1);
    }


    public double buy(int count) { return buy(count, false);
    }

    // TODO  最后都补充好参数，调用参数最全的一个方法
    public double buy(int count, boolean isVIP) {
        if (this.count < count) {
            return -1;
        }
        this.count -= count;
        double totalCost = count * soldPrice;
        if (isVIP) {
            return totalCost * 0.95;
        } else {
            return totalCost;
        }
    }
}

package com.geekbang;

import com.geekbang.supermarket.MerchandiseV2Overload;

public class MerchandiseV2OverrideBuyAppMain {
    public static void main(String[] args) {
        MerchandiseV2Overload merchandise = new MerchandiseV2Overload();
        merchandise.init("书桌", "DESK9527", 40, 999.9, 500);
        // >> TODO 理解为什么返回值不是方法签名的一部分：不能帮助确定调用哪个方法。
        merchandise.buy();
        merchandise.describe();

        double cost = merchandise.buy(10);
        System.out.println(cost);
        merchandise.describe();

        double costVIP = merchandise.buy(10, true);
        System.out.println(costVIP);
        merchandise.describe();
    }
}

• 重载的参数匹配规则

具体看代码：

package com.geekbang.supermarket;

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;
        }
    }
}

package com.geekbang;

import com.geekbang.supermarket.MerchandiseV2;

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);
    }
}