基础知识

数据类型

八个基本类型:

boolean/1
byte/8
char/16
short/16
int/32
float/32
long/64
double/64

所有的基础类型都有其包装类，⚠️：String 并非基础类型

缓存池

编译器会在缓冲池范围内的基本类型自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。

new Integer(123) //每次都会新建一个对象
Integer.valueOf(123) //会使用缓存池中的对象，多次调用会取得同一个对象的引用。

Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y);    // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k);   // true

编译器会在缓冲池范围内的基本类型自动装箱过程调用 valueOf() 方法，因此多个 Integer 实例使用自动装箱来创建并且值相同，那么就会引用相同的对象。

Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true

基本类型对应的缓冲池如下:

boolean values true and false
all byte values
short values between -128 and 127
int values between -128 and 127
char in the range \u0000 to \u007F

String

String是final的，内部使用 char 数组存储数据，该数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。即：String 的公开规范保证其值不可变

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    ...

String 的不可变性是指：一旦某个 String 对象被创建，它所表示的字符序列就不会被改变。对字符串进行拼接、替换等操作时，不会修改原对象，而是返回一个新的 String 对象（或复用等价对象）。需要区分：变量的引用可以重新赋值指向其他 String，这不违反不可变性，因为变化的是引用的指向，而不是原 String 对象的内部状态。

好处

可以缓存 hash 值

因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。

String Pool 的需要

如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。

安全性

String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。

线程安全

String 不可变性天生具备线程安全，可以在多个线程中安全地使用。

String常量池

String.intern()

使用 String.intern() 可以保证相同内容的字符串变量引用同一的内存对象。采用 "bbb" 这种使用双引号的形式创建字符串实例，会自动地将新建的对象放入 String Pool 中

注意，实践中，使用 equals 判断值是否相等，因为实际世界中，极少存在字符串要内存地址相同这样的判断。

StringBuilder(),StringBuffer()

一般用于拼接字符串（String不可变），StringBuffer() 线程安全

GC

字符串常量池在 堆内存中实现。因为在堆上，所以只要没有引用了，就可以被正常的垃圾回收机制回收。原则：只要常量池结构里不再强引用该字符串对象，并且程序其他地方也没有强引用它，就能回收。

当然也需要触发GC才行

字面量字符串通常几乎等同于跟随类加载器存活，如在类中定义 private String abc = "abc";

运算

参数传递

Java 的参数是以值传递的形式传入方法中，而不是引用传递。

在将一个参数传入一个方法时，本质上是将对象的地址以值的方式传递到形参中。因此在方法中改变指针引用的对象，那么这两个指针此时指向的是完全不同的对象，一方改变其所指向对象的内容对另一方没有影响。

public class Dog {
    String name;

    Dog(String name) {
        this.name = name;
    }

    String getName() {
        return this.name;
    }

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

    String getObjectAddress() {
        return super.toString();
    }
}

public class PassByValueExample {
    public static void main(String[] args) {
        Dog dog = new Dog("A");
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        func(dog);
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        System.out.println(dog.getName());          // A
    }

    private static void func(Dog dog) {
        System.out.println(dog.getObjectAddress()); // Dog@4554617c
        dog = new Dog("B");
        System.out.println(dog.getObjectAddress()); // Dog@74a14482
        System.out.println(dog.getName());          // B
    }
}

如果想要避免方法内部修改

private static void func(final Dog dog) {
    // dog = new Dog("B"); // 编译错误：不能给 final 形参再次赋值
    System.out.println(dog.getObjectAddress());
}

但是如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容。

class PassByValueExample {
    public static void main(String[] args) {
        Dog dog = new Dog("A");
        func(dog);
        System.out.println(dog.getName());          // B
    }

    private static void func(Dog dog) {
        dog.setName("B");
    }
}

隐式类型转换

类型精度高的无法隐式类型转换为类型精度比它低的。

整型字面量默认是 int。一般情况下不能把 int 隐式赋值给 short，因为这是窄化转换。但如果右侧是编译期可确定的常量表达式，并且常量值在 short 的表示范围内，Java 允许进行隐式窄化赋值。

int x = 1;
short s = x; // 编译错误
short a = 1;
short b = 2;
// short c = a + b; // 编译错误：a+b 会被提升为 int
int c = a + b; // 正常

short s = (short) 1_000_000; // 允许写，但会溢出，结果不是你以为的值

short s = 1; // 可以
final int x = 1; // 原因：final int x = 1 的 x 也是编译期常量（前提是用常量表达式初始化），编译器可以在编译期就确定它的值是 1，因此允许窄化。
short s = x; // 可以

继承

访问权限

Java 中有三个访问权限修饰符: private、protected 以及 public，如果不加访问修饰符，表示包级可见。

可以对类或类中的成员(字段以及方法)加上访问修饰符。

类可见表示其它类可以用这个类创建实例对象。
成员可见表示其它类可以用这个类的实例对象访问到该成员；

protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。

设计良好的模块会隐藏所有的实现细节，把它的 API 与它的实现清晰地隔离开来。模块之间只通过它们的 API 进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念被称为信息隐藏或封装。因此访问权限应当尽可能地使每个类或者成员不被外界访问。

如果子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例，也就是确保满足里氏替换原则。

字段决不能是公有的，因为这么做的话就失去了对这个字段修改行为的控制，客户端可以对其随意修改。(java没有内置的属性机制，导致在实践中形成了一套以getter,setter为核心的属性管理机制)

但是也有例外，如果是包级私有的类或者私有的嵌套类，那么直接暴露成员不会有特别大的影响。（因为管理起来简单，直接可以在当前类找到）

抽象类与接口

略

一般情况下，使用接口，尤其jdk1.8后，接口也有默认方法。哪怕不存在所谓的要实现方法，也可以做一个接口，方便后续迭代，或者工具类的开发。

super

访问父类的构造函数: 可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。访问父类的成员: 如果子类重写了父类的中某个方法的实现，可以通过使用 super 关键字来引用父类的方法实现。

重写与重载

重写(Override) 存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。

为了满足里式替换原则，重写有以下两个限制:

子类方法的访问权限必须大于等于父类方法；
子类方法的返回类型必须是父类方法返回类型或为其子类型。

使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。

重载(Overload)

存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。

应该注意的是，返回值不同，其它都相同不算是重载。

Object 通用方法

public final native Class<?> getClass()

public native int hashCode()

public boolean equals(Object obj)

protected native Object clone() throws CloneNotSupportedException

public String toString()

public final native void notify()

public final native void notifyAll()

public final native void wait(long timeout) throws InterruptedException

public final void wait(long timeout, int nanos) throws InterruptedException

public final void wait() throws InterruptedException

protected void finalize() throws Throwable {}

基础知识

基础知识

数据类型

缓存池

基本类型对应的缓冲池如下:

String

好处

String常量池

String.intern()

StringBuilder(),StringBuffer()

GC

运算

参数传递

隐式类型转换

继承

访问权限

抽象类与接口

super

重写与重载

Object 通用方法

results matching ""

No results matching ""