類, class, 是抽象的具有共同屬性和行為的集合

類 = 屬性(變量, 字段, field) + 行為(函數(shù), 方法, method)

對(duì)象, object, 對(duì)象實(shí)例, instance, 一個(gè)實(shí)體, 一塊可以標(biāo)識(shí)的存儲(chǔ)區(qū)域

三大特征: 封裝, 繼承, 多態(tài)

類型: Application(應(yīng)用程序), Applet(小應(yīng)用, 嵌入到HTML)

Application 的基本結(jié)構(gòu)

package javanote;

publicc class Main{
    public static void main(String args[]){
        System.out.println("Hello");
    }
}

// 一個(gè)文件可以有多個(gè) class, 但是只能有一個(gè) public class, 且與文件同名
// main 方法必須是 public static
// main 方法是一個(gè)特殊的方法, 它是程序運(yùn)行的入口
// main 還可用于測(cè)試, 直接運(yùn)行該類的時(shí)候會(huì)調(diào)用 main, 如果是其他類調(diào)用這個(gè)類的方法, 則不會(huì)運(yùn)行 main
// package, 包, 文件路徑
// import, 導(dǎo)入其他的類

輸入 Scanner, 輸出 System.out.print()

package javanote;

import java.util.InputMismatchException;
import java.util.Scanner;

public class Main{
    public static void main(String args[]) {
        try {
            // 注意, 如果輸入的不是整數(shù), 而是小數(shù)/字符串, 則會(huì)報(bào)錯(cuò). 因此需要try...catch...
            Scanner in = new Scanner(System.in);
            int a = in.nextInt();
            System.out.println(a);
        }
        catch (InputMismatchException e) {
            // TODO: handle exception
        }
    }
}

整數(shù)型

byte, 1 字節(jié)

short, 2 字節(jié)

int, 4 字節(jié)

long, 8 字節(jié)

Java 中沒有 無符號(hào)數(shù)

實(shí)數(shù), 浮點(diǎn)數(shù)

float, 4 字節(jié)

double, 8 字節(jié), 浮點(diǎn)數(shù)默認(rèn)是 double

邏輯型

boolean, 1 bit, true/false

Java 中不可以用 if(1) 或 if(0), 也不能 if( a = 5 )

boolean 不能比較大小, 不能進(jìn)行算術(shù)運(yùn)算

2 + true           // error
true + true        // error, 就算換成 boolean a, b; 然后 a + b; 仍然是error
true > false       // error
1 > false          // error
true == 6;         // error
a == b > false     // error, ==, != 優(yōu)先級(jí)低, 先做 b > false, 這里也會(huì)出錯(cuò)
( a == b ) > false // error, 類似于 true > false 的error

邏輯運(yùn)算的 !, &&, || 只能用于 boolean, 作用到其他類型上面會(huì)出錯(cuò), 這點(diǎn)也和 C 不一樣

字符型

char, 2 字節(jié), 統(tǒng)一使用 Unicode 編碼, 跨平臺(tái)

強(qiáng)制類型轉(zhuǎn)換

double a = 10.3;
int b = (int)a;
int c = (int) (10/3.0);
// (10/3.0)要加括號(hào), 因?yàn)?int)是單目運(yùn)算, 優(yōu)先級(jí)高

基本數(shù)據(jù)類型, 變量在棧. 復(fù)制變量的時(shí)候，復(fù)制的是值.

非基本數(shù)據(jù)類型, 引用類型, 在堆, 變量只是引用, 類似于指針, 只能指向特定對(duì)象, 不能亂指, 復(fù)制變量的時(shí)候，復(fù)制的是引用

數(shù)組是一種容器, 所有元素有相同的數(shù)據(jù)類型, 一旦創(chuàng)建, 則不能改變大小. 數(shù)組必須用 new 來分配空間, 數(shù)組元素默認(rèn)初始化.

// 注意方括號(hào)的位置

// a和b都是數(shù)組, 其中 a 未分配空間, b 分配了 4 個(gè) int 的空間
int[] a, b = new int[4];
// c 是數(shù)組, d 是 int 變量
int c[], d;

