Java基礎知識點梳理

Java基礎知識點梳理

摘要：
雖然已經在實際工作中經常與java打交道，但是一直沒系統地對java這門語言進行梳理和總結，掌握的知識也比較零散。恰好利用這段時間重新認識下java，並對一些常見的語法和知識點做個總結與回顧，一方面為了加深印象，方便後面查閱，一方面為了學好java打下基礎。

Java簡介

java語言於1995年正式推出，最開始被命名為Oak語言，由James Gosling（詹姆斯·高斯林）在Sun Microsystems公司和同事共同研發，Microsystems如今已經被oracle收購。java語言具有以下特點：

• 簡單性
• 物件導向
• 可移植性
• 安全性
• 健壯性
• 多執行緒

Java檔案執行過程如下：

1. 編寫原始碼，檔案格式： .java
2. 編譯 .java檔案 生成.class檔案（二進位制位元組碼檔案）
3. 執行 .class檔案在JVM上(java虛擬機器，支援多平臺)

Java語言基礎語法

註釋

註釋用於解釋程式，增強可讀性，java中註釋有以下幾種:

1. 單行註釋，語法如下：

// 單行註釋

2. 多行註釋，語法如下：

/*
多行註釋
多行註釋
*/

3. javadoc註釋，是一種專業註釋，可以被javadoc.exe工具解析提取生成幫助文件

/**
 * javadoc註釋
*/

識別符號

識別符號用於標識類名，方法名，變數名，介面名等，命名需要滿足以下規則：

• 只能由"數字，字母（A-Z 或者 a-z）,美元符（$）、或者下劃線（_）"組成
• 所有的識別符號都應該以字母（A-Z 或者 a-z）,美元符（$）、或者下劃線（_）開始
• 嚴格區分大小寫，不能用關鍵字做識別符號

java程式設計規範建議遵守駝峰命名法，類名和介面名首字母大寫，變數和方法名首字母小寫。Java採用unicode的編碼方式，所以識別符號也支援中文。

類的定義

java定義一個類用class關鍵字，有以下幾點需要注意：

• 一個java原始檔定義公開的類只能有一個，類名稱必須和java原始檔名稱一致
• 一個java原始檔可以編寫多個class
• 每一個class都可以編寫main方法

Java資料型別

基本資料型別

資料型別的作用是指導JVM在執行程式的時候給該資料分配多大的記憶體空間，Java提供了以下八種基礎資料型別：

序號	分類	型別	介紹	例項
01	整數型	byte	8位有符號整數（取值範圍：-128~127）	byte a = 128;
02	整數型	short	16位有符號整數（取值範圍：-32768~32767)	short num = 1314;
03	整數型	int	32位有符號整數	int n = 131400;
04	整數型	long	64位有符號整數	long sum = 10000L;
05	浮點型	float	單精度、32位、符合IEEE 754標準的浮點數	float f1 = 13.14f;
06	浮點型	double	雙精度、64 位、符合IEEE 754標準的浮點數	double d1 = 13.1452;
07	布林型	boolean	一位用於表示真假，只能取true 和 false；	boolean isMan = true;
08	字元型	char	一個單一的 16 位 Unicode 字元(0~65535)	char firstLetter = ‘a’;

整型表示方式

整型有三種表示方式，預設是十進位制：

進位制	表示方式	例項
十進位制	預設的表示方式，以非零數字開始	int x = 10; // x = 10
八進位制	以數字零"0"開始	int x = 010; // x = 8
十六進位制	以"0x"開始	int x = 0x10; // x = 16

型別轉換

型別轉換有如下規則：

1. 八種基本資料型別除了布林型別之外，剩下的7種型別都可以互相轉換
2. 小容量向大容量轉換，可以自動進行，容量從小到大排序為：
   byte < short < int < long < float < double
3. 大容量資料轉換成小容量，需要進行強制型別轉換，強轉會損失精度
4. byte, short ,char 混合運算，各自轉換成int；多種資料型別混合運算，轉換成容量最大的型別再運算。

對於強制型別轉換，將long強轉成int的語法如下：

long k = 6475201314L;
int num = (int) k;

注意：大容量轉換成小容量編譯無法通過，比如下面程式碼無法編譯：

byte b = 19;
b = b + 13; // 相當於直接把整型賦值給byte型，報錯
b += 13; // 可以編譯，等同於 b = (byte)(b + 13)

