java学习2 零基础

10.方法的签名和重载

overload

方法的签名是一个类中的唯一标识

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

}

// >> TODO 理解为什么返回值不是方法签名的一部分：不能帮助确定调用哪个方法。

重载的匹配规则

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 重载的特殊之处是，参数满足自动自动类型转换的方法有好几个，重载的规则是选择最"近"的去调用

        byte countForOverride1  = 11;
        merchandise.buy(countForOverride1);

        double countForOverride  = 11;
        merchandise.buy(countForOverride);

        short countForOverride2  = 11;
        merchandise.buy(countForOverride2);

        int countForOverride3  = 11;
        merchandise.buy(countForOverride3);

        float countForOverride4  = 11;
        merchandise.buy(countForOverride4);

        long countForOverride5  = 11;
        merchandise.buy(countForOverride5);
    }
}

测试使用不完全匹配的参数调用重载方法
buy(int)被调用了
buy(int,boolean)被调用了
buy(double)被调用了
buy(int)被调用了
buy(int,boolean)被调用了
buy(int)被调用了
buy(int,boolean)被调用了
buy(double)被调用了
buy(double)被调用了

11.构造方法

自动调用 调用哪一个方法

constructor

package com.geekbang.supermarket;

public class MerchandiseV2WithConstructor {

    public String name;
    public String id;
    public int count;
    public double soldPrice;
    public double purchasePrice;

    // >> TODO 构造方法（constructor）的方法名必须与类名一样，而且构造方法没有返回值。这样的方法才是构造方法。
    // >> TODO 构造方法可以有参数，规则和语法于普通方法一样。使用时，参数传递给 new 语句后类名的括号后面。
    // >> TODO 如果没有显示的添加一个构造方法，Java会给每个类都会默认自带一个无参数的构造方法。
    //    TODO 如果我们自己添加类构造方法，Java就不会再添加无参数的构造方法。这时候，就不能直接 new 一个对象不传递参数了（看例子）
    // >> TODO 所以我们一直都在使用构造方法，这也是为什么创建对象的时候类名后面要有一个括号的原因。
    // >> TODO 构造方法无法被点操作符调用或者在普通方法里调用，只能通过 new 语句在创建对象的时候，间接调用。
    // TODO 理解一下为什么构造方法不能有返回值，因为有返回值也没有意义，new 语句永远返回的是创建出来的对象的引用
    public MerchandiseV2WithConstructor(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;
    }

    public double buy(int count) {
        if (this.count < count) {
            return -1;
        }
        return this.count -= count;
    }
}

如果我们自己添加类构造方法，Java就不会再添加无参数的构造方法。
这时候，就不能直接 new 一个对象不传递参数了（看例子）
也可以创建多个构造函数  这也就是构造方法的重载 如下所示

    // >> TODO 构造方法（constructor）的重载和普通方法一样
    public MerchandiseV2(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;
//        soldPrice = 9/0;
    }

    // >> TODO 在构造方法里才能调用重载的构造方法。语法为this(实参列表)
    // >> TODO 构造方法不能自己调用自己，这会是一个死循环
    // >> TODO 在调用重载的构造方法时，不可以使用成员变量。因为用语意上讲，这个对象还没有被初始化完成，处于中间状态。
    // >> TODO 在构造方法里才能调用重载的构造方法时，必须是方法的第一行。后面可以继续有代码
    public MerchandiseV2(String name, String id, int count, double soldPrice) {
         // double purPrice = soldPrice * 0.8;
        // this(name, id, count, soldPrice, purchasePrice);
        this(name, id, count, soldPrice, soldPrice * 0.8);
        // double purPrice = soldPrice * 0.8;
    }

    // >> TODO 因为我们添加了构造方法之后，Java就不会再添加无参数的构造方法。如果需要的话，我们可以自己添加这样的构造方法
    public MerchandiseV2() {
        this("无名", "000", 0, 1, 1.1);

    }

构造方法里面可以相互调用

this(name, id, count, soldPrice, soldPrice * 0.8);

只有在构造方法里面才可以调用，不能自己调自己！

可以在构造方法之前赋值

    public String name;
    public String id;
    // >> TODO 构造方法执行前，会执行给局部变量赋初始值的操作
    // >> TODO 我们说过，所有的代码都必须在方法里，那么这种给成员变赋初始值的代码在哪个方法里？怎么看不到呢？
    //    TODO 原来构造方法在内部变成了<init>方法。学习就是要脑洞大，敢想敢试，刨根问底。
    public int count = 999;// 999/0;
    public double soldPrice;
    public double purchasePrice;

类名.<init> 构造方法 成员变量赋值 的是在这里完成的

12.静态 static

Magic Number 要赋一个变量名

package com.geekbang.supermarket;

public class MerchandiseV2WithStaticVariable {

    public String name;
    public String id;
    public int count;
    public double soldPrice;
    public double purchasePrice;

    // >> TODO 静态变量使用 static 修饰符
    // >> TODO 静态变量如果不赋值，Java也会给它赋以其类型的初始值
    // >> TODO 静态变量一般使用全大写字母加下划线分割。这是一个习惯用法
    // >> TODO 所有的代码都可以使用静态变量，只要根据防范控制符的规范，这个静态变量对其可见即可
    //    TODO 比如 public 的静态变量，所有的代码都可以使用它
    public static double DISCOUNT_FOR_VIP = 0.95;

    //    TODO 但是如果没有public修饰符，只能当前包的代码能使用它
    static int STATIC_VARIABLE_CURR_PACKAGE_ONLY = 100;


