【Java筆記】（一）：Java基礎

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

函數與類前面的修飾符示例

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

控制結構示例

包含的内容有：for循環、while循環、switch語句，if語句

public static void main(String[] args) {
    int a=0;
    for (int i = 0; i <10 ; i++) {
        a+=1;
    }
    while (a>0){
        if(a%2==0){
            System.out.println(a+"是偶數");
        }
        else{
            System.out.println(a+"是奇數");
        }
        a-=1;
    }
    switch(a){
        case 0:
            System.out.println("a是"+0);
            break;
        case 1:
            System.out.println("a是"+1);
            break;
    }
}
           

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

主資料類型與引用

primitive主資料類型+引用=變量

primitive的八種主資料類型

類型	位數	值域
boolean	JVM決定	true或false
char	16 bits	0~65535
byte	8 bits	-128~127
short	16 bits	-32768~32767
int	32 bits	±2147483648
long	64 bits	- 很大 ~ + 很大
float	32 bits	範圍規模可變
double	64 bits	範圍規模可變

注意，整數預設為int類型，小數預設為double類型，在建立其他類型變量以及運算時要标明。

當大杯轉小杯時可能會導緻資料溢出，是以要注意資料的範圍，以此來選擇資料類型。

當編譯器無法識别能否進行資料轉化時，需要進行強制轉換。

public class test {
    public static void main(String[] args) {
        long a=123;
        //int b=a;會報錯，編譯不通過
        int b=(int) a;
        System.out.println(a);
    }
}
           

自動強制轉換的規則：

引用reference

如果一個變量是類類型，而非基本類型，那麼該變量又叫引用。

可以把執行個體化的對象的reference當做一個遙控器，遠端遙控其他的行為。

當執行個體化一個對象的時候，會建立一個遙控器，遙控器在棧區，對象在堆區。

Book b=new Book();//new Book();隻是建立一個對象，前面的b表示引用指向他，等号表示指向
Book c=new Book();
Book d=c;//這時候c和d兩個遙控器遙控一個對象
c=b;//這時候c和b遙控同一個對象，但是d仍然遙控自己的那個對象
           

作用域

• 聲明在類的外面，變量就叫做字段 或者屬性、成員變量、Field ，其作用域就是從其聲明的位置開始的整個類
• 變量是參數：作用域在方法中
• 方法的局部變量：在方法中建立的變量作用域在方法内部

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

運算符

邏輯運算符

運算符	描述
&&	與
||	或
！=	不等于
！	非

• 短運算符

  比如&&，當兩端都為真才得到真，當左邊為假便不會再計算右邊

• 長運算符

  比如&，強制虛拟機必須做兩端的操作

算數運算符

符号	描述
+	加
-	減
*	乘
/	除
%	取餘
++	自增
–	自減

關系操作符

符号	描述
>	大于
>=	大于或等于
<	小于
<=	小于或等于
==	是否相等
!=	不等于

位運算符

參見ACM——位運算符整理

用的不多，用來提高運算速度，可以忽略不學。

指派運算符

符号	描述
+=	a=a+x
-=	a=a-x
*=	a=a*x
/=	a=a/x
%=	a=a%x
&=	a=a&x
|=	a=a|x
^=	a=a^x
>>=	a=a>>x
<<=	a=a<<x

三元操作符

(判斷)？A：B；

當判斷的内容為真時傳回A，否則傳回B

int k = i < j ? 99 : 88;
           

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

數組

建立與初始化數組

數組是一個固定長度，包含相同類型資料的容器，具有預設值

public class demo extends test{
    public static void main(String[] args) {
        int []a=new int[5];//或者是寫int a[]=new int[5];
        int []b = new int[]{100,102,444,836,3236};
        a[0]=15;
        System.out.println(a[0]);
        System.out.println(a.length);
    }
}
           

複制數組與合并數組

或者使用Arrays類的方法，或者是

複制數組： System.arraycopy(src, srcPos, dest, destPos, length)

• src: 源數組
• srcPos: 從源數組複制資料的起始位置
• dest: 目标數組
• destPos: 複制到目标數組的起始位置
• length: 複制的長度