複合資料型別

字串(String)

在Java中使用String 類來建立和操作字串，初始化一個String的語法如下：

// 常用，用雙引號直接建立
String testStr = "Wasting time is robbing oneself";
// 不常用，使用char陣列建立
char[] helloArray = {'h', 'e', 'l', 'l', 'o'};
String helloString = new String(helloArray);  

由於字串使用非常頻繁，String類也提供了很多方法，下面介紹一些用的比較多的。

• 對字串進行修改的常用方法有(包括格式化，大小寫轉換)：

序號	方法	描述
01	String trim()	返回字串的副本，忽略前面空白和尾部空白。
02	String intern()	返回字串物件的規範化表示形式。
03	String toUpperCase()	使用預設語言環境的規則將此 String 中的所有字元都轉換為大寫。
04	String toUpperCase(Locale locale)	使用給定的Locale規則將String中所有字元轉換為大寫。
05	String toLowerCase()	使用預設語言環境的規則將此 String 中的所有字元都轉換為小寫。
06	String toLowerCase(Locale locale)	使用給定 Locale 的規則將此 String 中的所有字元都轉換為小寫。

• 對字串進行查詢和替換的方法有：

序號	方法	描述
01	boolean startsWith(String str1)	字串是否以指定的字串str1開始。
02	boolean startsWith(String str1, int toffset)	字串指定索引開始的子字串是否以指定字串str1開始。
03	boolean endsWith(String str1)	測試此字串是否以指定的字串str1結束。
04	int indexOf(String str1)	返回指定子字串str1在此字串中第一次出現處的索引。
05	int indexOf(String str1, int fromIndex)	從指定的索引開始，返回指定子字串str1在此字串中第一次出現處的索引。
06	int lastIndexOf(String str1))	返回指定子字串str1在此字串中最右邊出現處的索引。
07	int lastIndexOf(String str1, int fromIndex)	返回指定子字串在此字串中最後一次出現處的索引，從指定的索引開始反向搜尋
08	boolean matches(String regex)	測試此字串是否匹配給定的正規表示式
09	String replace(char oldChar, char newChar)	返回一個用 newChar 替換此字串中出現的所有 oldChar 得到的新字串。
10	String replaceAll(String regex, String replacement)	使用給定的 replacement 替換此字串所有匹配給定的正規表示式的子字串

• 獲取子字串的常用方法有：

序號	方法	描述
01	String substring(int beginIndex)	返回一個新的從指定索引開始的字串。
02	String substring(int beginIndex, int endIndex)	返回從索引beginIndex開始到endIndex結束的新的字串
03	String[] split(String regex)	根據給定正規表示式的匹配拆分此字串。
04	String[] split(String regex, int limit)	根據匹配給定的正規表示式來拆分此字串。

• 對字串進行比較的方法有：

序號	方法	描述
01	int compareTo(String anotherString)	按字典順序比較兩個字串,相等時候返回0。
02	int compareToIgnoreCase(String str)	按字典順序比較兩個字串,不考慮大小寫
03	boolean contentEquals(StringBuffer sb)	當且僅當字串與指定的StringBuffer有相同順序的字元時候返回真。
04	boolean equals(Object anObject)	將此字串與指定的物件比較。
05	boolean equalsIgnoreCase(String anotherString)	將此 String 與另一個 String 比較，不考慮大小寫。

• 其他常見的方法比如統計長度，拼接，轉換等：

序號	方法	描述
01	int length()	按字典順序比較兩個字串,相等時候返回返回此字串的長度。
02	String toString()	轉換成String物件
03	String concat(String str)	將指定字串連線到此字串的結尾。
04	char[] toCharArray()	將此字串轉換為一個新的字元陣列。
05	char charAt(int index)	返回指定索引處的 char 值。

陣列

陣列可以用於存放固定大小的同型別元素，宣告一個陣列的語法如下：

變數型別[] 陣列名;   

建立陣列的語法：

陣列名 = new 變數型別[陣列大小];
變數型別[] 陣列名 = {value0, value1, ..., valuek};

陣列的變數型別可以是前面介紹八種基本資料型別以及複合資料型別，“陣列名[索引]” 可以訪問陣列元素，下面是一個操作一維陣列例子：

int[] primeNumbers = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
for (int num : primeNumbers) {
	System.out.println("num: " + num);
}

