Day1 面向对象编程与Java核心类

this变量

在方法内部，可以使用一个隐含的变量this，它始终指向当前实例。如果没有命名冲突，可以省略this。

但是，如果有局部变量和字段重名，那么局部变量优先级更高，就必须加上this。

构造方法

要特别注意的是，如果我们自定义了一个构造方法，那么，编译器就不再自动创建默认构造方法。

如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来。

方法重载

这种方法名相同，但各自的参数不同，称为方法重载（Overload）。

注意：方法重载的返回值类型通常都是相同的。

重载（overload）与重写（override）不同

Override和Overload不同的是，如果方法签名如果不同，就是Overload，Overload方法是一个新方法；如果方法签名相同，并且返回值也相同，就是Override。

方法名和形参列表共同组成方法签名。https://blog.csdn.net/ftell/article/details/80527159

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

条件为：

1.数列表必须完全与被重写方法的相同。

2.返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

3.访问权限*不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

4.父类的成员方法只能被它的子类重写。

5.声明为 final 的方法不能被重写。

6.声明为 static 的方法不能被重写，但是能够被再次声明。

7.子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

8.子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

9.重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

10.构造方法**不能被重写。

11.如果不能继承一个方法，则不能重写这个方法。

异常

https://blog.csdn.net/hguisu/article/details/6155636

继承

Java使用extends关键字来实现继承

protected关键字可以把字段和方法的访问权限控制在继承树内部，让子类访问父类的成员，但无法修改。

super关键字表示父类（超类）。子类引用父类的字段时，可以用super.fieldName。

向上/向下转型

这种把一个子类类型安全地变为父类类型的赋值，被称为向上转型（upcasting）。

父类类型强制转型为子类类型，就是向下转型（downcasting）

区分继承和组合

究其原因，是因为Student是Person的一种，它们是is关系，而Student并不是Book。实际上Student和Book的关系是has关系。

具有has关系不应该使用继承，而是使用组合，即Student可以持有一个Book实例：、

class Student extends Person {
    protected Book book;
    protected int score;
}

多态

在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为覆写/重写（Override）。

抽象类

如果一个class定义了方法，但没有具体执行代码，这个方法就是抽象方法，抽象方法用abstract修饰。

因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。

使用abstract修饰的类就是抽象类。我们无法实例化一个抽象类：

Person p = new Person(); // 编译错误

抽象类本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。

接口

如果一个抽象类没有字段，所有方法全部都是抽象方法：

abstract class Person {
    public abstract void run();
    public abstract String getName();
}

就可以把该抽象类改写为接口：interface。

interface Person {
    void run();
    String getName();
}

所谓interface，就是比抽象类还要抽象的纯抽象接口，因为它连字段都不能有。因为接口定义的所有方法默认都是public abstract的，所以这两个修饰符不需要写出来（写不写效果都一样）。

当一个具体的class去实现一个interface时，需要使用implements关键字。举个例子：

class Student implements Person {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(this.name + " run");
    }

    @Override
    public String getName() {
        return this.name;
    }
}

我们知道，在Java中，一个类只能继承自另一个类，不能从多个类继承。但是，一个类可以实现多个interface，例如

class Student implements Person, Hello { // 实现了两个interface
    ...
}

**接口可以继承

一个interface可以继承自另一个interface。interface继承自interface使用extends，它相当于扩展了接口的方法。

java8之前接口中的方法默认类型都是public abstract，也就是抽象方法，具体实现都交给实现类。

而java8对接口功能做了增强，增加了default方法和static方法，也就是说从java8开始接口中的方法不再只能是抽象的，也可以有实现。

实现类可以重写default方法，不能重写static方法。

https://www.jianshu.com/p/f8a84c498726

包 jar 模块

要特别注意：包没有父子关系。java.util和java.util.zip是不同的包，两者没有任何继承关系。

jar文件就是class文件的容器。

模块的重要作用就是声明依赖关系。

======核心类-

1.字符串

2.StringBuilder

3.StringJoiner

4.包装类型

5.JavaBean

6.枚举