    public MerchandiseV2WithStaticVariable(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 String getName() {
        return name;
    }

    public MerchandiseV2WithStaticVariable(String name, String id, int count, double soldPrice) {
        this(name, id, count, soldPrice, soldPrice * 0.8);
    }

    public MerchandiseV2WithStaticVariable() {
        this("无名", "000", 0, 1, 1.1);

    }

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

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


    public double buy() {
        return buy(1);
    }

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

    public double buy(int count, boolean isVIP) {
        if (this.count < count) {
            return -1;
        }
        this.count -= count;
        double totalCost = count * soldPrice;
        if (isVIP) {
            // >> TODO 使用自己的使用静态变量的时候，直接写静态变量名字。
            return totalCost * DISCOUNT_FOR_VIP;
        } else {
            return totalCost;
        }
    }
}

静态变量就这一个，不随实例的创建而创建。

使用静态变量

import引入

package com.geekbang;

import com.geekbang.supermarket.MerchandiseV2WithStaticVariable;
import  static com.geekbang.supermarket.MerchandiseV2WithStaticVariable.*;

public class MerchandiseV2DescAppMain {
    public static void main(String[] args) {
        MerchandiseV2WithStaticVariable merchandise = new MerchandiseV2WithStaticVariable
            ("书桌", "DESK9527", 40, 999.9, 500);

        merchandise.describe();

        // >> TODO 使用import static来引入一个静态变量，就可以直接用静态变量名访问了
        //    TODO import static也可以使用通配符*来引入一个类里所有静态变量
        System.out.println(DISCOUNT_FOR_VIP);
    }
}

静态变量一变都会变。

package com.geekbang;

import com.geekbang.supermarket.LittleSuperMarket;
import com.geekbang.supermarket.MerchandiseV2WithStaticVariable;

public class RunLittleSupperMarketAppMain {
    public static void main(String[] args) {
        // 创建一个小超市类
        LittleSuperMarket littleSuperMarket = new LittleSuperMarket(
            "有家小超市", "浦东新区世纪大道666号",
            100, 200, 200);

        System.out.println("下面请利润最高的商品自我介绍：");
        MerchandiseV2WithStaticVariable bigProfit = littleSuperMarket.getBiggestProfitMerchandise();
        bigProfit.describe();
        double cost1 = bigProfit.buy(10, true);
        System.out.println("VIP 购买10个" + bigProfit.getName() + "的花费为" + cost1);

        // >> TODO 使用别的类的静态变量的时候，需要使用完整形态：类名.静态变量名字
        MerchandiseV2WithStaticVariable.DISCOUNT_FOR_VIP = 0.5;
        bigProfit.describe();
        double cost2 = bigProfit.buy(10, true);
        System.out.println("VIP 购买10个" + bigProfit.getName() + "的花费为" + cost2);

        // >> TODO 静态变量在整个Java程序中只有一个（对比实例变量，是每个实例有一份
        //    TODO 所以静态变量一旦变化，所有使用这个静态变量的地方的值都会变
        MerchandiseV2WithStaticVariable m0 = littleSuperMarket.getMerchandiseOf(0);
        m0.describe();
        double cost3 = m0.buy(10, true);
        System.out.println("VIP 购买10个" + m0.getName() + "的花费为" + cost3);
    }
}

静态方法

也叫类方法：只能使用参数和静态变量，换而言之，就是没有this子引用的方法

    // >> TODO 静态变量使用 static 修饰符
    public static double DISCOUNT_FOR_VIP = 0.95;

    // >> TODO 静态方法使用static修饰符。
    // 静态方法的方法名没有约定俗称全大写
    public static double getVIPDiscount() {
        // >> TODO 静态方法可以访问静态变量，包括自己类的静态变量和在访问控制符允许的别的类的静态变量
        return DISCOUNT_FOR_VIP;
    }

    // >> TODO 除了没有this，静态方法的定义和成员方法一样，也有方法名，返回值和参数
    // >> TODO 静态方法没有this自引用，它不属于某个实例，调用的时候也无需引用，直接用类名调用，所以它也不能直接访问成员变量
    // >> TODO 当然在静态方法里面，也可以自己创建对象，或者通过参数，获得对象的引用，进而调用方法和访问成员变量
    // >> TODO 静态方法只是没有this自引用的方法而已。
    public static double getDiscountOnDiscount(LittleSuperMarket littleSuperMarket) {
        double activityDiscount = littleSuperMarket.activityDiscount;
        return DISCOUNT_FOR_VIP * activityDiscount;
    }

this-->类      and  静态---》类

用过方法的签名来重载静态方法

package com.geekbang.supermarket;

public class DiscountMgr {

    public static double BASE_DISCOUNT = 0.99;

    public static double VIP_DISCOUNT = 0.85;

    public static double SVIP_DISCOUNT = 0.75;

    // >> TODO 静态方法的重载也是一样的，方法签名不同即可：方法名+参数类型
    // >> TODO 判断调用哪个方法，也是根据调用时参数匹配决定的。
    public static double getDiscount() {
        return BASE_DISCOUNT;
    }

    public static double getDiscount(boolean isVIP) {
        // TODO >> 这节课这么无聊，我们顺带学一个三元操作符吧。
        // TODO    三元操作符的返回类型就是冒号两边的类型，两边的类型要和等号左边的变量类型兼容
        // double abc = true ? "" : 0;

        double svipDiscount = (isVIP ? VIP_DISCOUNT : 1);
        return getDiscount() * svipDiscount;
    }

    public static double getDiscount(int svipLevel) {
        double ret = getDiscount() * VIP_DISCOUNT;
        for (int i = 0; i < svipLevel; i++) {
            ret *= SVIP_DISCOUNT;
        }
        return ret;
    }

    // 这节课这么无聊，我们顺带看几个不是那么正经的getDiscount吧

    // >> TODO 返回值不算是方法签名，重载的方法可以有完全不同的返回值类型
    public static void getDiscount(String s) {
        System.out.println(s);
    }

    public static int getDiscount(int a, int b) {
        return a > b ? a : b;
    }


    public static boolean getDiscount(int a, int b, int c) {
        return a > b && b > c;
    }

    public static String getDiscount(long abc) {
        return "" + abc;
    }

    public static void main(String[] args) {
        getDiscount(1, 2);
    }

}

静态代码块

package com.geekbang.supermarket;

public class DiscountMgr {

