2.java基礎語法

java基礎語法

java註釋

註釋：程式在指定位置的說明性資訊，不參與程式的執行邏輯

當行註釋：//註釋資訊
多行註釋：/*註釋資訊*/
文件註釋：/**註釋資訊*/

/*
	java程式基本組成單位是類，
	類的定義格式
		public class 類名 {
			...
		}
*/
public class HelloWrold{
	pulic static void main(String[] args) {
        // 輸出語句
		System.out.println("hello world");
	}
}

java關鍵字

關鍵字：被java語言賦予了特定含義的單詞

關鍵字的字母全部小寫

常用編輯器對關鍵字，會有特殊顏色標記

java常量

常量：程式執行中，其值不可以發生改變的量

常量型別	說明	距離
字串常量	雙引號括起來的內容	"Hello world"
整數常量	不帶小數的數字	666
小數常量	帶小數的數字	13.14
字元常量	單引號括起來的內容	'A'
布林常量	布林值，表示真假	true, false
空常量	一個特殊的值，空值	null

public class ConstantDemo{
	public static void main(String[] args) {
		// 字元常量
		System.out.println("hello world");

		// 整數常量
		System.out.println("666");

		// 小數常量
		System.out.println("6.66");

		// 字元常量
		System.out.println('A');

		// 布林常量
		System.out.println(true);

		// 空常量, 不能直接列印
		// System.out.println(null);
	}
}

java資料型別

儲存單位：計算機儲存裝置最小心的單位：”位（bit）“，稱為”位元位“，通常用小寫字母”b“表示。而計算機中最小的儲存單位為”位元組（byte）“，通常大寫字母”B“表示，位元組是有連續的8個位組成。

資料型別：java是強型別語言，對於每一種資料都給出明確的資料型別，不同的資料型別也分配了不同的記憶體空間，所以他們表示的資料大小也不一樣。

資料型別記憶體佔用和取值範圍

java變數

變數：在程式執行過程中，其值可以發生改變的量，用來指向記憶體中的具體區域。

變數三要素：1.變數名，2.資料型別，3.變數值

定義變數格式：資料型別變數名 = 變數值；

int a = 10

變數取值格式：變數名

變數修改值：變數名 = 變數值;

a = 20;

示例：

public class VirableDemo{
	public static void main(String[] args) {
		// 變數定義
		int a = 10;
		// 輸出變數
		System.out.println(a);
		
		// 修改變數
		a = 20
		// 輸出變數
		System.out.println(a);
	}
}

使用變數注意的問題：

變數名不能重複
變數未賦值，不能使用
long型別的變數定義時，為防止整數過大，整數後面加L

long l = 10000000000L;

float型別的變數定義時，為防止格式不相容，後面加F

float f = 13.14F;

java識別符號

識別符號：用於給類、方法、變數等命名的符號。

識別符號定義規則：

由數字、字母、下劃線(_)、美元符($)組成
不能以數字開頭
不能是關鍵字
區分大小寫

常見命名規則：

小駝峰：方法、變數

識別符號是一個單詞時，首字母小寫：name
識別符號有多個單片語成，第一個單詞首字母小寫，其他大寫：firstName

大駝峰：類

識別符號為一個單詞，首字母大寫：Student
識別符號為多個單片語成，每個單詞首字母大寫：GoodStudent

java型別轉換

1.自動型別轉換：

把一個表示資料範圍小的數值或者變數賦值給另一個表示資料範圍大的變數

public class ConversionDemo{
	public static void main(String[] args) {
		// 自動型別轉換
		double a = 10;
		System.out.println(a);
        
        // 定義byte型別的便令
        byte b = 10;
        short s = b;
        int i = b;
        
        // 這種不可以
        // char c = b;
	}
}

2.強制型別轉換

把一個表示護具範圍大的數值或變數賦值給另一個表示範圍小的變數

格式：目標資料型別變數名 = （目標資料型別）值或者變數；

會產生資料丟失，不建議使用

public class ConversionDemo{
	public static void main(String[] args) {  
        // 強制型別轉換
        int k = (int)88.88;
        System.out.println(k);
	}
}

java運算子

算術運算子

運算子：對常量或者變數進行操作的符號

表示式：用運演算法把常量或者變數連線起來符合java語法的式子可以稱為表示式，不用運演算法連線的表示式體現的是不同型別的表示式。

如：

