Java基礎

時間 2019-12-09

標籤 java 基礎欄目 Java 简体版

原文原文鏈接

基本類型

數據類型	大小/bit
byte	8位
short	16位
int	32位
long	64位
float	32位
double	64位
char	16位
boolean	1位

Integer

new Integer(int)：返回一個全新的Integer對象。
Integer.parseInt(String s):返回基本類型int
Integer.valueOf(String s):返回一個Integer對象，會用到cache緩存（-128~127），效率可能比new Integer()要高。
new Integer(String s)：源碼即調用parseInt方法。

String

可變與不可變html

String類中使用字符數組來保存字符串，由於有final修飾符，因此string對象是不可變的。一旦建立，就不能修改她的值，對於已經存在的String對象修改都是建立一個新的對象。

private final char value[];

StringBuffer和StringBuilder都是繼承AbstractStringBuilder類，在類中也是使用字符數組來保存字符串，但沒有final修飾，故能夠改變。

char[] value;

是否線程安全java

String類對象是不可變的，故線程安全。
AbstractStringBuilder是StringBuffer跟StringBuilder的公共父類，定義了一些字符串的基本操做，如expandCapacity、append、insert、indexOf等方法。
StringBuffer對方法加了同步鎖或對調用的方法加了同步鎖，因此是線程安全的。

  public   synchronized  StringBuffer reverse() {
           super .reverse();
           return   this ;
      }
      
       public   int  indexOf(String str) {
           return  indexOf(str, 0);         //存在 public synchronized int indexOf(String str, int fromIndex) 方法
      }

StringBuilder並無對方法進行加同步鎖，因此是非線程安全的。

StringBuilder跟StringBuffer擴容

當char[] 數組大小即capacity不足時，StringBuilder的擴容爲原來的capacity*2+2；編程

length()方法返回已使用的長度
capacity()方法返回char[]數組的長度

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

equals()

與null的比較

對任何不是null的對象x調用x.equals(null)結果都爲false。數組

equals()與==

對於基本類型，== 判斷兩個值是否相等，基本類型沒有equals()方法。
對於引用類型，==判斷兩個實例是否引用同一對象，而equals()判斷對象的引用是否等價，根據對象引用equals()方法的具體實現來進行比較。

Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y);      // false

實現

判斷是否爲同一對象的引用，若是是直接返回true。
判斷是不是同一類型，若是不是直接返回false。
將Object實例進行轉型。
判斷每一個關鍵域是否相等。

public class EqualExample {
    private int x;
    private int y;
    private int z;

    public EqualExample(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        EqualExample that = (EqualExample) o;

        if (x != that.x) return false;
        if (y != that.y) return false;
        return z == that.z;
    }
}

hashCode()

hashCode()返回散列值，而equals()是用來判斷兩個實例是否等價，等價的兩個實例散列值必定要相等，可是散列值相同的兩個實例不必定等價。緩存

在覆蓋equals()方法時應當老是覆蓋hashCode()方法，保證等價的兩個實例散列值也相等。安全

下面代碼中，新建了兩個等價的實例，並將它們添加到HashSet中，咱們但願將這兩個實例當成同樣的，只在集合中添加一個實例，可是由於EqualExample沒有實現hashCode()方法，所以這兩個實例的散列值是不相同的，最終致使集合添加了兩個等價的實例。網絡

EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size());   // 2

理想的散列函數應當具備均勻性，既不相等的實例應當分佈在全部可能的散列值上。這就要求散列值要把全部的值都考慮進來，能夠將每一個域都當成R進制的某一位，而後組成一個R進程的整數。R通常取31，由於它是一個奇素數，若是是偶數的話，當出現乘法溢出，信息會丟失，由於與2相乘至關於向左移一位。app

一個數與 31 相乘能夠轉換成移位和減法：31*x == (x<<5)-x，編譯器會自動進行這個優化。ide

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + x;
    result = 31 * result + y;
    result = 31 * result + z;
    return result;
}

toString()

默認返回ToStringExample@4554617c 這種形式，其中@後面的數值爲散列值的無符號十六進制表示。函數

public class ToStringExample {
    private int number;

    public ToStringExample(int number) {
        this.number = number;
    }
}