    public static void main(String[] args) {
        System.out.println("最终main 方法中使用的SVIP_DISCOUNT是" + SVIP_DISCOUNT);
    }

    public static double BASE_DISCOUNT;

    public static double VIP_DISCOUNT;

    // >> TODO 使用某个静态变量的代码块必须在静态变量后面
    // >> TODO （但是仅仅赋值没有限制，很妖的语法哈，有些语法就应该在学会的第一时间忘掉它）
    public static double SVIP_DISCOUNT;


    static {
        BASE_DISCOUNT = 0.99;
        VIP_DISCOUNT = 0.85;
        SVIP_DISCOUNT = 0.75;

        // >> TODO 静态代码块里当然可以有任意的合法代码
        System.out.println("静态代码块1里的SVIP_DISCOUNT" + SVIP_DISCOUNT);

        // >> TODO 这段代码在哪个方法中呢？<clinit>，即class init。会在每个class初始化的时候被调用一次
//         SVIP_DISCOUNT = 9/0;
    }

    // >> TODO 其实给静态变量赋值也是放在代码块里的，static代码块可以有多个，是从上向下顺序执行的。
    //    TODO 可以认为这些代码都被组织到了一个clinit方法里
    // public static double WHERE_AM_I = 9/0;

//     public static double SVIP_DISCOUNT;

    static {
        SVIP_DISCOUNT = 0.1;
        System.out.println("静态代码块2里的SVIP_DISCOUNT" + SVIP_DISCOUNT);
    }
}

<clinit> class init  静态代码块在class init

13.访问修饰符

• public：全局可见
• 缺省：当前包可见
• private：当前类可见

package com.geekbang.supermarket;

// >> TODO 类，静态方法，静态变量，成员变量，构造方法，成员方法都可以使用访问修饰符
public class MerchandiseV2 {

    // >> TODO 成员变量应该都声明为private
    // >> TODO 如果要读写这些成员变量，最好使用get set方法，这些方法应该是public的
    // >> TODO 这样做的好处是，如果有需要，可以通过代码，检查每个属性值是否合法。
    private String name;
    private String id;
    private int count;
    private double soldPrice;
    private double purchasePrice;
    private NonPublicClassCanUseAnyName nonPublicClassCanUseAnyName;
    public static double DISCOUNT = 0.1;

    // >> TODO 构造方法如果是private的，那么就只有当前的类可以调用这个构造方法
    public MerchandiseV2(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;
        // soldPrice = 9/0;
    }

    // >> TODO 有些时候，会把所有的构造方法都定义成private的，然后使用静态方法调用构造方法
    // >> TODO 同样的，这样的好处是可以通过代码，检查每个属性值是否合法。
    public static MerchandiseV2 createMerchandise(String name, String id, int count,
                                                  double soldPrice, double purchasePrice) {
        if (soldPrice < 0 || purchasePrice < 0) {
            return null;
        }
        return new MerchandiseV2(name, id, count, soldPrice, purchasePrice);
    }

    public MerchandiseV2(String name, String id, int count, double soldPrice) {
        this(name, id, count, soldPrice, soldPrice * 0.8);
    }

    public MerchandiseV2() {
        this("无名", "000", 0, 1, 1.1);
    }

    // >> TODO public的方法类似一种约定，既然外面的代码可以使用，就意味着不能乱改。比如签名不能改之类的
    public void describe() {
        System.out.println("商品名字叫做" + name + "，id是" + id + "。 商品售价是" + soldPrice
            + "。商品进价是" + purchasePrice + "。商品库存量是" + count +
            "。销售一个的毛利润是" + (soldPrice - purchasePrice));
        freeStyle();
    }

    // >> TODO 对于private的方法，因为类外面掉不到，所以无论怎么改，也不会影响（直接影响）类外面的代码
    private void freeStyle() {

    }

    public double calculateProfit() {
        double profit = soldPrice - purchasePrice;
        return profit;
    }

    public double buy(int count) {
        if (this.count < count) {
            return -1;
        }
        return this.count -= count;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public double getSoldPrice() {
        return soldPrice;
    }

    public void setSoldPrice(double soldPrice) {
        this.soldPrice = soldPrice;
    }

    public double getPurchasePrice() {
        return purchasePrice;
    }

    public void setPurchasePrice(double purchasePrice) {
        this.purchasePrice = purchasePrice;
    }
}

private都可以配备一个static的方法。来控制实例是否非法

// >> TODO 构造方法如果是private的，那么就只有当前的类可以调用这个构造方法
private MerchandiseV2(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;
    // soldPrice = 9/0;
}

// >> TODO 有些时候，会把所有的构造方法都定义成private的，然后使用静态方法调用构造方法
// >> TODO 同样的，这样的好处是可以通过代码，检查每个属性值是否合法。
public static MerchandiseV2 createMerchandise(String name, String id, int count,
                                              double soldPrice, double purchasePrice) {
    if (soldPrice < 0 || purchasePrice < 0) {
        return null;
    }
    return new MerchandiseV2(name, id, count, soldPrice, purchasePrice);
}

只能在当前包里用

package com.geekbang.supermarket;

// >> TODO 非public的类，类名可以不和文件名相同
class NonPublicClassCanUseAnyName {
}

package com.geekbang.learn;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Scanner;

public class LearnScanner {
    public static void main(String[] args) {
        // TODO Scanner是一个方便的可以帮我们从标准输入读取并转换数据的类
        // TODO 注释里 @since   1.5 表示它是从Java5才开始有的。
        Scanner scanner = new Scanner(System.in);

        // TODO 但是这并是说从Java5开始，这个类就没有变化过了
        // TODO 在源代码里搜索一下@since，会发现很多方法是在后续的 Java 版本中加进去的
        // TODO 但是private方法就不会有这个文档标示，因为private方法本来就不给用。

        System.out.println("请输入一个巨大的正数");
        BigInteger bigInteger = scanner.nextBigInteger();
        System.out.println("请输入想给这个数加多少");
        BigInteger toBeAdd = scanner.nextBigInteger();
        System.out.println("结果为：" + bigInteger.add(toBeAdd));
    }
}

14.String

String 不可变immutable，用来存储的数据是private的，而且不提供人格修改内容的方法，string一旦生成就不可能被修改。

转自：https://blog.csdn.net/qq_40434646/article/details/81914843