public class OperatorDemo01{
	public static void main(String[] args) {  
        // 定義兩個變數
        int a = 1;
        int b = 3;
        
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);  // 商
        System.out.println(a % b);  // 餘
        
        // 整數相除只能的到整數，要想的到小數，必須要有浮點數
        System.out.println(6.0 / 4);
	}
}

注意事項

整數相除只能的到整數，要想的到小數，必須要有浮點數

字元的 + 操作

字元的 + 操作會拿字元在計算機底層對應的數值來進行計算

'A' - 65 A-Z連續

'a' - 97 a-z連續

'0' - 48 0-9連續

public class OperatorDemo02{
	public static void main(String[] args) {  
        // 定義兩個變數
        int i = 10;
        char = 'A';
        
		c = 'A'; // 'A'的值是65
		c = 'a'; // 'a'的值97
		c = '0'; // '0'的值48
        
        // 整數相除只能的到整數，要想的到小數，必須要有浮點數
        System.out.println(i + c);

		// char ch = i + c;
        // char型別會被自動提升為int型別
        int j = i + c;
        System.out.println(j);
        
        // int d = 10 + 13.14;
        double d = 10 + 13.14;
	}
}

提升規則：

byte型別，short型別和char型別將被提升到int型別
整個表示式的型別自動提升到表示式中最高等級操作同樣的型別

字串的 "+" 操作

public class OperatorDemo03 {
	public static void main(String[] args) {
		System.out.println("it" + "heima");
		System.out.println("itheima" + 666);
		System.out.println(666 + "itheima");
		
		System.out.println("itheima" + 6 + 66);
		System.out.println(1 + 99 + "itheima");
	}
}

當 "+" 操作中出現字串時，這個 "+" 是字串連線符，而不是算術運算子，如："itheima" + 666

當 "+" 操作中，如果出現了字串，就是連線運算子，否則就是算術運算。當連續進行 "+" 操作時，從左到右逐個執行，如：1 + 99 + "itheima"

賦值運算子

符號	作用	說明
=	賦值	a=10，將10賦值給變數a
+=	加後賦值	a += b，a+b賦值給a
-=	減後賦值	a -= b，a-b賦值給a
*=	乘後賦值	a = b，ab的乘積賦值給a
/=	除後賦值	a /= b，a/b的商賦值給a
%=	取餘後賦值	a %= b，a/b的餘數賦值給a

public class OperatorDemo04 {
	public static void main(String[] args) {
		// 把10賦值給int
		int i = 10;
		System.out.println("i:" + i);
        
        // += 把左邊和右邊資料做加法，結果賦值給左邊
        i += 20;  // 等價於 i = i + 20
        System.out.println("i:" + i);
        
        // 注意：擴充套件的賦值運算底層隱含了強制型別轉換
        short s = 10;
        // s += 20;
        s = (short)(s + 20);
        System.out.println("s:" + s);
	}
}

自增運算子

符號	作用	說明
++	自增	變數值加1
--	自減	變數值減1

注意：

++和--既可以放在變數的後面，也可以放在變數的前邊。
單獨使用時，++和--無論是放在變數前面或者是變數後面，結果是一樣的。
參與操作時：如果放在變數前面，變數先參與操作，後做++或--；如果放在變數後面，變數先做++或--，後參與操作。

最常見的用法：單獨使用

public class OperatorDemo05 {
	public static void main(String[] args) {
		// 把10賦值給int
		int i = 10;
		System.out.println("i:" + i);
        
        // 單獨使用的時候，i++和++i是等效的
        i++;
        System.out.println("i:" + i);
        ++i;
        System.out.println("i:" + i);
        
        // 參與操作時
        int i = 10;
        int j = i++;
        System.out.println("i:" + i);
        System.out.println("j:" + j);
        
        int i = 10;
        int j = ++i;
        System.out.println("i:" + i);
        System.out.println("j:" + j);
	}
}

關係運算符

常見關係運算符

符號	說明
==	a==b，判斷a和b是否相等，成立true，否則false
!=	a==b，判斷a和b是否不相等，成立true，否則false
>	a>b，判斷a是否大於b，成立true，否則false
>=	a>=b，判斷a是否大於等於b，成立true，否則false
<	a<b，判斷a是否小於b，成立true，否則false
<=	a<=b，判斷a是否小於等於b，成立true，否則false

示例