public static void main(String[] args) {
    int a [] = new int[]{18,62,68,82,65,9};
    int b[] = new int[3];//配置設定了長度是3的空間，但是沒有指派
    //通過數組指派把，a數組的前3位指派到b數組
    System.arraycopy(a, 0, b, 0, 3);
    //把内容列印出來
    for (int i:b) {
        System.out.print(b[i] + " ");
    }
}
           

初始化二維數組與不規則長度數組

public static void main(String[] args) {
    //初始化二維數組，
    int[][] a = new int[2][3]; //有兩個一維數組，每個一維數組的長度是3
    a[1][2] = 5;  //可以直接通路一維數組，因為已經配置設定了空間
    //隻配置設定了二維數組
    int[][] b = new int[2][]; //有兩個一維數組，每個一維數組的長度暫未配置設定
    b[0]  =new int[3]; //必須事先配置設定長度，才可以通路
    b[0][2] = 5;
    //指定内容的同時，配置設定空間
    int[][] c = new int[][]{{1,2,4}, {4,5}, {6,7,8,9}};
}
           

增強for循環

格式：可以通過

values.for

快捷鍵實作

for (int each : values) {
    System.out.println(each);//do something
}
           

Arrays類的常用方法

包：import java.util.Arrays;

常用方法：

方法	描述	作用
int[] b = Arrays.copyOfRange(a, 0, 3);	a是原數組，0取的到，3取不到	數組複制
String content = Arrays.toString(a);	a是數組，得到[18, 62, 68, 82, 65, 9]	轉換為字元串
Arrays.sort(a);	a是數組	升序排序
Arrays.binarySearch(a, 62 )：	62是要搜尋的元素	搜尋，前提是升序排列了，不存在傳回負數
Arrays.equals(a, b)	ab為兩個數組	判斷兩個數組是否相同
Arrays.fill(a, 5 );	填充a數組全為5	填充(初始化)

建立類的數組

Dog[] myDogs=new Dog[3];
myDogs[0]=new Dog();//放咖啡的杯子就隻能放咖啡
myDogs[0].name="Fido";
myDogs[0].bark();
           

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

初識類與對象——基本概念

封裝資料

在建立資料時，标明private，否則執行個體化的對象可以直接修改對應的值，把内褲給别人看了就挺尴尬的…

可以建立對應的方法來擷取或者設定相應資料，比如

public void setname(String newname){
	name=newname+getname();
}
           

執行個體變量的預設值

當你僅僅隻是聲明一個變量，但是不初始化的時候，java會預設給你賦一個值

資料類型	預設值
integers
floating points	0.0
boolean	false
references	null

執行個體變量與局部變量的差别

執行個體變量是聲明在類裡面的，局部變量是聲明在類的方法裡的，局部變量在使用前必須要先指派，否則編譯器會報錯。

可變長參數

在參數位置加三個點，例如

public void attack(Hero ... heros){
    for (Hero:heros) {
        //do something
    }
}
//傳參時參數用逗号隔開
           

構造函數

聲明為public，構造函數可以重載哦，注意别寫void ，否則就成了普通方法

class demo {
    public demo(String a){
        System.out.println("調用了構造函數參數是"+a);
    }
    public demo(){
        System.out.println("調用了預設構造");
    }
    public static void main(String[] args) {
        demo test1=new demo("草");
        demo test2=new demo();
    }
}
           

this關鍵字

指向目前類本身的元素，類似c++，即使是同名的，

this.name=name;

也可以指派，稱為隐式調用。

但是隻要和屬性不同名，直接指派也OK的，this還能實作

構造方法

的

互相調用

一個包(package)内的class可以互相通路

要通路别的class用import導入哦，import package.class

成員變量四種權限修飾符

标黃了就表示不能通路到，不寫預設為

protected

自身	同包子類	不同包子類	同包類	其他類
private	通路	繼承	繼承	通路	通路
protected	通路	繼承	繼承	通路	通路
public	通路	繼承	繼承	通路	通路
package	通路	繼承	繼承	通路	通路

屬性初始化

對象屬性初始化有3種