 Integer i = 128; 
 Integer j = 128; 
 System.out.println(i == j);//返回false

Integer m = 127;
Integer n = 127;
System.out.println(m == n);//返回true

1.如果Integer类型的两个数相等，如果范围在-128~127（默认），那么用“==”返回true，其余的范会false。

2.两个基本类型int进行相等比较，直接用==即可。

3.一个基本类型int和一个包装类型Integer比较，用==也可，比较时候，Integer类型做了拆箱操作。

4.Integer类型比较大小，要么调用Integer.intValue()转为基本类型用“==”比较，要么直接用equals比较。

package com.geekbang.learn;

public class LearnString {
    public static void main(String[] args) {
        String content = "01234567ABCDefgh";

        // 数组的length是属性，没有括号   A.length
        // String的length()是个方法不是属性哦
        System.out.println(content.length());

        // 其实是生成了一个新的String对象
        System.out.println(content.toUpperCase());

        System.out.println(content.toLowerCase());

        // content指向对象的内容并没有变化
        System.out.println(content);

        System.out.println(content.charAt(1));

        // System.out.println(content.charAt(99));

        System.out.println(content.substring(5));

        System.out.println(content.substring(1, 5));  // 最后一个不包含

    }
}

字符串用法：

package com.geekbang.learn;

public class LearnString2 {
    public static void main(String[] args) {
        String content = "Orange_Apple_Banana";

        char[] chars = content.toCharArray();  // 字符数组
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }

        String sp = "_";
        String[] s = content.split(sp);  // 分割
        for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }

        int indexOf = content.indexOf('_');
        System.out.println(indexOf);
        System.out.println(content.substring(indexOf + 1, content.length()));

        int lastIndexOf = content.lastIndexOf("_");
        System.out.println(lastIndexOf);
        System.out.println(content.substring(0, lastIndexOf));


        // 是否包含字符串
        System.out.println(content.contains("apple"));
        System.out.println(content.contains("Apple"));
        System.out.println(content.startsWith("Orange"));
        System.out.println(content.endsWith("Banana"));

        String content2 = "Orange_Apple_Banana";
        String content3 = "   orange_Apple_banana   ";


        // TODO 两个String对象比较是否相等，一定要用equals方法
        // 比较两个字符串是否相等
        System.out.println(content.equals(content2));
        System.out.println(content.equals(content3));
        System.out.println(content3.trim());
        System.out.println(content.equalsIgnoreCase(content3.trim()));  // 把string前面和后面的额外空格去掉
    }
}

 main方法也知识一个静态的，有String[]作为参数，没有返回值的方法而已，它的特殊性在于java可以吧main方法作为程序入口。

package com.geekbang.learn;