操作二維陣列的例子如下：

int[][] a = new int[2][3];
a[0][0] = 19;
String[][] s = new String[2][];
s[0] = new String[2]; // 第一個陣列長度為2
s[1] = new String[3]; // 第二個陣列長度為3
s[0][0] = "Hello";
s[0][1] = "World";

java.util.Arrays類能方便地運算元組，它提供的所有方法都是靜態的，比較常見的方法有：

序號	方法	描述
01	public static int binarySearch(Object[] a, Object key)	用二分查詢演算法在給定陣列中搜尋給定值的物件(Byte,Int,double等)。前提是陣列在呼叫前必須排序好的。找到了則返回搜尋鍵的索引；否則返回 (-(插入點) - 1)。
02	public static void sort(Object[] a)	對指定物件陣列根據其元素的自然順序進行升序排列。同樣的方法適用於所有的其他基本資料型別（Byte，short，Int等）。

使用Arrays的sort方法進行排序的例子如下：

int[] primeNumbers = {7, 11, 5, 2, 3};
Arrays.sort(primeNumbers);
for (int num : primeNumbers) {
	System.out.println("num: " + num);
}

集合

Java語言提供了一個完善的集合框架，主要包括兩種型別的容器，一種是集合（Collection），儲存一個元素集合，另一種是圖（Map），儲存鍵/值對對映
經常用到的集合有：

序號	型別	描述
01	ArrayList	該類實現了List的介面，實現了動態陣列，隨機訪問和遍歷元素時，提供更好的效能，插入刪除效率低。
02	LinkedList	該類實現了List介面，允許有null（空）元素。主要用於建立連結串列資料結構，插入刪除效率高，查詢效率較低。
03	HashSet	該類實現了set介面，不允許出現重複元素，不保證集合中元素的順序。
04	HashMap	HashMap 是一個雜湊表，它儲存的內容是鍵值對(key-value)對映，具有很快的訪問速度

ArrayList提供的常用方法有：

序號	分類	方法	描述
01	增加	boolean add(E object)	向容器中新增指定資料型別的元素
02	增加	boolean addAll([int index], Collection collection)	向容器中指定的位置增加一個集合
03	獲取	E get(int location)	獲得容器中位置location的元素
04	刪除	E remove(int i)	移除下標為i的元素，返回值是刪除的資料元素
05	刪除	void clear()	清空容器所有元素
06	統計	int size()	獲得容器中元素的個數
07	判斷	boolean isEmpty()	獲得容器中是否有元素
08	修改	E set(int location, E object)	修改容器中指定位置元素的值

下面是操作一個java.util.ArrayList的例子:

ArrayList list = new ArrayList();
list.add(2);
list.add(3);
list.add(5);
for (int i = 0; i<list.size(); i++) {
	System.out.println(list.get(i));
}
		
list.remove(1);
list.set(1, 19);

型別轉換方法

關於資料型別，最後再介紹下Java中常見的型別轉換方法：

序號	方法	描述	例項
01	String.toCharArray()	String型別轉換成char陣列	String str = “hello word”;char[] nums = str.toCharArray();
02	Integer.parseInt()	String型別轉換成int型別	String numStr = “1314”;int num = Integer.parseInt(numStr);
03	Double.parseDouble()	String型別轉換成Double型別	String doubleStr = “13.14”;double d = Double.parseDouble(doubleStr);
04	Integer.toString()	int型別轉換成String型別	int num = 12;String numStr = Integer.toString(num);
05	Double.toString()	Double型別轉換成String型別	Double num = 13.14;String numStr = Double.toString(num);

運算子

Java的運算子種類比較多，本文介紹幾種常見的運算子：

算術運算子

java的算術運算子如下表(int a = 10; int b= 9;):

序號	操作符	描述	例項
01	+	加法 - 對運算子兩側的值進行相加	a + b = 19;
02	-	減法 - 左運算元減去右運算元	a - b = 1;
03	*	乘法 - 對運算子兩側的值進行乘法運算	a * b = 90;
04	/	除法 - 左運算元除以右運算元	a / b = 1;
05	％	取餘 - 左運算元除以右運算元的餘數	a % b = 1;
06	++	自增: 運算元的值增加1	++a，a++均為11，前者先自增，再進行表示式運算，後者順序相反
07	–	自減：運算元的值減少1	–b,b-- 均為8，前者先自減，再進行表示式運算，後者順序相反

