`public class EnumTest {
public static void main(String[] args) {
Size s=Size.SMALL;
Size t=Size.LARGE;
//s和t引用同一個物件？
System.out.println(s==t); //
//是原始資料型別嗎？
System.out.println(s.getClass().isPrimitive());
//從字串中轉換
Size u=Size.valueOf("SMALL");
System.out.println(s==u); //true
//列出它的所有值
for(Size value:Size.values()){
System.out.println(value);
}
}
}
enum Size{SMALL,MEDIUM,LARGE};`
執行結果：
結論：列舉不屬於原始資料型別，它的每個具體值都引用一個特定的物件。相同的值則引用同一個物件。
可以使用“”和equals()方法直接比對列舉變數的值，換句話說，對於列舉型別的變數，“”和equals()方法執行的結果是等價的。
2.
一、什麼是補碼
計算機中的有符號數有三種表示方法，即原碼、反碼和補碼。三種表示方法均有符號位和數值位兩部分，符號位都是用0表示“正”，用1表示“負”，而數值位，三種表示方法各不相同 。
在計算機系統中，數值一律用補碼來表示和儲存。它的定義如下：
對於一個n位二進位制數，如果它為正數，他的補碼等於原碼本身，如果它為負數，它的補碼為將這個數除符號位以外的所有位取反（0變成1，1變成0），然後加1所得到的結果。
例如，對於一個8位的二進位制數10011010，它的補碼為11100101 + 1 = 11100110。
其中11100101是10011010除第一位符號位以外的所有位取反得到的。
補碼有以下幾個特點：
補碼能夠表示正數和負數，而且在計算機中，通常只採用補碼進行運算。
正數的補碼與原碼相同，而負數則採用補碼錶示。
在補碼中，一個數的絕對值與它的反碼相同。
二、什麼是反碼
反碼是另一種用來表示負數的二進位制數的方法。它的定義如下：
對於一個n位二進位制數，如果它是負數，則它的反碼為將這個數的所有位取反（0變成1，1變成0）所得到的結果；如果它是非負數，則它的反碼與原碼相同。
例如，對於一個8位的二進位制數（第一位為符號位）10011010，它的反碼為11100101。
反碼有以下幾個特點：
反碼能夠表示整數和負數，但在計算機中並不常用。
在反碼中，一個數的絕對值與它的補碼相同。
三、原碼與補碼之間的轉換
對於一個原碼，可以將它轉換成補碼，然後再進行運算。轉換的方法如下：
如果原碼為正數，則它的補碼與原碼相同。
如果原碼為負數，則將原碼的絕對值轉換成二進位制數，然後將這個二進位制數除符號位外的所有位取反，最後加1，得到的結果即為它的補碼。
例如，將-6轉換成補碼的過程如下：
將-6轉換成二進位制數：10000110。
將-6的二進位制數除符號位的所有位取反：11111001。
將取反後的結果加1：11111010，這就是-6的補碼。
四、補碼與原碼之間的轉換
補碼和原碼之間的轉換也是十分重要的。當我們需要將補碼轉換成原碼時，可以按照以下步驟進行：
如果補碼的最高位是1，說明這個補碼所代表的數是負數。將補碼除符號位外的所有位取反（0變成1，1變成0），得到反碼。
在反碼的基礎上，將所有位加1，得到原碼。
例如，將補碼11100111轉換成原碼的過程如下：
最高位是1，說明這是一個負數。將補碼除符號位外的所有位取反得到反碼：10011000。
在反碼的基礎上，將所有位加1，得到原碼：10011001，即-25。
當需要將原碼轉換成補碼時，也可以按照以上步驟進行，反向轉換即可。
public class BitwiseOperations {
public static void main(String[] args) {
int a = 5; // 0000 0101
int b = -5; // 1111 1011
System.out.println("正數: " + a);
System.out.println("負數: " + b);
// 位與操作
System.out.println("位與操作 (a & b): " + (a & b)); // 0000 0001
// 位或操作
System.out.println("位或操作 (a | b): " + (a | b)); // 1111 1111
// 位異或操作
System.out.println("位異或操作 (a ^ b): " + (a ^ b)); // 1111 1010
// 位取反操作
System.out.println("位取反操作 (~a): " + (~a)); // 1111 1010
System.out.println("位取反操作 (~b): " + (~b)); // 0000 0100
// 左移操作
System.out.println("左移操作 (a << 1): " + (a << 1)); // 0000 1010
System.out.println("左移操作 (b << 1): " + (b << 1)); // 1111 0110
// 右移操作
System.out.println("右移操作 (a >> 1): " + (a >> 1)); // 0000 0010
System.out.println("右移操作 (b >> 1): " + (b >> 1)); // 1111 1101
// 無符號右移操作
System.out.println("無符號右移操作 (b >>> 1): " + (b >>> 1)); // 0111 1101
}
}
執行結果：
3.
同名變數的遮蔽原則
同名變數的遮蔽原則是 Java 程式設計中的一個重要概念，指的是在不同作用域中可以定義同名變數，而區域性作用域中的變數會遮蔽外層作用域中的同名變數。具體來說：
作用域：變數的可見範圍。Java 的作用域包括類級別、方法級別和塊級作用域。
遮蔽：當區域性變數（如方法內或塊內定義的變數）與外層作用域的同名變數存在時，區域性變數會優先被訪問。
示例程式碼
public class ShadowingExample {
static int value = 10; // 類級別變數
public static void main(String[] args) {
int value = 20; // 方法級別變數
System.out.println("在 main 方法中，value = " + value); // 輸出 20
testMethod(); // 呼叫另一個方法
}
public static void testMethod() {
int value = 30; // 塊級作用域變數
System.out.println("在 testMethod 方法中，value = " + value); // 輸出 30
// 訪問類級別變數
System.out.println("在 testMethod 方法中，類級別的 value = " + ShadowingExample.value); // 輸出 10
}
}
輸出結果
在 main 方法中，value = 20
在 testMethod 方法中，value = 30
在 testMethod 方法中，類級別的 value = 10
總結
在 main 方法中定義的 value 遮蔽了類級別的 value，所以輸出的是 20。
在 testMethod 中又定義了一個 value，遮蔽了 testMethod 外層的 value，輸出 30。
如果需要訪問被遮蔽的變數，可以透過類名來引用（如 ShadowingExample.value）。
測試所給結果發現，輸出順序按照就近原則，先在本方法內查詢，如果沒有，去到本類中查詢，如果也沒有，再去到上一級的介面或者父類中查詢。
4.
一. 浮點數表示
Java 中的浮點數（float 和 double）是近似值，並不能精確表示所有小數。例如：
public class PrecisionLoss {
public static void main(String[] args) {
double a = 0.1;
double b = 0.2;
double sum = a + b; // 期望結果是 0.3
System.out.println("Sum: " + sum); // 可能輸出 0.30000000000000004
}
}
二. 整數溢位
當整數計算結果超出其型別範圍時，會導致溢位。例如：
public class IntegerOverflow {
public static void main(String[] args) {
int maxInt = Integer.MAX_VALUE;
int result = maxInt + 1; // 期望結果是 Integer.MIN_VALUE
System.out.println("Result: " + result); // 可能輸出 -2147483648
}
}
三. 型別轉換
在將浮點數轉換為整數時，小數部分會被截斷，可能導致資料損失。例如：
public class TypeConversion {
public static void main(String[] args) {
double value = 5.99;
int intValue = (int) value; // 小數部分被丟棄
System.out.println("Converted Value: " + intValue); // 輸出 5
}
}
四. 使用 BigDecimal 解決精度問題
為了處理浮點數的精度問題，可以使用 BigDecimal 類，它提供高精度的計算。示例：
import java.math.BigDecimal;
public class BigDecimalExample {
public static void main(String[] args) {
BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
BigDecimal sum = a.add(b);
System.out.println("Sum: " + sum); // 輸出 0.3
}
}
5.
public class Main {
public static void main(String[] args) {
int X=100;
int Y=200;
System.out.println("X+Y="+X+Y);
System.out.println(X+Y+"=X+Y");
}
}
執行結果：
結論：
第一行 System.out.println("x+y=" + x + y);
首先，"x+y=" 是一個字串。
然後，Java 會執行字串與整數的連線。此時會先計算 "x+y=" + x，結果是 "x+y=100"。
接著，再將這個結果與 y 進行連線，最終結果是 "x+y=100200"。
第二行 System.out.println(x + y + "=x+y");
這裡 x + y 會先被計算，因為整數的加法優先於字串連線。
x + y 的結果是 300。
然後，再將 300 與 "=x+y" 進行連線，最終結果是 "300=x+y"。
6.
隨機出題程式碼
import java.util.Random;
public class Main {
public static void main(String[] args) {
Random random = new Random();
for(int i=0;i<30;i++){
int num1 = random.nextInt(101)+1;
int num2 = random.nextInt(101)+1;
int change = random.nextInt(5)+1;
if(change1){
System.out.println(num1+"+"+num2+"=");
}
else if(change2){
System.out.println(num1+"-"+num2+"=");
}
else if(change3){
System.out.println(num1+"*"+num2+"=");
}
else if(change4){
System.out.println(num1+"/"+num2+"=");
}
}
}
}
使用 java.util.Random 類
Random 類提供了多種方法用於生成不同型別和範圍的隨機數。