public class OperatorDemo06 {
	public static void main(String[] args) {
		// 把10賦值給int
		int i = 10;
		int j = 20;
		int k = 10;
        // 比較
		System.out.println(i == j);
		System.out.println(i != j);
		System.out.println(i > j);
		System.out.println(i >= j);
		System.out.println(i < j);
		System.out.println(i <= j);

	}
}

邏輯運算子

邏輯運算：用來連線關係表示式的運算子，也可以連線布林型別和常量。

符號	作用	說明
&	邏輯與	a&b，ab都為True，則為true，否則false
\|	邏輯或	a\|b，ab任意為True，則為true，否則false
^	邏輯異或	a^b，a和b結果不同為true，否則為false
!	邏輯非	!a，結果和a相反

示例

public class OperatorDemo07 {
	public static void main(String[] args) {
		// 把10賦值給int
		int i = 10;
		int j = 20;
		int k = 30;
        // & 有false則false
        System.out.println((i > j) & (i > k));
        System.out.println((i < j) & (i > k));
        System.out.println((i > j) & (i < k));
        System.out.println((i < j) & (i < k));
        
        // | 有true則ture
        System.out.println((i > j) | (i > k));
        System.out.println((i < j) | (i > k));
        System.out.println((i > j) | (i < k));
        System.out.println((i < j) | (i < k));
        
        // ^ 相同為false，不同為true
        System.out.println((i > j) ^ (i > k));
        System.out.println((i < j) ^ (i > k));
        System.out.println((i > j) ^ (i < k));
        System.out.println((i < j) ^ (i < k));
        
        // ! 相反
        System.out.println((i > j));
        System.out.println(!(i < j));

	}
}

短路邏輯運算子

符號	作用	說明
&&	短路與	作用和&相同，但是有短路效果，前邊為false，則為false，不再判斷
\|\|	短路或	作用和\|相同，但是有短路效果，前邊為true，則為true，不再判斷

示例

public class OperatorDemo08 {
	public static void main(String[] args) {
		// 把10賦值給int
		int i = 10;
		int j = 20;
		int k = 30;
        // && 有false則false
        System.out.println((i > j) && (i > k));
        System.out.println((i < j) && (i > k));
        System.out.println((i > j) && (i < k));
        System.out.println((i < j) && (i < k));
        
        // || 有true則ture
        System.out.println((i > j) || (i > k));
        System.out.println((i < j) || (i > k));
        System.out.println((i > j) || (i < k));
        System.out.println((i < j) || (i < k));
        
        // &&和&
        System.out.println((i++ > 100) & (j++ > 100));
        // System.out.println((i++ > 100) && (j++ > 100));
        System.out.println("i:" + i);
        System.out.println("j:" + j);
	}
}

注意事項：

邏輯與&，無論左邊真假，右邊都要執行

短路與&&，如果左邊為真，右邊執行；如果左邊為假，右邊不執行。
邏輯或|，無論左邊真假，右邊都要執行

短路或||，如果左邊為假，右邊執行；如果左邊為真，右邊不執行。

三元運算子

格式：關係表示式?表示式1: 表示式2;

範例：a > b ? a: b

public class OperatorDemo09 {
	public static void main(string[] args) {
		// 定義兩個變數
		int a = 10;
		int b = 20;
		
		// 獲取兩個資料中的較大值
		int max = a > b ? a: b;
		// 輸出結果
		System.out.println("max:" + max)
	}
}

java資料輸入

Scanner使用基本步驟

/*
	資料匯入
		導包：
			import java.util.Scanner;
		建立物件：
			Scanner sc = new Scanner(System.in);
		接受資料：
			int x = sc.nextInt();
*/
import java.util.Scanner;
public class ScannerDemo {
	public static void main(String[] args) {
		// 建立物件
		Scanner sc = new Scanner(System.in);
		
		// 接收資料
		int x = sc.nextInt();
		
		// 輸出資料
		System.out.println("x:" + x);
	}
}

java流程控制

流程控制語句分類

順序結構
分支結構（if, switch)
迴圈結構（for, while, do ... while）

順序結構

最簡單的基本流程控制，按照程式碼先後順序，一次執行。

public class OrderDemo {
	public static void main(string[] args) {
		System.out.println("開始");
		System.out.println("語句A");
		System.out.println("語句B");
		System.out.println("結束");
	}
}

if分支結構

1.單分支格式

if (關係表示式) {
	語句體;
}

執行流程：計算關係表示式，值為true，執行與語句體，否則不執行語句體，繼續執行後面語句。