• 聲明該屬性的時候初始化 public String name =

  "some hero"

  ;
• 構造方法中初始化
• 使用set方法
• 初始化塊===>大括号括起來，不常用，别幾把了解了

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

類的封裝

封裝概述

封裝是面向對象三大特征之一(封裝、繼承、多态)，是面向對象程式設計語言對客觀世界的模拟，客觀世界裡成員變量都是隐藏在對象内部的，外界是無法直接操作的

封裝原則

将類的某些資訊隐藏在類的内部，不允許外部程式直接通路，而是通過該類提供的方法來實作對隐藏資訊的操作與通路，成員變量設定為

private

，提供對應的

getAbb

和

setAbb

方法

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

類的繼承

子類繼承父類可以獲得父類的屬性和方法，一個父類可以被多個子類繼承，但是一個子類隻能繼承一個父類，不過一個類可以實作多個接口，Object類是所有類的父類，類的繼承關鍵字是

extents

繼承中變量通路順序

在子類方法中尋找一個變量時如下順序：

• 子類局部範圍找
• 子類成員範圍找
• 父類成員範圍找
• 如果都沒有就報錯(不考慮父親的父親)

繼承中構造方法的通路順序

子類中的所有構造方法都會預設

先通路父類的無參構造方法

，子類會繼承父類的資料，是以在子類初始化前一定要先進行父類初始化，每一個子類第一句話預設都是

super()

繼承中成員方法的通路順序

順序如下：先目前再長遠

• 子類成員範圍找
• 父類成員範圍找
• 如果都沒有就報錯(不考慮父親的父親)

super關鍵字

• 調用父類帶參構造方法

執行個體化子類的時候，會先調用父類的構造方法，當多個構造方法時，預設調用父類無參構造方法

如果想調用父類帶參構造，需要用super，例如

• 調用父類屬性

• 調用父類的方法

this與supper的差別

this是通路或調用本類的成員變量或方法，supper是操作父類的

類的初始化順序

靜态變量與靜态初始塊隻會初始化一次，但是類成員變量在每次初始化都會進行初始化，而且是先進行成員變量的初始化再調用構造函數

父類靜态變量 > 父類靜态初始塊 > 子類靜态變量 > 子類靜态初始塊 > 父類成員變量 > 父類非靜态初始塊 > 父類構造器 > 子類成員變量 > 子類非靜态初始塊 > 子類構造器

方法(重寫)覆寫

當子類需要父類的功能，而功能主題子類有自己特有内容時，可以重寫父類的方法，這樣既沿襲了父類的功能，又定義了子類獨有的内容。如果在子類中定義一個方法，其名稱、傳回類型及參數簽名正好與父類中某個方法的名稱、傳回類型及參數簽名相比對，就說子類的方法覆寫了父類的方法。簡單來說，子類的方法和父類

一模一樣

就說覆寫，注解是

@Override

四個特點：

• 有繼承關系的兩個類
• 具有相同方法名、傳回值類型、形式參數清單
• 子類通路權限不能更低
• 抛出異常不能更多

四個注意事項：（多态文法）

• 方法覆寫隻是針對于方法，和屬性無關。
• 私有方法無法覆寫
• 構造方法不能被繼承，是以構造方法也不能被覆寫。
• 方法覆寫隻是針對于“執行個體方法”，“靜态方法覆寫”沒有意義

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

類的多态

多态是同一對象在不同時刻表現出來的不同形态

多态的形式：

• 具體類多态
• 抽象類多态
• 接口多态

多态的前提和展現：

• 有繼承/實作關系
• 有方法重寫
• 有父類(接口)引用指向子(實作)類對象

操作符的多态：

• 加号兩邊都是數字代表數字相加
• 加号兩邊有一個字元串則表示字元串拼接

類的多态：

• 子類父類轉型

/**
LifePotion（血瓶）和MagicPotion（魔瓶）都繼承于Item，當使用effect方法時隻需要傳入Item對象即可，
不用再寫useLifePotion和useMagicPotion兩個方法
*/
public class Hero {
    public String name;
    protected float hp;
    
    public void useItem(Item i){
        i.effect();
    }
    