數(shù)組是引用類型, 元素個(gè)數(shù)可以用變量定義,

// 數(shù)組是引用類型
int[] a1 = new int[3];
int b = 10;
// 元素個(gè)數(shù)可以用變量定義, 和c99類似
int[] a2 = new int[b];

// error, 數(shù)組是引用類型, 理解為指針, 不能直接給它分配空間, 分配的空間在堆, 必須 new 一塊空間然后指向那里
int a3[5];

如果沒有對(duì)數(shù)組進(jìn)行顯式初始化, 則會(huì)隱式初始化為 0 或 null, 比 C 安全

// 如果沒有對(duì)數(shù)組進(jìn)行顯式初始化, 則會(huì)隱式初始化為 0 或 null
int[] a4 = {3, 1, 2};
int[] a5 = new int[]{3, 1, 2};

// 注意, 數(shù)組元素會(huì)默認(rèn)初始化, 但是基本數(shù)據(jù)類型聲明后不會(huì)默認(rèn)初始化
int a;
a++;  // error

與指針的類似之處, 數(shù)組變量只是數(shù)組的管理者, 而不是擁有者

int[] a = new int[10];
int[] b = a;
b[0] = 5;

// 此時(shí) a[0] 也變成了 5
// a == b 的結(jié)果是 true

復(fù)制數(shù)組, 不能用 b = a, 而需要遍歷, 除此以外還有 a.clone() 和 System.arraycopy(src, int srcPos, dst, int dstPos, int length) 方法

int[] a = {1, 2, 3, 4};
// 方法1, a.clone()
int[] b = a.clone();

int[] c = new int[4];
// 方法2, System.arraycopy()
System.arraycopy(a, 0, c, 0, a.length);

每個(gè)數(shù)組, 都有一個(gè) .length 屬性, 比 C 安全

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

// 也可以這樣遍歷, 因?yàn)閿?shù)組是個(gè) Iterable 對(duì)象
for( int n : a ) {  }

二維數(shù)組

int[][] a = new int[3][5];
for( int i = 0; i < a.length; i++ ) {
    for( int j = 0; j < a[0].length; j++ ) {
        a[i][j] = i * 5 + j; 
    }
}

// 初始化
int[][] a = {
    {1, 2, 3, 4},
    {1, 2, 3},
}

// 注意最后可以多一個(gè)逗號(hào)

字符類型 char, 能被單引號(hào)包圍, 如 "a", "+", "你", unicode16編碼, 2個(gè)字節(jié), 在所有機(jī)器上是一致和統(tǒng)一的

字符串, String, 第一個(gè)字母大寫, 說明是一個(gè)類, 是管理者

String s1 = new String("123");
String s2 = "abc";

// 自動(dòng)轉(zhuǎn)換
String s3 = s1 + s2 + 12 + 24;    // "123abc1224"
String s4 = s1 + s2 + (12 + 24);  // "123abc36"

// 注意
String s5 = null;
System.out.println( s5 + "a" ); // nulla

讀取輸入

next --- 相當(dāng)于 C++ 中的 cin
nextLine --- 相當(dāng)于 C++ 中的 getline

字符串的操作. 字符串是對(duì)象, 對(duì)它的所有操作都要通過 . 這個(gè)運(yùn)算符

長度, s.length()

注意要加括號(hào) () , 是字符串的 length() 方法, 和數(shù)組的 length 屬性不一樣

而且在調(diào)用 .length() 時(shí), s 必須指向一塊字符串, 不能是未初始化區(qū)域(null)

訪問字符, s.charAt(index), 注意這是只讀操作, read-only

遍歷, 注意字符串無法使用 for(char ch : s), 因?yàn)樽址皇?Iterable 對(duì)象

for( int i = 0; i < s.length(); i++ ){
    s.charAt(i);
}

子串, .substring()

// [n:-1]
s.substring(n);
// [n, n + len)
s.substring(n, len);