基本的賦值運算子"=" 可以與前5種算術運算子組合成 +=,-=,*=,/=,%=等擴充套件的賦值運算子
int a = 10; a += 5； 等價於 a = (int)(a + 5)；
其他的運算子類似，擴充套件運算子預設有型別轉換，但是不改變運算結果型別

對於"+"運算子，只要兩邊的運算元有一個是字串就會進行字串連線運算生成一個新的字串。

關係運算子

java中主要有以下六種關係運算子：

運算子	描述	運算子	描述	運算子	描述
>	大於	>=	大於等於	<	小於
<=	小於等於	==	等於	!=	不等於

關係運算子返回的結果是布林型

邏輯運算子

主要有以下三種邏輯運算子（boolean a = true; boolean b = false）：

序號	操作符	描述	例項
01	&&	邏輯與，只有兩個運算元都為真才返回true	a && b 為false
02	||	邏輯或，兩個運算元只要有一個為真就返回true	a || b 為true
03	！	邏輯非，對運算元的狀態取反	!a 為false，!b為true

位運算子

位運算子對兩個運算元的每一位進行運算，有以下幾種常見的型別：

運算子	描述	運算子	描述	運算子	描述
&	按位與	|	按位或	^	按位異或
~	按位取反	<</>>	按位左移/右移	>>>	指定位數右移，空位補零

三目運算子

三目元素符的語法規則：

布林表示式 ? 表示式1 : 表示式2;

布林表示式為真執行表示式1，為假執行表示式2，利用三目運算子求最大值的一個例子如下：

int a = 10;
int b = 9;
int max = (a > b) ? a : b;
System.out.println("max number is: " + max);

控制語句

每種程式語言都少不了控制語句來控制程式碼流程，java語言也提供了豐富的控制語句。

選擇結構

if語句

if語句常見的語法：

// 第一種寫法，else分支可以省略
if (布林表示式) {
	表示式為真要執行的語句;
} else {
	其他條件要執行的語句
}
// 第二種寫法，最後的else分支可以省略
if (布林表示式) {
	表示式為真要執行的語句;
} else if (布林表示式1) {
	表示式1為真要執行的語句
} else if (布林表示式2) {
	表示式2為真要執行的語句
} else {
	除上述條件之外要執行的語句
}

switch語句

switch語句的語法如下：

switch (expression) {
    case value1 :
       // 匹配value1成功之後執行的語句
       break; // 可選
    case value2 :
       // 匹配value2成功之後執行的語句
       break; //可選
    ...
    default : // 可選
       // 前面case分支都沒匹配時執行的語句
}

其中expression支援byte、short、int、char以及字串(String)，byte、short、char會轉換為int型別。程式只有遇到break語句才會跳出switch語句，缺少break的分支會繼續往下面分支執行。

迴圈結構

程式當中總會有些需要重複執行的程式碼片段，因此各個程式語言都支援迴圈語法。

for語句

for語句的語法如下：

for (初始化表示式; 布林表示式; 更新表示式) {
    // 要重複執行的程式碼片段
}

執行過程：

1. 初始化表示式最先執行而且只執行一次；
2. 判斷布林表示式，如果是真執行迴圈體，如果是假則退出迴圈
3. 迴圈體執行之後更新表示式，再執行步驟2，反覆迴圈直到退出迴圈
   利用for迴圈計算數字1到10的和的程式碼如下：

int sum = 0;
for (int i = 0; i <= 10; i++) {
	sum += i;
}
System.out.println("the sum is: " + sum);

while語句

while語句的語法如下：

while (布林表示式) {
  // 迴圈內容
}

執行過程:
先判斷布林表示式的值，為真就執行迴圈體，為假則迴圈結束，迴圈體可能一次也不執行。
使用while迴圈計算數字1到10的和是：

int sum = 0;
int i = 0;
while (i <=10) {
	sum += i;
	i++;
}
System.out.println("The sum is: " + sum);

do…while 迴圈

do…while迴圈的語法如下：

do {
	// 迴圈內容
} while (布林表示式);

do…while迴圈先執行迴圈內容再判斷表示式，迴圈體至少會執行一次。

控制迴圈語句

break語句

break使用在switch語句中終止switch執行，使用在迴圈語句中終止迴圈，跳出當前迴圈體。語法如下：

break;

continue語句