    public static void main(String[] args) {
        Hero garen =  new Hero();
        garen.name = "蓋倫";
     
        LifePotion lp =new LifePotion();
        MagicPotion mp =new MagicPotion();
         
        garen.useItem(lp);
        garen.useItem(mp);
    }    
}
           

多态的好處與弊端

多态的優點：

• 提高了程式的擴充性

多态的弊端：

• 不能使用子類的特有功能

多态中轉型

instanceof判斷引用是否指向對象

子類轉父類，向上：ADHero引用轉Hero引用是完全沒問題的

父類轉子類，向下：需要用到子類的類名進行強制轉化，為什麼要加呢，因為不知道子類的引用指向的對象是誰，

注：父類轉子類之後再轉子類可能會報錯

多态轉換的順序

https://www.bilibili.com/video/BV18J411W7cE?p=173

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

抽象類(abstruct)

介紹

隻對方法進行聲明，而不去實作，在java中，一個沒有方法體的方法稱為抽象方法，如果類中有抽象方法，該類必須定義為抽象類

抽象類以及子類的特點

• 抽象類和抽象方法必須使用

  abstruct

  進行修飾
• 抽象類中不一定有抽象方法，有抽象方法的類一定是抽象類
• 抽象類不能執行個體化，但是可以通過子類對象執行個體化，這叫抽象類的多态
• 抽象類的子類要麼重寫抽象類中所有的抽象方法，要麼是抽象類
• 抽象是多态的表現形式之一

抽象類的成員特點

• 抽象類不能被執行個體化
• 成員變量既可以是變量也可以是常量(final)
• 構造方法可以有，作用是子類通路父類進行資料的初始化
• 成員方法可以是抽象的也可以是非抽象的，非抽象的方法提高了代碼的複用性
• 構造方法，類方法（用 static 修飾的方法）不能聲明為抽象方法

抽象類名作為形參和傳回值

• 方法形參是抽象類名時，其實需要的是

  該抽象類的子類對象

• 方法傳回值是抽象類名時，其實傳回的時

  該抽象類的子類對象

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

接口(interface)

介紹

接口就像一種公共規範，隻要符合規範标準，大家就可以通用。Java中的接口更多展現在

對行為的抽象

接口的特點

• 接口用

  interface

  修飾
• 類實作接口用

  implements

  表示
• 接口不能執行個體化
• 接口是多态的表現形式之一

接口的成員特點

• 成員變量隻能是常量，預設修飾符：

  public static final

• 接口沒有構造方法，因為接口更多的是展現在對行為的抽象

• 成員方法隻能是抽象方法

  ，預設修飾符：

  public abstruct

• JDK8之後接口都有了預設實作，可以在實作的類中直接調用

設計接口

接口就像約定，接口定義某些方法，交給某個類去實作，一個類可以實作多個接口 用逗号隔開就行

接口定義關鍵字：interface

public interface AD{
	public void physicAttack();
}
           

類去實作接口的關鍵字：implements

public class ADHero extends Hero implements AD{
	public void physicAttack(){
		System.out.println("發起進攻");
	}
}
           

注意，假如類不實作接口約定的方法，這個類會報錯。

類和接口的關系

• 類和類的關系：繼承關系，隻能是單繼承，但是可以多層繼承
• 類和接口的關系：實作關系，類去實作接口，可以單實作，也可以多實作
• 接口和接口的關系：繼承關系，可以單繼承也可以多繼承

注：可以繼承一個類時同時實作多個接口

抽象類與接口的差別

# 成員差別
	抽象類---->常量和變量，可以定義四種通路權限，有構造方法，有抽象方法，也有非抽象方法
	接口------>隻有公共的靜态的常量和抽象方法
# 關系差別
	抽象類---->隻能被單繼承
	接口------>可以被類多實作（被其他接口多繼承）
# 設計理念差別
	抽象類---->抽象類是對類抽象，是對根源的抽象，包括屬性和行為，抽象類反映的是is-a關系，表示這個對象是什麼
	接口------>主要是對行為動作的抽象，接口反映的是like-a關系，表示這個對象能做什麼，接口是更加純粹的抽象。
           