內(nèi)容是否相同 .equals()

if( s.equals("Hello") ) {  }

比較大小, .compareTo(), unicode 編碼相減

s1.compareTo(s2);        // unicode 編碼相減

其他操作

int loc = s.indexOf("a");
s.indexOf("a", loc + 1);
s.indexOf("abc");

s.lastIndexOf("a");

s.startsWith(ch);
s.endsWith(ch);
s.trim();            // 去掉兩端空格
s.replace(c1, c2);
s.toLowerCase();
s.toUpperCase();

注意, 字符串本身是不可變的. 以上操作如果返回了字符串, 那這些返回的字符串是新生成的, 而不是修改了原來的字符串.

基本數(shù)據(jù)類型對(duì)應(yīng)的包裹類型

boolean --- Boolean
byte --- Byte
short --- Short
char --- Character
int --- Integer
long --- Long
float --- Float
double --- Double

基本數(shù)據(jù)類型 + 更多方法和字段

int a = Integer.MAX_VALUE;        // 2^31 - 1
boolean b = Character.isDigit("a");    // false
char c = Character.toLowerCase("A");    // a

數(shù)學(xué)類, Math

Math.abs()
Math.round()
Math.random()
Math.pow()

實(shí)參類型的寬度(尺寸大小)必須 <= 形參類型的寬度(大小)

比如形參 double 實(shí)參 int 是可以的, 但是反過來就不行

true 和 int 無法轉(zhuǎn)換

方法的每一次運(yùn)行, 都會(huì)產(chǎn)生獨(dú)立的本地變量空間, 參數(shù)也是本地變量

由于沒有 C 的指針, 也沒有 C++ 的引用 &, 所以一般方法無法實(shí)現(xiàn) swap, 需要使用數(shù)組或者對(duì)象

類名首字母大寫. 其余的, 首字母小寫

少用下劃線

隨寫隨用，而不是上方統(tǒng)一聲明、分開使用

訪問控制修飾符

其他修飾符

static

不屬于某個(gè)實(shí)例, 而是屬于整個(gè)類的(屬性). static 變量, 相當(dāng)于該類一個(gè)全局變量, 有點(diǎn)像 C 中的 extern 全局變量, 是所有該類的對(duì)象實(shí)例所共享的. 這樣看來, Java 的類是一個(gè)樹的結(jié)構(gòu), 根結(jié)點(diǎn)中存儲(chǔ)著公有信息, 而對(duì)象實(shí)例是衍生出來的子結(jié)點(diǎn). 也就是說, static 是一個(gè)公共的路燈, 只有一盞, 每個(gè)人可以去開關(guān)路燈. 但是如果你要去關(guān)掉某一戶人家里的燈, 就要明確指明他家的門牌號(hào)

類就相當(dāng)于計(jì)網(wǎng)中的協(xié)議, 比如網(wǎng)絡(luò)層協(xié)議, 規(guī)定了每個(gè)數(shù)據(jù)包應(yīng)該有什么樣的格式. 而對(duì)象則是一個(gè)個(gè)具體的實(shí)際的數(shù)據(jù)包.

類變量, 相當(dāng)于協(xié)議頭部的一個(gè)字段, 所有這個(gè)類的對(duì)象實(shí)例都有相同的頭部信息. 相對(duì)的, 成員變量則是數(shù)據(jù)部分.

static 變量多帶帶劃分一塊存儲(chǔ)空間, 不與具體的對(duì)象綁定在一起, 該存儲(chǔ)空間被類的各個(gè)對(duì)象所共享.

static 變量值在方法區(qū)加載一次, 而 非 static 變量在創(chuàng)建對(duì)象時(shí)會(huì)加載很多次, 每次創(chuàng)建都會(huì)拷貝一份

static 方法再內(nèi)存中有專用的代碼段

static 的訪問

static 方法可以訪問 static 變量 (類變量)

static 方法不能訪問無 static 前綴的 普通成員變量, 不能訪問實(shí)例變量, 也就是不能使用 this 或 super, 調(diào)用類方法時(shí), 可以通過 `類名.

普通成員函數(shù) 可以訪問 static 變量

可以通過 類名.類變量 訪問類變量, 也可以通過 對(duì)象名.類變量 訪問類變量. 同理, 調(diào)用類方法時(shí)可以用 類名.類方法, 也可以用 類名.類方法

class A{
    static int var = 1;
    public static void main(String args[]){
        A.var++;            // OK, 類名.類變量
        A a = new A();
        a.var++;            // OK, 對(duì)象名.類變量
        var++;                // OK, 直接訪問
    }
}

final, 不可改變的, 最終的

類前面加上 final, 表示這個(gè)類不能被繼承, 有利于 Java 的優(yōu)化

方法前面加上 final, 則這個(gè)方法不能被子類覆蓋 Override

字段前面加上 final, 能且只能被賦值一次, 然后就不能被改變了. 通常用 static final 表示常量

類 = 字段(成員變量) + 方法(成員函數(shù))

成員變量的生存期 ---> 該對(duì)象的生存期, new 開始, GC 收集

成員變量的作用域 ---> 類的內(nèi)部

構(gòu)造方法, 構(gòu)造函數(shù), new 一個(gè)新的對(duì)象會(huì)調(diào)用構(gòu)造方法, 可以重載 overload (參數(shù)表不同)

初始化順序

1.new
2.先跳到構(gòu)造函數(shù)(但不進(jìn)入)
3.調(diào)到父類的構(gòu)造函數(shù)(如果有父類)
4.重復(fù)3, 一直到最高的父類
5.跳到構(gòu)造函數(shù)外面的 定義初始化
    int price = 80, balance = 0;
6.進(jìn)入構(gòu)造函數(shù), 完成構(gòu)造函數(shù)里面的語句
7.回到子類, 進(jìn)行子類的定義初始化, 再完成子類的構(gòu)造函數(shù)
8.把構(gòu)造出來的對(duì)象交給對(duì)象實(shí)例 vm 管理

如果有構(gòu)造方法的重載, 而且如果其中一個(gè)要調(diào)用另一個(gè)構(gòu)造方法, 那么要借助 this

class Person{
    private int age, id;
    public Person(){
        this(1);// 必須放在最開始, 調(diào)用另外一個(gè)構(gòu)造方法
        age = 0;
    }
    public Person(int pid){
        id = pid;
    }
}

析構(gòu)函數(shù)使用的是 finalize() 方法, 但是一般不用去定義, 交給 JVM 就好了

對(duì)象是實(shí)體, 可以像理解 C++ 的指針一樣理解對(duì)象實(shí)例

必須 new, 才會(huì)分配具體的空間, 每個(gè)對(duì)象的 id 不同

如果是用另一個(gè)對(duì)象對(duì)其賦值, 則相當(dāng)于兩個(gè)人管理同一個(gè)對(duì)象實(shí)例, 和指針一樣

Student s1 = new Student();
Student s2 = s1;
s1.setAge(5);   // 5
s1.getAge();    // 5
s2.setAge(10);  // s2 更新 age
s1.getAge();    // 10, s1也會(huì)修改, 因?yàn)閮烧咧赶蛲粔K區(qū)域

安全性

一個(gè)對(duì)象實(shí)例是內(nèi)存中的一塊區(qū)域, 只能通過同類型的引用去訪問, 不能隨便拿一個(gè)指針亂指到一個(gè)實(shí)例(內(nèi)存區(qū)域)

private

是對(duì)類的限制, 而不是對(duì)對(duì)象的限制

同一個(gè)類的內(nèi)部, 該類的不同對(duì)象實(shí)例之間, 可以互相訪問private.

但是出了這個(gè)類，就無法訪問private了。舉例如下

class Lower{
    private int val = 0;

    public void test(){
        Lower a = new Lower();
        Lower b = new Lower();
        // 類的內(nèi)部, 該類的不同對(duì)象實(shí)例之間, 可以互相訪問private
        a.val = b.val;
    }
}

class Higher{
    public void test2(){
        Lower l1 = new Lower();
        Lower l2 = new Lower();
        // error, not visible. 超出了Lower類的內(nèi)部, private字段就變成了不可見
        l1.val = l2.val;
    }
}

private 方法和字段不能繼承

public

default (friendly)

既沒有前綴 public, 也沒有前綴 private, 那么這個(gè)成員是 default

那么和它位于同一個(gè)包(同一個(gè)文件夾)的其他類可以訪問.

注意, 不需要顯式聲明為 default

protected

同一包內(nèi)的類可見

所有子類可見

繼承關(guān)系

父類 public, 子類也必須為 public

父類 protected, 子類 protected, public, private

父類 private 不能夠被繼承

方法重載: 多個(gè)方法有著相同的名字, 這些方法的簽名 signature 不同 (參數(shù)不同, 或者參數(shù)類型不同), 編譯的時(shí)候能夠被識(shí)別出來

通過方法重載, 可以實(shí)現(xiàn)多態(tài)

模塊化, 把相關(guān)的屬性和方法封裝成為一個(gè)類

信息隱蔽, 隱藏類的細(xì)節(jié)(private), 用戶只能通過受保護(hù)的接口訪問某個(gè)類

class Person{
    private int age;
    public int getAge(){
        return age;
    }
}

父類(super)和子類(sub, 也作派生類)之間如果有共同的屬性和方法, 就不用再寫第二遍了?？梢愿玫爻橄蠛头诸? 提高代碼的可重用性, 提高可維護(hù)性

單繼承, 一個(gè)類只能有一個(gè)直接父類, 子類自動(dòng)繼承父類的狀態(tài)和行為

繼承的例子 (extends)

class Person{
    int age;
    String name;
}

// 注意關(guān)鍵字 extends 表示繼承(擴(kuò)展)
class Student extends Person{
    String school;
}

// 如果沒有 extends xxx, 那么默認(rèn)為 extends java.lang.Object 的子類
// 因此所有的類都是直接或間接地繼承了 Object

覆蓋

JDK 1.5 之后引入了 @Override, 表示覆蓋 (修改) 了父類的方法.

可以當(dāng)做注釋, 同時(shí)編譯器會(huì)幫你檢查, 如果父類中沒有相同的 方法名 + 參數(shù)表, 就會(huì)報(bào)錯(cuò)

父類方法 func() 被覆蓋后, 仍然可以用 super.func() 調(diào)用父類的方法

重載

方法名相同, 參數(shù)表不同. 重載是新的方法.

構(gòu)造方法是不能繼承的, 因?yàn)闃?gòu)造方法是和類名同名的

子類構(gòu)造的過程中需要用 super 來調(diào)用父類的構(gòu)造方法

例題, 問以下代碼的結(jié)果是什么

class Person {
    String name = "";
    public Person(String n) {
        name = n;
    }
}
class Employee extends Person {
    String empID = "";
    public Employee(String id) {
        empID = id;
    }
}
public class Test {
    public static void main(String args[]) {
        Employee e = new Employee("123");
        System.out.println(e.empID);
    }
}

結(jié)果是編譯報(bào)錯(cuò), 因?yàn)楦割?Person 沒有無參數(shù)的構(gòu)造函數(shù), 解決方法

// 方法1, 給父類 Person 增加無參數(shù)的構(gòu)造函數(shù)(子類會(huì)默認(rèn)調(diào)用)
class Person {
    public Person() {}
}

// 方法2, 子類構(gòu)造函數(shù)中用 super 顯式調(diào)用父類已有的構(gòu)造函數(shù)
class Employee extends Person {
    public Employee(String id) {
        super("Bob");// 注意 super 必須放在第一句
        empID = id;
    }
}

子類對(duì)象和父類對(duì)象的轉(zhuǎn)換

Student 是一個(gè) Person (子類對(duì)象可以被視為父類對(duì)象)

Person 不一定是 Student, 具體情況看下面的例子

// 假設(shè) Student extends Person
Person p1 = new Student(); // 編譯正常, 運(yùn)行正常
Student s1 = (Student) p1; // 編譯正常, 運(yùn)行正常

Person p2 = new Person();
Student s2 = (Student) p2;
s2.xxx(); // 【編譯正常, 運(yùn)行錯(cuò)誤】

與類的繼承沒有關(guān)系, 子類和父類可以位于不同的包中

相當(dāng)于名字空間, 解決同名沖突. 同時(shí)包也相同于文件夾(存儲(chǔ)路徑)

另外就是可訪問性, 同一個(gè)包中的各個(gè)類, 默認(rèn)是可以互相訪問的

abstract, 抽象

abstract class Person{
    // 含有抽象方法的類必須聲明為抽象類
    // 注意抽象方法是分號(hào);結(jié)尾, 而不是花括號(hào)
    // 也就是說抽象方法只有聲明, 沒有實(shí)現(xiàn)
    abstract void speak();

    void eat() {
        // 抽象類可以有非抽象方法
    }
}

class Student extends Person{
    @Override
    void speak() {
        // 子類 extends 父類后
        // 要么仍然保持 abstract 方法
        // 要么 Override 覆蓋(這里也可以稱為實(shí)現(xiàn))父類的 abstract 方法
    }
}

public class Main{
    public static void main(String args[]) {
        // 錯(cuò)誤, 抽象類不能被實(shí)例化 `instantiate`
        // Person p1 = new Person();

        // 但是抽象類可以用于定義變量
        Person p2 = new Student();
    }
}

interface, 接口, 約定某種特征

interface 是純抽象類, 所有方法都是 abstract, 也就是 C++ 中的純虛類

所有的成員變量都是 public static final (相當(dāng)于 const 常量)

static 表明它屬于這個(gè)類而不是某個(gè)具體對(duì)象, final 表明它一旦初始化就不會(huì)被改變, 是一個(gè)編譯時(shí)刻已經(jīng)確定的常量

// 注意直接用 interface 修飾, 不需要 class
interface Flyable{
    // 接口類的所有方法都是 `public abstract`, 不需要顯式寫出
    // public abstract void fly();

    void fly();
}

interface Runnable{
    // 如果使用 static 修飾符, 則表明這是默認(rèn)實(shí)現(xiàn), 不需要每次 implements 都去實(shí)現(xiàn) run
    // java8 以上的新特性, 但是這就又回到父子繼承了
    static void run() {
    }
}

// implements 多個(gè)接口用逗號(hào)分隔
class Superman extends Person implements Flyable, Runnable{
    @Override
    public void fly() {
    }
}

class Airplane implements Flyable{
    @Override
    public void fly() {
    }
}

接口可以繼承接口，但是不能繼承(extends)類

接口不能實(shí)現(xiàn)接口，只有類能夠?qū)崿F(xiàn)(implements)接口. 一個(gè)類可以實(shí)現(xiàn)(implements)多個(gè)接口(多繼承), 也就是說, 通過接口可以實(shí)現(xiàn)不相關(guān)類的相同行為(fly()), 而不需要考慮層次關(guān)系(``)

引用類型一共有三大類: 1.類 class, 2.接口 interface, 3.數(shù)組

相同的名字表示不同的含義

case1, 編譯時(shí)多態(tài), 靜態(tài)

重載 Overload, 多個(gè)方法同名但參數(shù)表不同

p.say();
p.say("Hi");

case2, 運(yùn)行時(shí)多態(tài), 動(dòng)態(tài)

覆蓋 Override, 子類方法覆蓋父類同名方法. 動(dòng)態(tài)綁定 dynamic binding, 也稱為虛方法調(diào)用, 運(yùn)行的時(shí)候根據(jù)實(shí)例對(duì)象來調(diào)用方法, 舉例如下

class Person{
    void say(){
        System.out.println("hi");
    }
}

class Student extends Person{
    @Override
    void say(){
        System.out.println("hi, I"m a student");
    }
}

public class Main{
    static void func(Person p){
        p.say();
    }

    public static void main(String args[]) {
        Person p = new Person();
        Student s = new Student();
        Person ps = new Student();
        // func() 的參數(shù)表說明了我們需要一個(gè) Person 對(duì)象
        func(p);
        // 但是我們也可以把 Student 傳進(jìn)去
        // 這時(shí)候不會(huì)報(bào)錯(cuò), 而且會(huì)正確調(diào)用子類的 say()
        func(s);
        // 更進(jìn)一步, 如果我們用向上造型, func() 能接受 ps, 且會(huì)正確調(diào)用子類的 say()
        func(ps);
    }
}

可以被 Override 的方法都可以稱作虛方法, 虛方法不需要特殊的聲明

非 static、final、private 修飾的所有方法都是虛方法

向上造型 upcasting

父類 obj = new 子類();

子類的對(duì)象, 可以被當(dāng)成父類的對(duì)象來使用, 可以賦值給父類的變量, 可以傳遞給需要父類對(duì)象的函數(shù), 如果一個(gè)容器存放的是父類對(duì)象, 那么子類對(duì)象也可以放進(jìn)去

// 為什么? 因?yàn)槔^承了父類, 對(duì)外的接口是一樣的

子類的對(duì)象可以賦值給父類的變量. 注意, Java 不存在 對(duì)象 對(duì) 對(duì)象 的賦值, 而是讓兩個(gè)管理員共同管理一個(gè)對(duì)象. 類比指針, 不是復(fù)制內(nèi)容, 而是給地址.

有哪些類, 類里面有什么屬性和方法, 類之間的關(guān)系(繼承, 關(guān)聯(lián)), 對(duì)象之間發(fā)送消息(調(diào)用方法)

容器 container, 是放東西的東西, 數(shù)組可以看做一種容器, 但是數(shù)組的長度一旦確定就無法改變, 而容器一般可以改變其容量

基本數(shù)據(jù)類型數(shù)組 與 對(duì)象數(shù)組

// 基本數(shù)據(jù)類型數(shù)組, 每一個(gè)元素都是基本數(shù)據(jù)類型
int[] ai = new int[32]; // 每個(gè)元素被初始化為0

// String[] 數(shù)組, 對(duì)象數(shù)組, 每一個(gè)元素只是一個(gè)管理者, 一個(gè)指針, 而不是保存實(shí)際內(nèi)容
// 元素初始化為 null, 實(shí)際內(nèi)容還不存在, 需要 for 循環(huán)去創(chuàng)建和賦值(指向)
String[] as = new String[10];

容器類

// import java.util.ArrayList;
ArrayList noteList = new ArrayList();

// 用法參考 https://www.w3schools.com/java/java_arraylist.asp
noteList.add( Integer.toString(0) );
noteList.add( "1" );
noteList.get(0);
noteList.set(0, "00");

// import java.util.Collections;
// 排序
Collections.sort(noteList);

noteList.remove(0);
noteList.clear();

// 如果要構(gòu)建一個(gè)數(shù)組, 可以調(diào)用 toArray() 方法
int size = noteList.size();
String[] mylist = new String[size];
noteList.toArray(mylist);

關(guān)系圖

去重

HashSet s = new HashSet();
s.add("first");
s.add("second");
s.add("first");
sysout(s); // [first, second]
s.contains("1"); // false

參考文檔

https://docs.oracle.com/javas...

https://www.tutorialspoint.co...

鍵值映射關(guān)系

/*
映射關(guān)系
1        penny
5        nickel
10        dime
25        quarter
50        half-dollar
*/
HashMap dollarMap = new HashMap();
dollarMap.put(1, "penny"); // 注意其他容器都是 add, map 是 put
dollarMap.put(5, "nickel");
dollarMap.put(10, "dime");
dollarMap.put(25, "quarter");
dollarMap.put(50, "half");
dollarMap.replace(50, "half-dollar");
dollarMap.containsKey(30); // false
dollarMap.get(30); // null
dollarMap.get(50);