continue表示直接進入下一次迴圈繼續執行，語法如下：

continue;

Java變數型別

在Java中，所有的變數在使用前必須宣告。宣告變數的基本格式如下：

type identifier = value;

value的資料型別必須和宣告的變數型別一致，變數的值可變化，必須先宣告再賦值才能訪問。

區域性變數：

java中的區域性變數宣告在方法內部，有以下特點：

• 變數只在作用域內有效，超出作用域變數將會被銷燬；
• 變數是在棧上分配，沒有預設值，所以區域性變數被宣告後，必須經過初始化，才可以使用。

區域性變數儲存在棧記憶體中。

例項變數(成員變數)：

成員變數在方法體之外宣告，有以下特點：

• 當一個物件被例項化之後，每個例項變數的值就跟著確定
• 例項變數在物件建立的時候建立，在物件被銷燬的時候銷燬
• 例項變數具有預設值，數值型變數的預設值是0，布林型變數的預設值是false，引用型別變數的預設值是null。

成員變數在JVM的堆記憶體中儲存，垃圾回收器主要針對堆記憶體處理。

靜態變數：

靜態變數用static關鍵字宣告，需要記住以下特點：

• 無論一個類建立了多少個物件，類只擁有靜態變數的一份拷貝
• 靜態變數在第一次被訪問時建立，在程式結束時銷燬。
• 靜態變數具有預設值，取值和例項變數類似

不同型別變數在JVM中的儲存情況如下表：

棧記憶體	堆記憶體	方法區記憶體
區域性變數/執行的方法	例項變數/new出來的物件	靜態變數/程式碼片段

方法/函式

方法語法

方法實質就是一段可以重複使用，完成某項特定功能的片段，和C語言中的函式類似。方法的語法如下：

[修飾符] 返回值型別 方法名(引數型別 引數名1, 引數型別 引數名2 ...) {
    ...
    方法體;
    ...
    return 返回值; // 可選，與返回值型別一致
}

比如常見的main方法如下：

public static void main(String []args) {
	System.out.println("Hello World!");
}

方法有如下幾個部分組成：

1. 修飾符：修飾符，這是可選的，定義了該方法的訪問型別。比如public, static, private, protected等
2. 返回值型別 ：方法可能會返回值，支援前面介紹的八種基本資料型別以及String，如果不需要返回值，返回值型別就寫成void。
3. 方法名：是方法的實際名稱，建議首字母小寫。方法名和參數列共同構成方法簽名。
4. 引數型別：即形參列表，形參的個數可以是：0~N個。當方法被呼叫時，傳遞值給對應引數，這個值被稱為實參。
5. 方法體：方法體包含具體的語句，定義該方法的功能。
   下面是實現判斷一個正整數是否是質數的函式的例子(假設num大於2)：

private static boolean isPrimeNumber(int num) {
	boolean isPrime = true;
	for (int i = 2; i < num; i++) {
		if (num % i == 0) {
			isPrime = false;
			break;
		}
	}
	return isPrime;
}

方法記憶體

方法程式碼片段屬於.class位元組碼檔案的一部分，在呼叫方法的時候才會在棧中分配記憶體，稱為壓棧；方法執行結束釋放方法的記憶體空間稱為彈棧。方法執行完之後，方法內區域性變數的空間也釋放，因此區域性變數只在方法內有效。JVM的棧中主要儲存的是區域性變數。

方法過載

方法過載(overload)主要是是指方法名相同，引數列表不同，和返回值型別無關，和修飾符無關。要構成方法過載需要滿足以下條件：

1. 方法是在同一個類當中
2. 這些方法的方法名相同
3. 引數列表不同，可以是數量不同，順序不同，型別不同

物件導向

物件導向是Java核心的特點，主要有以下特性：

• 封裝：封裝就是隱藏實現細節，僅對外提供訪問介面。優點是使程式碼模組化，具有安全性。
• 繼承：繼承就是將已存在的類(父類)的定義作為基礎建立新類，新類(子類)的定義可以增加新的資料或新的功能，也可以用父類的功能
• 多型：多型就是引用變數指向的具體型別和通過該引用變數發出的方法呼叫在程式設計時並不確定，而是在程式執行期間才確定。使得程式靈活地執行在多個狀態。

物件和類的定義：