public class IfDemo {
	public static void main(String[] args) {
		System.out.println("開始");
		// 定義兩個變數
		int a = 10;
		int b = 20;
		
		// 判斷a和b是否相等，相等輸出：a等於b
		if (a == b) {
			System.out.println("a等於b");
		};
		if (a != b) {
			System.out.println("a不等於b");
		};
		System.out.println("結束");
	}
}

2.二分支格式

if (關係表示式) {
	語句體1;
} else {
	語句體2;
}

執行流程：

計算關係表示式的值
值為true，執行與語句體1
否則執行語句體2
繼續執行後面語句。

public class IfDemo02 {
	public static void main(String[] args) {
		System.out.println("開始");
		// 定義兩個變數
		int a = 10;
		int b = 20;
		
		// 判斷a和b是否相等，相等輸出：a等於b
		if (a == b) {
			System.out.println("a等於b");
		} else {
			System.out.println("a不等於b");
		};
		System.out.println("結束");
	}
}

3.多分支格式

if (關係表示式1) {
	語句體1;
} else if (關係表示式2) {
	語句體2;
}
...
else {
	語句體n+1;
}

執行流程：

計算關係表示式1的值；
值為true，執行與語句體1；值為false就計算關係表示式2的值；
值為true，執行與語句體2；值為false就計算關係表示式3的值；
...
如果沒有任何關係表示式為True，則執行語句體n+1；

import java.util.Scanner;
public class IfDemo03 {
	public static void main(String[] args) {
		System.out.println("開始");
		// 輸入一個星期數，對應星期一、星期二、星期三、...、星期日
		Scanner sc = new Scanner(System.in);
		System.out.println("輸入一個星期數(1~7):");
		int week = sc.nextInt();
		
		if (week == 1) {
			System.out.println("星期一");
		} else if (week == 2) {
			System.out.println("星期二");
		} else if (week == 3) {
			System.out.println("星期三");
		} else if (week == 4) {
			System.out.println("星期四");
		} else if (week == 5) {
			System.out.println("星期五");
		} else if (week == 6) {
			System.out.println("星期六");
		} else {
			System.out.println("星期日");
		};
		System.out.println("結束");
	}
}

switch語句

流程格式

switch (表示式) {
	case 值1:
		語句體1;
		break;
	case 值2:
		語句體2;
		break;
	...
	default:
		語句體n+1;
		[break;]
}

說明：

表示式：取值為byte、short、int、char、JDK5以後可以是列舉，JDK7以後可以使String。
case：後面跟的是要和表示式進行比較的值
break：表示中斷，結束的意思，用來結束switch語句
default：表示所有情況都不匹配的時候，就執行該處的內容，和if-else語句相似

執行流程：

計算表示式的值
依次和case後面的值進行比較，如果有對應的值，就會執行相應的語句，執行過程中，遇到break會結束。
如果所有case後面的值和表示式的值不匹配，就會執行default裡面的語句體，然後程式結束。

import java.util.Scanner;

public class SwitchDemo{
	public static void main(String[] args) {  
        System.out.println("開始");
		// 輸入一個星期數,對應輸出星期一,...星期日
		Scanner sc = new Scanner(System.in)

		System.out.println("請輸入一個星期數(1-7):")
		int week = sc.nextInt();
		switch (week) {
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期日");
				break;
			default:
				System.out.println("輸入星期數有誤");
				break;
		}

		System.out.println("結束")
	}
}

for迴圈語句

迴圈結構組成：

初始化條件：表示迴圈開始時的起始狀態
條件判斷語句：用於判斷迴圈是否反覆執行的條件
迴圈體語句：迴圈反覆執行的內容
條件控制語句：迴圈中每次變化的內容，控制迴圈體是否執行下去

格式

for (初始化語句; 條件判斷語句; 條件控制語句) {
	迴圈體語句;
}

流程：

執行初始化語句
執行條件判斷語句：結果是false，迴圈結束；結果是true，繼續執行
執行迴圈體語句
執行條件控制語句
回到2重複執行

public class ForDemo{
	public static void main(String[] args) {  
		// 輸出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}
	}
}

while迴圈語句

完整格式

初始化語句;
while (條件判斷語句) {
	迴圈體語句;
	條件控制語句;
}

執行流程：

執行初始化語句；
執行條件判斷語句：結果是false，迴圈結束；結果是true，繼續執行；
執行迴圈體語句；
執行條件控制語句；
回到2重複執行；