ToStringExample example = new ToStringExample(123);
System.out.println(example.toString());

ToStringExample@4554617c

clone()

cloneable

clone()是Object的protect方法，它不是public，一個類不顯示區重寫clone()，其餘類就不能直接去調用該類實例的clone()方法。

public class CloneExample {
    private int a;
    private int b;
}
CloneExample e1 = new CloneExample();
// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'

重寫clone()獲得如下實現：

public class CloneExample {
    private int a;
    private int b;

    @Override
    protected CloneExample clone() throws CloneNotSupportedException {
        return (CloneExample)super.clone();
    }
}

CloneExample e1 = new CloneExample();
try {
    CloneExample e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

java.lang.CloneNotSupportedException: CloneExample

以上拋出了CloneNotSupportedException，這個由於CloneExample沒有實現Cloneable接口。

public class CloneExample implements Cloneable {
    private int a;
    private int b;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

應該注意的是，clone()方法並非Cloneable接口的方法，而是Object的一個protect方法。Cloneable接口只是規定，若是一個類沒有實現Cloneable接口又調用了clone()方法，就會拋出CloneNotSupportException。

深拷貝和淺拷貝

淺拷貝：拷貝實例和原始實例的引用類型引用同一對象。
深拷貝：拷貝實例和原始實例的引用類型引用不一樣對象。

public class ShallowCloneExample implements Cloneable {
    private int[] arr;

    public ShallowCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected ShallowCloneExample clone() throws CloneNotSupportedException {
        return (ShallowCloneExample) super.clone();
    }
}


ShallowCloneExample e1 = new ShallowCloneExample();
ShallowCloneExample e2 = null;
try {
    e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 222

public class DeepCloneExample implements Cloneable {
    private int[] arr;

    public DeepCloneExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }

    @Override
    protected DeepCloneExample clone() throws CloneNotSupportedException {
        DeepCloneExample result = (DeepCloneExample) super.clone();
        result.arr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            result.arr[i] = arr[i];
        }
        return result;
    }
}


DeepCloneExample e1 = new DeepCloneExample();
DeepCloneExample e2 = null;
try {
    e2 = e1.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 2

使用clone()方法來拷貝一個對象即複雜又有風險，它會拋出異常，而且還須要類型轉換。最好不要去使用clone()而是使用拷貝構造函數或者拷貝工廠來拷貝一個對象。

public class CloneConstructorExample {
    private int[] arr;

    public CloneConstructorExample() {
        arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }

    public CloneConstructorExample(CloneConstructorExample original) {
        arr = new int[original.arr.length];
        for (int i = 0; i < original.arr.length; i++) {
            arr[i] = original.arr[i];
        }
    }

    public void set(int index, int value) {
        arr[index] = value;
    }

    public int get(int index) {
        return arr[index];
    }
}
CloneConstructorExample e1 = new CloneConstructorExample();
CloneConstructorExample e2 = new CloneConstructorExample(e1);
e1.set(2, 222);
System.out.println(e2.get(2)); // 2

面向對象的三個特性

封裝

利用抽象數據類型將數據和基本數據的操做封裝在一塊兒，使其構成一個不可分割的獨立實體。數據被保護在抽象數據類型的內部，儘量地隱藏內部的細節，只保留一些對外接口與外部發生聯繫。

繼承

繼承實現了 IS-A 關係，例如 Cat 和 Animal 就是一種 IS-A 關係，所以 Cat 能夠繼承自 Animal，從而得到 Animal 非 private 的屬性和方法。

繼承應該遵循里氏替換原則，子類對象必須可以替換掉全部父類對象。

多態

多態分爲編譯時多態和運行時多態，編譯時多態指方法的重載，運行時多態指程序中定義的對象引用所指向的具體類型在運行時才肯定。
運行時多態的三個條件：

繼承
覆蓋
向上轉型

如：
樂器類（Instrument）有兩個子類：Wind 和 Percussion，它們都覆蓋了父類的 play() 方法，而且在 main() 方法中使用父類 Instrument 來引用 Wind 和 Percussion 對象。在 Instrument 引用調用 play() 方法時，會執行實際引用對象所在類的 play() 方法，而不是 Instrument 類的方法。