注：最大的相同點是

抽象類和接口都不能直接執行個體化

接口名作為形參和傳回值

• 方法的形參是接口名，其實需要的是

  該接口的實作類對象

• 方法的傳回值是接口名，其實需要的是

  該接口的實作類對象

預設方法（Java8）

例如我們想更新接口，但是如果更新的話所有的實作類都需要實作這個新方法，可以使用一個新接口繼承這個接口，然後找類去實作它，但是太麻煩了，于是有了預設實作方法

public interface Test{
	public default void show() {//public可以省略，但是default不行
        System.out.println("預設方法執行了,沖!");
    }
}
           

靜态方法（Java8）

靜态方法隻能被接口調用，這樣做的目的是防止實作多個接口的時候，這多個接口存在同一個靜态方法，導緻混亂

public interface Test{
	public static void show() {
        System.out.println("靜态方法執行了,沖!");
    }
}
           

public class TestInterface{
	public void main(String[] args) {
        Test.show();
    }
}
           

私有方法（Java9）

Java 9中新增了帶方法體的私有方法，這其實在Java8中就埋下了伏筆：Java8允許在接口中定義帶方法體的預設方法和靜态方法。這樣可能就會引發一個問題：當兩個預設方法或者靜态方法中包含一段相同的代碼實作時，程式必然考慮

将這段實作代碼抽取成一個共性方法

，而這個共性方法是不需要讓别人使用的，是以用私有給隐藏起來，這就是Java9增加私有方法的必然性

定義的格式：

• 格式一：

  private 傳回值類型 方法名(參數清單)

• 格式二：

  private static 傳回值類型 方法名(參數清單)

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

Java中的内部類

内部類介紹

内部類就是在類中定義一個類，例如在類A中定義了類B，這個類B就是内部類，

按照内部類在類中定義的位置不同，可以分為兩種形式：

• 在類的成員位置：成員内部類，定義在類中
• 在類的局部位置：局部位置類，定義在類方法中

内部類的定義格式如下：

public class ClassNameA{
    修飾符 class ClassNameB{
        
    }
}
           

内部類：java檔案的class裡面的類，屬性和方法平等的位置

内部類與外部類的通路特點

• 内部類可以直接通路外部類的所有屬性和方法
• 外部類如果想通路内部類成員必須先建立對象

成員内部類

如何通路内部類呢？

外部類名.内部類名 對象名 = 外部類名.内部類名

通常情況下，我們把類做成内部類的目的就是不讓别人通路到，是以通常是

将内部類修飾為private

，外部類定義一個方法去調用内部類的函數，我們隻需要調用外部對象的該方法即可

局部内部類

如果想調用局部内部類隻能是在方法中建立内部類對象，然後使用内部類對象去通路方法

public class Test {

    public int num = 10;
    
    public void method() {
        class Inner {
            public void show(){
                System.out.println(num);
            }
        }
        Inner inner = new Inner();
        inner.show();
    }
    
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}
           

非靜态内部類

通過

new 外部類().new 内部類()

的形式去使用

Hero garen = new Hero();
BattleScore score = garen.new BattleScore();
           

靜态内部類

static修飾，就不用再建立外部類

匿名内部類（是局部内部類一種）

前提是存在一個類，這個類可以是具體類也可以是抽象類，格式如下：

xxxx = new ClassNameOrInterfaceName(){
    //重寫方法
}
           

Hero是一個抽象類（abstruct），重寫方法表示繼承了這個類或實作了這個接口

Hero hero = new Hero(){
    //實作一個attack新方法
    public void attack() {
        System.out.println("新的進攻手段");
    }
};
hero.attack();
///--------也可以------//
new Hero(){
    //實作一個attack新方法
    public void attack() {
        System.out.println("新的進攻手段");
    }
}.attack();
           

匿名内部類的本質是繼承了該類或實作了該接口的匿名對象

内部類與匿名類不一樣的是，内部類必須聲明在成員的位置，即與屬性和方法平等的位置

本地類

本地類和匿名類一樣，直接聲明在代碼塊裡面，可以是主方法，for循環裡等等地方