public class WhileDemo01 {
	public static void main(String[] args) {  
		// for實現,輸出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}

		// while實現,輸出5次"HelloWrold"
		int j = 1;
		while (j <= 5) {
			System.out.println("HelloWorld");
			j++;
		}
	}
}

do...while迴圈語句

基本格式

do {
	迴圈體語句;
} while (條件判斷語句);

完整格式

初始化語句;
do {
	迴圈體語句;
	條件控制語句;
} while (條件判斷語句);

執行流程：

執行初始化語句；
執行迴圈體語句；
執行條件控制語句；
執行條件判斷語句：結果是false，迴圈結束；結果是true，繼續執行；
回到2重複執行；

public class WhileDemo02 {
	public static void main(String[] args) {  
		// for實現,輸出5次"HelloWrold"
		for (int i=1; i<=5; i++) {
			System.out.println("HelloWrold");
		}

		// while實現,輸出5次"HelloWrold"
		int j = 1;
		do {
			System.out.println("HelloWorld");
			j++;
		} while (j <= 5);
		
	}
}

三種迴圈的區別

迴圈區別：

for和while是先判斷條件是否成立，在決定是否執行
do...while先執行一次，在判斷是否成立，是否繼續執行

for和while區別：

條件語句控制的自增變數，在for迴圈結束後，外部不能再次訪問到
條件語句控制的自增變數，不屬於while語法結構，while迴圈結束後，還可以繼續使用

public class LoopTest {
	public static void main(String[] args) {
		// 區別一:  
		// for迴圈
		for (int i=3; i<3; i++) {
			System.out.println("i love java");
		}

		// while迴圈
		int j = 3;
		while (j < 3) {
			System.out.println("j love java");
			j++;
		}

		// do...while迴圈
		int k = 3;
		do {
			System.out.println("k love java");
			j++;
		} while (k < 3);

		// 區別2:
		// for迴圈
		for (int i=3; i<3; i++) {
			System.out.println("i love java");
		}
		// System.out.println(i);  // 不能再使用,會報錯

		// while迴圈
		int j = 3;
		while (j < 3) {
			System.out.println("j love java");
			j++;
		}
		System.out.println(j);  // 可以正常使用
	}
}

三種死迴圈寫法

while死迴圈是最常用的

public class LoopTest01 {
	public static void main(String[] args) {
		// 死迴圈
		for (;;) {
			System.out.println("for");
		}

		while (true) {
			System.out.println("while");
		}

		do {
			System.out.println("do...while");
		} while (true);
	}
}

跳轉控制語句

continue：迴圈中，基於條件控制，跳過某次迴圈體內容的執行，繼續下次的執行

break：迴圈中，基於條件控制，終止迴圈體內容的執行，結束當前整個迴圈。

public class ControlDemo {
	public static void main(String[] args) {
		for (int i=1; i<=5; i++) {
			// continue
			break
			System.out.println(i)
		}
	}
}

迴圈巢狀

分支語句中包含分支語句稱為分支巢狀

迴圈語句中包含迴圈語句稱為迴圈巢狀

public class LootNestDemo {
	public static void main(String[] args) {
		// for迴圈巢狀
		for (int hour=0; i<=3; i++) {
			for (int minute=0; minute<=3; minute++) {
				System.out.println(hour + "時" + minute + "分");
			}
			System.out.println("---------------")
		}
	}
}

Random模組

Random模組：產生一個隨機數

使用步驟：

// 匯入包
import java.util.Random
// 建立物件
Random r = new Random();
// 獲取隨機數
int number = r.nextInt(10); // 獲取資料的範圍: [0,10)

示例

import java.util.Random
public class RandomDemo {
	public static void main(String[] args) {
		// 建立物件
        Random r = new Random();
        // 獲取隨機數
        int number = r.nextInt(10); // 獲取資料的範圍: [0,10)
		System.out.println(number);
        
        // 獲取一個1~100之間的隨機數
        int x = r.nextInt(100) + 1;
        System.out.println(x);
		}
	}
}

java註釋

java關鍵字

java常量

java資料型別

java變數

java識別符號

java型別轉換

java運算子

算術運算子

字元的 + 操作

賦值運算子

自增運算子

關係運算符

邏輯運算子

三元運算子

java資料輸入

java流程控制

順序結構

if分支結構

switch語句

for迴圈語句

while迴圈語句

do...while迴圈語句

三種迴圈的區別

跳轉控制語句

迴圈巢狀

Random模組

相關推薦