public class LearnMain {
    public static void main(String[] args) { // 以空格为分隔符号 空格字符串以引号括住
        System.out.println(args.length);
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

package com.geekbang.learn;

public class InvokeMain {
    public static void main(String[] args) {
        System.out.println("进入了InvokeMain的main方法");
        LearnMain.main(args);
        System.out.println("InvokeMain的main方法执行结束");
    }
}

System类

• in
• out
• 取系统当前时间

package com.geekbang.learn;

public class LearnSystem {
    public static void main(String[] args) {
        // 当前的毫秒数
        long startMS = System.currentTimeMillis();

        int counter = 0;
        for (int i = 0; i < 1000; i++) {
            counter++;
        }

        long endMS = System.currentTimeMillis();
        System.out.println("程序执行使用了几个毫秒？" + (endMS - startMS));

        // 纳秒
        long startNS = System.nanoTime();

        counter = 0;
        for (int i = 0; i < 1000; i++) {
            counter++;
        }

        long endNS = System.nanoTime();
        System.out.println("程序执行使用了几个纳秒？" + (endNS - startNS));
    }
}

StringBuild

是一个非常方便的用来拼接和处理字符串的类，和String不同的是，它是可变的。

操作不会生成新的StringBulid和String对象

package com.geekbang.learn;

public class LearnStringBuilder {

    public static void main(String[] args) {

        // TODO StringBuilder首先是可变的
        // TODO 而且对它进行操作的方法，都会返回this自引用。这样我们就可以一直点下去，对String进行构造。
        StringBuilder strBuilder = new StringBuilder();

        long longVal = 123456789;

        // 可以append所有数据类型
        strBuilder.append(true).append("abc").append(longVal);

        System.out.println(strBuilder.toString());
        System.out.println(strBuilder.reverse().toString());  // 翻转
        System.out.println(strBuilder.reverse().toString());
        System.out.println(strBuilder.toString());

        System.out.println(strBuilder.delete(0, 4).toString());   // 删除

        System.out.println(strBuilder.insert(3,"LLLLL").toString());  // 插入
    }

}

StringBuffer类

StringBuffer():返回一个空串，长度为16个字符,实现对字符的增删改查。

除了字符所占的空间外，另外加16个字符大小的缓冲区。

package com.geekbang.learn;

public class LearnStringBuffer {
    public static void main(String[] args) {
        String s = new String("This is A String");
        StringBuffer sb = new StringBuffer(s);
        sb.insert(sb.length(), "BufferDemo").insert(sb.length(), 2);
        System.out.println(sb.toString());
    }
}

• String : 不可变字符序列
• StringBuillder：可变字符序列、效率高、线程不安全
• StringBuffer：可变字符序列、效率低、线程安全

15.继承

• 子类继承了父类的方法和属性
• 使用子类的引用可以调用父类的共有方法
• 使用子类的引用可以访问父类的共有属性
• 就好像子类的引用可以一物体=二用，既可以当做父类的引用使用，又可以当做子类的引用使用。 

// >> TODO 继承的语法就是在类名后面使用extends 加 要继承的类名
// >> TODO 被继承的类叫做父类（Parent Class），比如本例中的MerchandiseV2。
// >> TODO 继承者叫做子类（Sub Class），比如本例中的PhoneExtendsMerchandise。
// >> TODO Java中只允许一个类有一个直接的父类（Parent Class），即所谓的单继承
// >> TODO 没错，别的类也可以继承子类，比如可以有一个HuaweiPhone继承PhoneExtendsMerchandise
//    TODO 这时候，HuaweiPhone就是PhoneExtendsMerchandise的子类了。
// >> TODO 子类继承了父类什么呢？所有的属性和方法。
// >> TODO 但是子类并不能访问父类的private的成员（包括方法和属性）。

 组合 is-a 和 集成 has-a

 package com.geekbang.supermarket;

// >> TODO 继承，其实表达的是一种"is-a"的关系，也就是说，在你用类构造的世界中，"子类是父类的一种特殊类别"

// >> TODO 组合和继承，是拿到一个问题，设计相应的Java类的时候，不得不面对的来自灵魂的拷问
//    TODO "XX到底是YY的一种，还是只是组合了YY？"，"手机到底是手电筒的一种，还是组合了一个可以当手电的闪光灯？"


// TODO 在组合的情况下，怎么限制一次只能买五个手机呢？
// TODO 1）首先不能修改MerchandiseV2这个类，否则你会限制所有商品一次购买的数量
// TODO 2）其次，在现实情况下，这个类可能根本不受你控制，你无权修改其代码
// TODO 3）在每次调用buy方法的地方做限制，是不行的，
//      TODO - 你无法控制别人怎么用你的类，
//      TODO - 而且会面临到处复制代码的糟糕情况，
//      TODO - 如果说限制改成10个，所有复制的代码都要改，程序员都应该很懒，这不是一个程序员该做的事情
// TODO 4）在只能修改手机类的情况下，我们可以提供一个buyPhone的方法，实现限制购买数量的逻辑。
// TODO    但是这样并不能阻止别人像下面这样调用merchandise的buy方法，这个方法是会修改库存的，所以还是无法硬性的限制一次性购买手机的数量

// TODO 我们来理清一下自己的核心诉求：针对手机，限制一次性购买的数量。必须限制死，必须不影响别的商品，必须只能改手机类的代码
// TODO 这时候，组合就无能为力了，继承可以发挥其应有的作用。


// >> TODO 继承不是组合，继承也不只是为了能简单的拿来父类的属性和方法。如果仅仅如此，原封不动的拿来主义，组合也能做到。
//    TODO 继承也不是通过组合的方式来实现的。和组合相比，继承更像是"融合"
//    TODO 所谓融合，即合二为一，可以互相影响。父类影响子类没问题，子类怎么影响父类呢？如何限制手机一次只能最多买五个？

public class PhoneExtendsMerchandise extends MerchandiseV2 {}

覆盖才是继承的精髓

// >> TODO 通过使用和父类方法签名一样，而且返回值也必须一样的方法，可以让子类覆盖(override)掉父类的方法

// >> TODO ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓下面才是继承的终极奥义↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

// >> TODO 也就是说，子类并不是只能把父类的方法拿过来，而且可以通过覆盖来替换其中不适合子类的方法

// >> TODO ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑上面才是继承的终极奥义↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑

// >> TODO 题外话：属性是联动的，可能是有特殊意义的。
//    TODO 所以直接给属性赋值是危险的，因为没有办法检查新的值是否有意义，也没法对这个修改做联动的修改

public double buy(int count) {

    // TODO 这个方法里代码大部分和父类一样，肯定有方法解决
    if (count > MAX_BUY_ONE_ORDER) {
        System.out.println("购买失败，手机一次最多只能买" + MAX_BUY_ONE_ORDER + "个");
        return -2;
    }
    if (this.count < count) {
        System.out.println("购买失败，库存不够");
        return -1;
    }
    this.count -= count;
    double cost = count * soldPrice;
    System.out.println("购买成功，花费为" + cost);
    return cost;
}

返回值必须一样，不是类型兼容，而是必须一摸一样。
如果签名一样，但是返回值不一样，会是错误

public String getName() {
    return name;
}

// >> TODO 覆盖可以覆盖掉父类的方法。同一个方法，不同的行为。
// >> TODO 这，就是多态！
// >> TODO 方法可以覆盖，属性访问不可以，所以这也是使用方法的一个原因。
//    TODO 即使在父类里，只是一个简单的getName，但是这样做，子类就可以覆盖掉父类的方法
//    TODO 方法不止眼前的代码，还有子类的覆盖。用方法，才能覆盖，才能多态。

public String getName() {
    return this.brand + ":" + this.os + ":" + name;
}

替换父类代码  ---> super

父类可以多继承super可以是多个类的方法和访问public属性

子类：
// >> TODO 使用super可以调用父类的方法和属性（当然必须满足访问控制符的控制）
public double buy(int count) {
    if (count > MAX_BUY_ONE_ORDER) {
        System.out.println("购买失败，手机一次最多只能买" + MAX_BUY_ONE_ORDER + "个");
        return -2;
    }
    return super.buy(count);
}
父类：

public double buy(int count) {
    if (this.count < count) {
        System.out.println("购买失败，库存不够");
        return -1;
    }
    this.count -= count;
    double cost = count * soldPrice;
    System.out.println("购买成功，花费为" + cost);
    return cost;
}

子类：

public void describe() {
    System.out.println("此手机商品属性如下");
    super.describe();
    System.out.println("手机厂商为" + brand + "；系统为" + os + "；硬件配置如下：
" +
        "屏幕：" + screenSize + "寸
" +
        "cpu主频" + cpuHZ + " GHz
" +
        "内存" + memoryG + "Gb
" +
        "存储空间" + storageG + "Gb");
}

父类：

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

super并不会是父类的引用

  // >> TODO super是子类和父类交流的桥梁，但是并不是父类的引用
    // >> TODO 所以，super和this自引用不一样，不是简单可以模拟的（可以模拟的话不就成了组合了吗）
//    public MerchandiseV2 getParent(){
//        return super;
//    }

    public Phone getThisPhone(){
        return this;
    }

    // >> TODO 使用super可以调用父类的public属性，但是super不是一个引用。
    public void accessParentProps() {
        System.out.println("父类里的name属性：" + super.name);
    }

    public void useSuper() {
        // >> TODO super的用法就像是一个父类的引用。它是继承的一部分，像组合的那部分，但不是全部
        super.describe();
        super.buy(66);
        System.out.println("父类里的count属性：" + super.count);
    }

可以认为，创建子类对象的时候，也就同时创建了一个隐藏的父类对象，集成链上所有的数据

Super调用构造方法

private String name;
private String id;
private int count;
private double soldPrice;
private double purchasePrice;

public Phone(
        String name, String id, int count, double soldPrice, double purchasePrice,
        double screenSize, double cpuHZ, int memoryG, int storageG, String brand, String os
) {
    // >> TODO 使用super调用父类的构造方法，必须是子类构造方法的第一个语句
    // >> TODO 可以使用表达式
    // >> TODO super调用构造方法，不可以使用super访问父类的属性和方法，不可以使用子类成员变量和方法
    // >> TODO 可以使用静态变量和方法
    // >> TODO 都是<init>方法，我们来看一下
    super(name, id, count, soldPrice * 1.2, purchasePrice);
    init(screenSize, cpuHZ, memoryG, storageG, brand, os);
}

public void init(double screenSize, double cpuHZ, int memoryG, int storageG, String brand, String os) {
    this.screenSize = screenSize;
    this.cpuHZ = cpuHZ;
    this.memoryG = memoryG;
    this.storageG = storageG;
    this.brand = brand;
    this.os = os;
}

public MerchandiseV2(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;
}

super this 都要放第一个 矛盾  可是使用init方法来解决，init是自己写的。

public Phone() {
    super("无名", "000", 0, 1, 1.1);   父类有参数的构造方法
    init(4.5, 4.6, 6, 128, "Uknown", "Uknown");
}

子类的构造方法会调用父类的构造方法，默认调用父类无参的构造方法

public Phone() {
    init(4.5, 4.6, 6, 128, "Uknown", "Uknown");
}
默认调用父类方法

public MerchandiseV2() {
    this("无名", "000", 0, 1, 1.1);
}

// >> TODO 可以用子类的引用给父类的引用赋值，也就是说，父类的引用可以指向子类的对象

MerchandiseV2 m = ph;
MerchandiseV2 m2 = new Phone(
    "手机002", "Phone002", 100, 1999, 999,
    4.5, 3.5, 4, 128, "索尼", "安卓"
);

// >> TODO 但是反之则不行，不能让子类的引用指向父类的对象。因为父类并没有子类的属性和方法呀

// >> TODO                          重点
// >> TODO 因为子类继承了父类的方法和属性，所以父类的对象能做到的，子类的对象肯定能做到
//    TODO 换句话说，我们可以在子类的对象上，执行父类的方法
// >> TODO 当父类的引用指向子类的实例（或者父类的实例），只能通过父类的引用，像父类一样操作子类的对象
//    TODO 也就是说"名"的类型，决定了能执行哪些操作


// >> TODO ph和m都指向同一个对象，通过ph可以调用getBrand方法
//    TODO 因为ph的类型是Phone，Phone里定义了getBrand方法
ph.getBrand();

只能根据引用类型来决定对象的操作。

 // TODO 如果确定一个父类的引用指向的对象，实际上就是一个子类的对象（或者子类的子类的对象），可以强制类型转换
    Phone aPhone = (Phone) m2;

    // MerchandiseV2是Phone的父类，Phone是shellColorChangePhone的父类
    ShellColorChangePhone shellColorChangePhone = new ShellColorChangePhone(
        "手机002", "Phone002", 100, 1999, 999,
        4.5, 3.5, 4, 128, "索尼", "安卓"
    );

    // TODO 父类的引用，可以指向子类的对象，即可以用子类（以及子类的子类）的引用给父类的引用赋值
    MerchandiseV2 ccm = shellColorChangePhone;

    // TODO 父类的引用，可以指向子类的对象。
    // TODO 确定MerchandiseV2的引用ccm是指向的是Phone或者Phone的子类对象，那么可以强制类型转换
    Phone ccp = (Phone) ccm;

    // TODO 确定MerchandiseV2的引用ccm是指向的是ShellColorChangePhone或者ShellColorChangePhone的子类对象
    // TODO 那么可以强制类型转换
    ShellColorChangePhone scp = (ShellColorChangePhone) ccm;

    // TODO 会出错，因为m2指向的是一个Phone类型的对象，不是ShellColorChangePhone的对象
    ShellColorChangePhone notCCP = (ShellColorChangePhone) m2;

package com.geekbang;

import com.geekbang.supermarket.LittleSuperMarket;

public class PolymorphismAppMainSimple {
    public static void main(String[] args) {
        LittleSuperMarket superMarket = new LittleSuperMarket("大卖场",
            "世纪大道1号", 500, 600, 100);

        // >> TODO 虽然是用的父类的引用指向的不同类型的对象，调用getName方法时，实际执行的方法取决于对象的类型，而非引用的类型
        // >> TODO 也就是说，能调用哪些方法，是引用决定的，具体执行哪个类的方法，是引用指向的对象决定的。
        //    TODO 这就是覆盖的精髓。覆盖是多态的一种，是最重要的一种。
        // >> TODO 以getName为例，父类里有这个方法，所以肯定都可以调用，但是Phone覆盖了父类的getName方法
        //    TODO 之前我们使用子类的引用指向子类的对象，调用子类里覆盖父类的方法，比如getName，执行的是子类的getName方法，我们觉得很自然。
        //    TODO 这里变换的是，我们用父类的引用指向子类的对象，调用被子类覆盖的方法，实际执行的还是子类里的getName方法
        //    TODO 当我们用父类的引用指向一个Phone的实例，并调用getName方法时，实际调用的就是Phone类里定义的getName方法
        System.out.println(superMarket.getMerchandiseOf(0).getName());
        System.out.println();
        System.out.println(superMarket.getMerchandiseOf(10).getName());
        // TODO 如果子类里没有覆盖这个方法，就去父类里找，父类里没有，就去父类的父类找。反之只要能让一个引用指向这个对象
        // TODO 就说明这个对象肯定是这个类型或者其子类的的一个实例（否则赋值会发生ClassCastException），总归有父类兜底。
        System.out.println();
        System.out.println(superMarket.getMerchandiseOf(100).getName());

    }
}

package com.geekbang;

import com.geekbang.supermarket.LittleSuperMarket;

public class PolymorphismAppMainComplex {
    public static void main(String[] args) {
        LittleSuperMarket superMarket = new LittleSuperMarket("大卖场",
            "世纪大道1号", 500, 600, 100);

        // >> TODO 不仅如此，我们看一个更复杂的例子，describe方法。
        // TODO MerchandiseV2里的describe方法，调用了calculateProfit方法
        // TODO Phone里的describe方法，覆盖了直接父类MerchandiseV2里的describe方法，并且使用super调用了父类的describe方法
        // TODO ShellColorChangePhone里的describe方法，覆盖了直接父类Phone里的describe方法，并且使用super调用了父类的describe方法
        // TODO 更复杂的是，ShellColorChangePhone还覆盖了间接父类MerchandiseV2里的calculateProfit方法
        superMarket.getMerchandiseOf(0).describe();
        System.out.println();
        superMarket.getMerchandiseOf(10).describe();
        System.out.println();
        superMarket.getMerchandiseOf(100).describe();

        // >> TODO 总结：无论一个方法是使用哪个引用被调用的，"它都是在实际的对象上执行的"。执行的任何一个方法，都是这个对象所属的类的方法。
        //    TODO 如果没有，就去父类找，再没有，就去父类的父类找，依次寻找，知道找到。

        //    TODO 换个角度理解。我们一直说子类里又一个（特殊的）父类的对象。这时候，这个特殊的父类的对象里的this自引用，是子类的引用。
        //    TODO 那么自然的，即使是在继承自父类的代码里，去调用一个方法，也是先从子类开始，一层层继承关系的找。

        //    TODO 这也是Java选择单继承的重要原因之一。在多继承的情况下，如果使用不当，多态可能会非常复杂，以至于使用的代价超过其带来的好处。

    }
}

静态多态 重载 Overload

动态多态 覆盖 Override

之前重载的时候，参数是用的自定义类型。现在理解了父类和子类的引用赋值关系，重载又多了一层复杂性

package com.geekbang;

import com.geekbang.supermarket.LittleSuperMarket;
import com.geekbang.supermarket.MerchandiseV2;
import com.geekbang.supermarket.Phone;
import com.geekbang.supermarket.ShellColorChangePhone;

public class OverloadTestAppMain {
    public static void main(String[] args) {
        LittleSuperMarket superMarket = new LittleSuperMarket("大卖场",
            "世纪大道1号", 500, 600, 100);
        MerchandiseV2 m = superMarket.getMerchandiseOf(100);

        MerchandiseTest merchandiseTest = new MerchandiseTest();

        System.out.println("-----------1-------------");
        // TODO 重载调用哪个方法，和参数的引用类型相关，和引用实际指向的类型无关
        merchandiseTest.testMerchandiseOverload(m);
        merchandiseTest.testMerchandiseOverload((Phone) m);
        merchandiseTest.testMerchandiseOverload((ShellColorChangePhone) m);
        // TODO 甚至是个null也可以，但是要用强制类型转换，告诉Java这个类型是什么，否则找不到一个唯一的方法去调用
        // TODO 重载的参数类型，相同位置，不一定要有继承或者兼容的关系，完全free style
        merchandiseTest.testMerchandiseOverload("");

        System.out.println("-----------2-------------");

        System.out.println();
        // >> TODO 引用本身是null没关系，确定调用哪个方法只需要引用的类型。这叫做静态多态。即在编译期就知道该调用哪个方法
        m = null;
        merchandiseTest.testMerchandiseOverload(m);
        merchandiseTest.testMerchandiseOverload((Phone) m);
        merchandiseTest.testMerchandiseOverload((ShellColorChangePhone) m);

        System.out.println("-----------3-------------");

        // >> TODO 如果引用类型没有完全匹配的，则会根据继承关系，沿着参数当前类型，向下撸
        merchandiseTest.testMerchandiseOverloadNotExactlyMatchType((ShellColorChangePhone) null);


        // >> TODO 重载总结：静态多态，调用的方法和参数实际指向的对象无关，只和引用本身的类型相关。
        // >> TODO 因为调用时参数类型是确定的，所以，在编译期间就可以明确的知道哪个方法会被调用。如果有多种可能，则会有编译错误
        // >> TODO 如果没有类型完全匹配的候选，则根据类型的继承关系向下撸着找。找到最贴近参数类型的那个方法
        // >> TODO 无论是静态方法，还是成员方法，重载寻找方法的顺序是一样的，在这里就不赘述了
        //    TODO （再提一句多继承，Java没有多继承，是前辈给我们的馈赠。保护了发际线。心疼隔壁CPP的程序员）


    }
}

package com.geekbang;

import com.geekbang.supermarket.MerchandiseV2;
import com.geekbang.supermarket.Phone;
import com.geekbang.supermarket.ShellColorChangePhone;

public class MerchandiseTest {

    // TODO 之前重载的时候，参数是用的自定义类型。现在理解了父类和子类的引用赋值关系，重载又多了一层复杂性

    public void testMerchandiseOverload(MerchandiseV2 me) {
        System.out.println("参数为MerchandiseV2的testMerchandiseOverload 被调用了");
    }

    public void testMerchandiseOverload(Phone ph) {
        System.out.println("参数为Phone的testMerchandiseOverload 被调用了");
    }

    public void testMerchandiseOverload(ShellColorChangePhone shellColorChangePhone) {
        System.out.println("参数为ShellColorChangePhone的testMerchandiseOverload 被调用了");
    }

    public void testMerchandiseOverload(String str) {
        System.out.println("参数为String的testMerchandiseOverload 被调用了");
    }

    public void testMerchandiseOverloadNotExactlyMatchType(MerchandiseV2 me) {
        System.out.println("参数为MerchandiseV2的testMerchandiseOverloadNotExactlyMatchType 被调用了");
    }

//    public void testMerchandiseOverloadNotExactlyMatchType(Phone ph) {
//        System.out.println("参数为Phone的testMerchandiseOverloadNotExactlyMatchType 被调用了");
//    }

    public void testMerchandiseOverloadNotExactlyMatchType(String str) {
        System.out.println("参数为String的testMerchandiseOverloadNotExactlyMatchType 被调用了");
    }

}

instanceof操作

package com.geekbang;

import com.geekbang.supermarket.LittleSuperMarket;
import com.geekbang.supermarket.MerchandiseV2;
import com.geekbang.supermarket.Phone;
import com.geekbang.supermarket.ShellColorChangePhone;

public class InstanceOfTestAppMain {
    public static void main(String[] args) {
        int merchandiseCount = 600;
        LittleSuperMarket superMarket = new LittleSuperMarket("大卖场",
            "世纪大道1号", 500, merchandiseCount, 100);

        // >> TODO instanceof 操作符，可以判断一个引用指向的对象是否是某一个类型或者其子类
        //    TODO 是则返回true，否则返回false
        for(int i =0;i<merchandiseCount;i++){
            MerchandiseV2 m = null;// superMarket.getMerchandiseOf(i);
            if(m instanceof MerchandiseV2){
                // TODO 先判断，再强制类型转换，比较安全
                MerchandiseV2 ph = (MerchandiseV2)m;
                System.out.println(ph.getName());
            }else {
                System.out.println("not an instance");
            }
        }

        // >> TODO 如果引用是null，则肯定返回false
    }
}

Protected 继承专属的访问控制

同一个包可见+子类可见

package com.geekbang.onlinemarket;

import com.geekbang.supermarket.Phone;

public class OnlineSpecialPhone extends Phone {

    public OnlineSpecialPhone(String name, String id, int count, double soldPrice, double purchasePrice, double screenSize, double cpuHZ, int memoryG, int storageG, String brand, String os) {
        super(name, id, count, soldPrice, purchasePrice, screenSize, cpuHZ, memoryG, storageG, brand, os);
        this.screenSize = 99;
    }

    // >> TODO 子类覆盖父类的方法，不可以用可见性更低的修饰符，但是可以用更高的修饰符
    // >> TODO 原因是什么呢？
   public String getNameOfPhone(){
        return super.getNameOfPhone();
   }
}

final

final修饰类：不可被继承

final修饰方法: 不可被子类覆盖

final修饰变量：不可被赋值（修改）

final修饰变量 在 static块赋值只能赋值一次。

final只能指向这个引用，引用的值不能修改，但是引用本身的值可以修改。

静态方法的继承

没有的静态方法可以话执行的话，执行父类的静态方法

签名和返回值必须一致

package com.geekbang;

import com.geekbang.supermarket.LittleSuperMarket;
import com.geekbang.supermarket.MerchandiseV2;
import com.geekbang.supermarket.Phone;
import com.geekbang.supermarket.ShellColorChangePhone;

public class StaticMethodDoesNotBelieveOverride {
    public static void main(String[] args) {
        LittleSuperMarket superMarket = new LittleSuperMarket("大卖场",
            "世纪大道1号", 500, 600, 100);


        System.out.println("-----1------");


        // >> TODO 静态方法可以被继承
        MerchandiseV2.staticMethod();
        Phone.staticMethod();
        ShellColorChangePhone.staticMethod();

        System.out.println("-----2------");

        MerchandiseV2 m = superMarket.getMerchandiseOf(100);

        // >> TODO 用引用调用静态方法没有覆盖
        m.staticMethod();
        ((Phone) m).staticMethod();
        ((ShellColorChangePhone) m).staticMethod();
        // TODO 有些东西，学会就应该马上忘掉，比如上面使用引用调用静态方法的内容

        System.out.println("-----3------");

        ((MerchandiseV2) null).staticMethod();
        ((Phone) null).staticMethod();
        ((ShellColorChangePhone) null).staticMethod();
        // TODO 有些东西，学会就应该马上忘掉，比如上面使用有类型的null引用调用静态方法的内容

    }
}

父类可以强转成子类

null是引用的缺省值，强转给null一个类型信息

Object

没有成员变量

hashcode 表示对象的特征值的int整数

哈希吗 散列吗

equals判断两个对象从逻辑上是否相对

需要覆盖

// >> TODO hashCode 和 equals是我们最常覆盖的两个方法
// >> TODO 覆盖的原则是，equals为true，hashCode就应该相等。这是一种约定俗成的规范
// >> TODO 即equals为true是hashCode相等的充分非必要条件，hashCode相等是equals为true的必要不充分条件


@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof MerchandiseV2)) return false;
    MerchandiseV2 that = (MerchandiseV2) o;
    return this.getCount() == that.getCount() &&
            Double.compare(that.getSoldPrice(), getSoldPrice()) == 0 &&
            Double.compare(that.getPurchasePrice(), getPurchasePrice()) == 0 &&
            getName().equals(that.getName()) &&
            getId().equals(that.getId());
}

@Override
public int hashCode() {
    return Objects.hash(getName(), getId(), getCount(), getSoldPrice(), getPurchasePrice());
}