public abstract class Hero {
    String name; //姓名
    float hp; //血量
    float armor; //護甲
    int moveSpeed; //移動速度
    public abstract void attack();
    
    public static void main(String[] args) {
        //與匿名類的差別在于，本地類有了自定義的類名
        class SomeHero extends Hero{
        	public void attack() {
                System.out.println( name+ " 新的進攻手段");
            }
        }
        SomeHero h  =new SomeHero();
        h.name ="地蔔師";
        h.attack();
    }
}
           

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

基本類型的包裝類

基本資料類型與包裝類對應關系

基本類型轉封裝類

//一個int類型資料
int i = 5;
//基本類型轉換成封裝類型
Integer it = new Integer(i);
           

封裝類轉基本類型

//一個封裝類型
Integer it = new Integer(5);
//封裝類型轉換成基本類型
int i2 = it.intValue();
           

自動裝箱

基本資料類型通過等号轉換為包裝類，稱為裝箱

int i = 5;
//自動裝箱為Integer類型
Integer it2 = i;
           

自動拆箱

包裝類通過等号轉為基本資料類型，稱為拆箱

Integer it = new Integer(5);
//自動拆箱為int基本資料類型
int i3 = it;
           

int的最大值最小值

//int的最大值
System.out.println(Integer.MAX_VALUE);
//int的最小值      
System.out.println(Integer.MIN_VALUE);
           

字元串與數值互相轉換

• 數字–>字元串（第二種方式不介紹了）

  String str = String.valueOf(5);
  //或者是String str = 5+"";
             

• 字元串–>數字

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

String類

格式化輸出

• %s 表示字元串
• %d 表示數字
• %n 表示換行

printf和format能夠達到一模一樣的效果，如何通過eclipse檢視java源代碼 可以看到，在printf中直接調用了format

String sentenceFormat ="%s 在進行了連續 %d 次擊殺後，獲得了 %s 的稱号%n";
System.out.printf(sentenceFormat,name,kill,title);
           

字元與Character工具類

char用來儲存一個字元，char對應的封裝類是Character

public class TestChar {
    public static void main(String[] args) {
         
        System.out.println(Character.isLetter('a'));//判斷是否為字母
        System.out.println(Character.isDigit('a')); //判斷是否為數字
        System.out.println(Character.isWhitespace(' ')); //是否是空白
        System.out.println(Character.isUpperCase('a')); //是否是大寫
        System.out.println(Character.isLowerCase('a')); //是否是小寫
         
        System.out.println(Character.toUpperCase('a')); //轉換為大寫
        System.out.println(Character.toLowerCase('A')); //轉換為小寫
 
        String a = 'a'; //不能夠直接把一個字元轉換成字元串
        String a2 = Character.toString('a'); //轉換為字元串
    }
}
           

字元串操作

charAt	擷取字元
toCharArray	擷取對應的字元數組
subString	截取子字元串
split	分隔
trim	去掉首尾空格
toLowerCase toUpperCase	大小寫
indexOf lastIndexOf contains	定位
replaceAll replaceFirst	替換
startsWith	以…開始
endsWith	以…結束
equals	判斷是否相等
equalsIgnoreCase	忽略大小寫判斷是否相等

StringBuffer

package character;
public class TestString {
    public static void main(String[] args) {
        String str1 = "let there ";
 
        StringBuffer sb = new StringBuffer(str1); //根據str1建立一個StringBuffer對象
        sb.append("be light"); //在最後追加
        System.out.println(sb);
         
        sb.delete(4, 10);//删除4-10之間的字元，都是閉區間
        System.out.println(sb);
         
        sb.insert(4, "there ");//在4這個位置插入 there
        System.out.println(sb);
         
        sb.reverse(); //反轉
        System.out.println(sb);
    }
}
           

StringBuffer與StringBuilder的差別是：StringBuilder是線程安全的

Random類