7.常用工具类

String

String是一个引用类型。它本身也是一个class。Java字符串的一个重要特点就是字符串不可变

当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用equals()方法而不能用==

Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池。

要忽略大小写比较，使用equalsIgnoreCase()方法。

string方法https://www.liaoxuefeng.com/wiki/1252599548343744/1260469698963456

StringBuilder

查看StringBuilder的源码，可以发现，进行链式操作的关键是，定义的append()方法会返回this，这样，就可以不断调用自身的其他方法。

在编译时就自动把多个连续的+操作编码为StringConcatFactory的操作

StringJoiner

类似用分隔符拼接数组的需求很常见，所以Java标准库还提供了一个StringJoiner来干这个事：

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}

如果查看源码，可以发现，StringJoiner内部实际上就是使用了StringBuilder

包装类型

把一个基本类型视为对象（引用类型）？

比如，想要把int基本类型变成一个引用类型，我们可以定义一个Integer类，它只包含一个实例字段int，这样，Integer类就可以视为int的包装类（Wrapper Class）：

Bean

在Java中，有很多class的定义都符合这样的规范：

若干private实例字段；

通过public方法来读写实例字段。

例如：

public class Person {
    private String name;
    private int age;

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

    public int getAge() { return this.age; }
    public void setAge(int age) { this.age = age; }
}

如果读写方法符合以下这种命名规范：

// 读方法:
public Type getXyz()
// 写方法:
public void setXyz(Type value)
那么这种class被称为JavaBean：

读写方法合称为属性

JavaBean的作用

JavaBean主要用来传递数据**，即把一组数据组合成一个JavaBean便于传输。此外，JavaBean可以方便地被IDE工具分析，生成读写属性的代码，主要用在图形界面的可视化设计中。

枚举类

在Java中，我们可以通过static final来定义常量。例如，我们希望定义周一到周日这7个常量，可以用7个不同的int表示：

public class Weekday {
    public static final int SUN = 0;
    public static final int MON = 1;
    public static final int TUE = 2;
    public static final int WED = 3;
    public static final int THU = 4;
    public static final int FRI = 5;
    public static final int SAT = 6;
}

为了让编译器能自动检查某个值在枚举的集合内(比如不能有星期八），并且，不同用途的枚举需要不同的类型来标记，不能混用，我们可以使用enum来定义枚举类：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day == Weekday.SAT || day == Weekday.SUN) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}

enum Weekday {
    SUN, MON, TUE, WED, THU, FRI, SAT;
}

和int定义的常量相比，使用enum定义枚举有如下好处：

首先，enum常量本身带有类型信息，即Weekday.SUN类型是Weekday，编译器会自动检查出类型错误。例如，下面的语句不可能编译通过：

int day = 1;
if (day == Weekday.SUN) { // Compile error: bad operand types for binary operator '=='
}

使用enum定义的枚举类是一种引用类型。前面我们讲到，引用类型比较，要使用equals()方法，如果使用==比较，它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用equals()方法，但enum类型可以例外。

这是因为enum类型的每个常量在JVM中只有一个唯一实例，所以可以直接用==比较

BigInteger大数

如果我们使用的整数范围超过了long型怎么办？这个时候，就只能用软件来模拟一个大整数。java.math.BigInteger就是用来表示任意大小的整数。BigInteger内部用一个int[]数组来模拟一个非常大的整数：

BigInteger bi = new BigInteger("1234567890");
System.out.println(bi.pow(5)); // 2867971860299718107233761438093672048294900000

对BigInteger做运算的时候，只能使用实例方法，例如，加法运算：

BigInteger i1 = new BigInteger("1234567890");
BigInteger i2 = new BigInteger("12345678901234567890");
BigInteger sum = i1.add(i2); // 12345678902469135780

BigInteger用于表示任意大小的整数；

BigInteger是不变类，并且继承自Number；

将BigInteger转换成基本类型时可使用longValueExact()等方法保证结果准确

BigDecimal

和BigInteger类似，BigDecimal可以表示一个任意大小且精度完全准确的浮点数。