• 物件(object)：物件是類的一個例項，是實際存在的個體，有狀態和行為。
• 類(class)：類是一個模板，它描述一類物件的行為和狀態，是抽象思考的結果。

物件和類的關係：
一個類進行例項化就形成了物件，物件抽象形成類。

類的語法如下：

[修飾符列表] class 類名 {
	屬性; // 物件的狀態資訊，通常採用變數方式定義，稱為成員變數
	方法; // 物件的動作資訊
}

類例項化需要用new運算子，語法如下：

new 類名();

java中的類屬於引用資料型別，new新建的java物件儲存在JVM的堆記憶體中，new等號左側類的變數名儲存的是指向堆記憶體的地址。每個new出來的類的記憶體互相獨立。
Java物件導向中相關的重要知識點有：

• 構造方法：構造方法名稱與類名相同，無返回引數。構造方法在類初始化的時候呼叫，支援過載。類存在預設的無參構造方法。
• this關鍵字：this指向當前物件的引用，"this.屬性名稱"或者"this.方法名稱"用於訪問本類的變數或者方法，在構造方法中使用"this();"語句訪問本類的構造方法。
• static關鍵字：static修飾屬性表示靜態變數，修飾類的方法表明無需類的物件就可以呼叫此方法。
• super關鍵字：super為對父類的引用，可以使用super來呼叫父類的屬性，方法，和構造方法。
• final關鍵字：final修飾變數表示變數的值初始化後不能發生變化；final修飾方法表示不能被子類重寫；final修飾的類無法被繼承。
• 抽象類：抽象類使用abstract關鍵字宣告，非抽象類繼承抽象類必須實現所有抽象方法，抽象類不能被例項化。抽象類不能宣告為final。
• instanceof關鍵字：instanceof 是用於檢查物件是否為指定的型別，通常在進行型別轉換時要使用，以避免發生型別轉換異常。
• 介面(Interface)：介面是一個抽象型別，是抽象方法的集合。介面不是類，介面沒有構造方法，不能被例項化，只能被類實現。介面只能包含 static 和 final 變數。

Java中宣告一個介面的語法如下：

interface 介面名稱 [extends 其他的介面名] {
　　全域性常量;
　　抽象方法;
}

常用函式

接著介紹Java中使用非常頻繁的幾個函式：

輸出函式

控制檯的輸出由 print() 和 println() 完成。這些方法都由類 PrintStream 定義，System.out 是該類物件的一個引用。print()列印指定的字元不換行，println()列印完成換一行。
下面是使用的例子：

System.out.print("Remember: ");
System.out.println("Haste makes waste");

輸入函式

Java中使用java.util.Scanner類獲取使用者的輸入，使用前需要先建立Scanner物件。常用next() 與 nextLine() 方法獲取輸入的字串，對應地用hasNext() 與 hasNextLine() 判斷是否還有輸入的資料。
下面是使用next函式獲取使用者輸入字串的例子：

// 建立scanner物件
Scanner scan = new Scanner(System.in);

// 判斷是否還有輸入
if (scan.hasNext()) {
	String inputStr = scan.next();
	System.out.println("you input：" + inputStr);
}
// 關閉scanner
scan.close();

還可以使用nextInt接收一個整數，Scanner常用的方法如下表：

序號	方法	描述	判斷是否有資料方法
01	next()	獲取輸入的字串，不帶空格	hasNext()
02	nextLine()	獲取輸入的一行字串，支援空格，以Enter鍵結束	hasNextLine()
03	nextInt()	獲取使用者輸入的整數	hasNextInt()
04	nextFloat()	獲取使用者輸入的浮點數	hasNextFloat()

總結

Java這門語言涵蓋的知識點比較豐富，一篇文章是不可能將所有知識點都完全覆蓋到的。本文的主要目的是梳理下基礎常見的知識點，幫助大家一起復習下，學習一門語言打好基礎是至關重要的。掌握了這些基礎知識點，自己動手寫一些小程式問題也不大。文章最後再附上一個完整程式碼的小例子，實現的功能是將使用者輸入的字串逆序輸出：

class Test{  
    public static void main(String args[]) {
			Scanner scan = new Scanner(System.in);
		
			String inputStr = scan.nextLine();
		    // String轉換為char陣列
			char[] nums = inputStr.toCharArray();
		
			for (int i = nums.length; i>0; i--) {
				System.out.print(nums[i-1]);
			}
			System.out.println("");	
    }
}