方法	描述
Random random = new Random(10);	10是seed，可以不寫
random.nextInt(10)	随機在最小int~最大int取一個數
random.nextInt(10)	[0,x)的随機整數，x不能小于0
nextFloat()	随機一個float
nextDouble()	随機一個Double
nextLong()	随機一個Long
nextBoolean()	随機true或false
nextBytes(byte[] bytes)	為一個byte類型的數組随機指派
nextGaussian()	随機生成一個高斯分布的浮點數

Math類

方法	描述
Math.abs()	取絕對值
Math.ceil()	向上取整
Math.floor()	向下取整
Math.round(float a)	四舍五入取整
Math.max(int a,int b)	去較大的值
Math.min(int a,int b)	去較小的值
Math.pow(double a,double b)	a的b次幂
Math.random()	傳回一個[0.0,1.0)之間的double值

System類

方法	描述
System.currentTimeMillis()	擷取系統目前毫秒值
System.exit(0);	結束正在運作的Java程式
System.gc();	垃圾回收器
System.getProperties()	确定目前的系統屬性
System.arraycopy(src, 2, dest, 0, 2);	複制數組

日期類

注意：是java.util.Date;

而非 java.sql.Date，此類是給資料庫通路的時候使用的

時間原點概念

零這個數字，就代表Java中的時間原點，其對應的日期是1970年1月1日 8點0分0秒 ，

為什麼對應1970年呢？ 因為1969年釋出了第一個 UNIX 版本：AT&T，綜合考慮，當時就把1970年當做了時間原點。

所有的日期，都是以為這個0點為基準，每過一毫秒，就+1。

建立日期對象

// 目前時間
Date d1 =  new Date();
System.out.println(d1);
// 從1970年1月1日 早上8點0分0秒 開始經曆的毫秒數
Date d2 = new Date(5000);
System.out.println(d2);
           

Date().gettime()擷取時間戳

傳回long型的時間戳，直接列印對象，會看到 “Tue Jan 05 09:51:48 CST 2016” 這樣的格式，可讀性比較差，可以進行日期格式化

注：

System.currentTimeMillis()

也可以達到gettime()的功能，而且更精确

日期的格式化

• y 代表年
• M 代表月
• d 代表日
• H 代表24進制的小時
• h 代表12進制的小時
• m 代表分鐘
• s 代表秒
• S 代表毫秒

package date;

import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDate {
    public static void main(String[] args) {
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );
        Date d= new Date();
        String str = sdf.format(d);
        System.out.println("目前時間通過 yyyy-MM-dd HH:mm:ss SSS 格式化後的輸出: "+str);
    }
}
           

月曆類

月曆類可以轉為日期類，還能翻月曆，别雞巴學了，感覺沒啥用啊

import java.util.Calendar;
import java.util.Date;
public class TestDate {
    public static void main(String[] args) {
        //采用單例模式擷取月曆對象Calendar.getInstance();
        Calendar c = Calendar.getInstance();
        //通過月曆對象得到日期對象
        Date d = c.getTime();
        Date d2 = new Date(0);
        c.setTime(d2); //把這個月曆，調成日期 : 1970.1.1 08:00:00
    }
}
           

幾個常見的關鍵字

static靜态屬性與靜态方法

所有的飲用都能通路，用static修飾，到時候直接用

類+原點操作符

就能直接調用

例如Math庫的Pi，math.pi

final(隻能操作一次)

• 修飾類。這個類不能夠被繼承
• 修飾方法。這個方法不能夠被重寫
• 修飾基本類型變量。該變量隻有一次指派機會
• 修飾引用。表示該引用隻有1次指向對象的機會
• 修飾常量。表示可以直接通路當不能修改的常量
• 如果是final修飾了引用，隻是不能修改位址而已，對象的屬性還是可以修改的

abstract(抽象)

• 在類中聲明一個方法，這個方法沒有實作體，是一個“空”方法 ，即抽象方法。
• 一個類有抽象方法，就必須聲明為抽象類。一個抽象類可以沒有抽象方法。
• 抽象類不能直接執行個體化，隻能通過子類來執行個體化
• 一個子類繼承了抽象類就必須重寫抽象方法，重寫的時候就不用寫abstract了

結語

預祝大家學習進步✔

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋

我愛你 帥帥龍

💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋💋