###### tags: `java`,
# 113年東吳物件導向程式設計
## Teams 團隊加入連結： https://pse.is/5pj96h
## 團隊代碼：af2vn44
## 課程筆記網址：https://pse.is/5mf78f
## Teams 課程加入連結：https://pse.is/5pjafn
## Teams 會議網址：https://pse.is/5r3g57
## 課程錄影回看：
https://soochowmss-my.sharepoint.com/:v:/g/personal/89000249_mss_scu_edu_tw/Eal77hn6xLxOjI5Qr6IBy7kBfOYchZoxKXSDHD9wrDdLPA?referrer=Teams.TEAMS-ELECTRON&referrerScenario=MeetingChicletGetLink.view.view
## 2024/06/05 上課筆記
類別定義
```java=
[public] [final] class 類別名稱 [extends 父類別名稱] {
[存取修飾子] [static] [final] 資料型態 屬性名稱1 [=常數] ;
[
[存取修飾子] [static] [final] 資料型態 屬性名稱2 [=常數] ;
]
⋯
[
[public] 類別名稱() { // 無參數串列的建構子
// 程式敘述; ⋯
}
]
[
[public] 類別名稱([參數串列]) { // 有參數串列的建構子
// 程式敘述; ⋯
}
]
⋯
[存取修飾子] [static] [final] 回傳值的資料型態 方法名稱a(
[參數串列]) [throws 例外類別a1,例外類別a2,⋯] {
// 程式敘述; ⋯
}
[
[存取修飾子] [static] [final] 回傳值的資料型態 方法名稱b(
[參數串列]) [throws 例外類別b1,例外類別b2,⋯] {
// 程式敘述; ⋯
}
]
⋯
}
```
Java API: https://docs.oracle.com/javase/8/docs/api/
當你看到 public static final double PI 這一行程式碼，它是在宣告一個名為 PI 的常數，屬於某個類別或介面。讓我們逐步解析這一行程式碼中的各個關鍵字和它們的意義：
public:
public 是一個存取修飾符（access modifier），它表示這個變數可以被所有其他類別所訪問。也就是說，無論是在同一個包（package）裡還是在不同的包裡，這個變數都是可見的。
static:
static 表示這個變數是屬於類別的，而不是某個具體的物件的。換句話說，不需要創建這個類別的物件就可以訪問這個變數。這在需要共享常數或方法時特別有用。
final:
final 關鍵字表示這個變數是不可變的。一旦被初始化後，其值就不能再改變。這通常用來宣告常數。
double:
double 是一個基本資料型別，用來表示雙精度浮點數。這意味著 PI 變數將是一個雙精度的浮點數。
PI:
PI 是變數的名稱。根據命名慣例，常數名通常全部使用大寫字母，並用底線分隔詞語（如果有多個詞）。這樣做是為了清楚地表明這是個常數。
綜合起來，public static final double PI 的意思是：
宣告一個名為 PI 的變數；
這個變數是 double 型別的浮點數；
這個變數是公開的，任何類別都可以訪問它；
這個變數是靜態的，屬於類別本身，而不是某個具體的物件；
這個變數是最終的（不可變的），一旦被賦值後就不能再改變。
若「存取修飾子」為保留字「public」，則表示在任何套件的類別中，皆可存取此屬性
若「存取修飾子」為保留字「protected」，則此屬性可在所屬的類別及所屬類別的子類別中被存取，無論子類別是否在同一套件中
無「存取修飾子」，則表示此屬性只能在同一個套件的類別中被存取
若「存取修飾子」為保留字「private」，則此屬性只能在所屬的類別中被存取
## 2024/05/22 上課筆記
Java 資料型態分兩大類：
* 基本資料型態(primary data type): 又分8種資料類型
* 參考資料型態(reference data type): 除了8種基本資料類型外，其餘的都是參考資料型態。要宣告及初始化(透過 new 運算子)。
* 要判斷兩個字串變數所指向的記憶體位址是否相同，是使用「==」運算子
* 判斷兩個字串變數所指向的記憶體位址內的內容是否相同，則是使用「equals」方法
```java=
import java.util.Scanner;
public class Ex01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner keyin = new Scanner(System.in);
String str1 = new String();
String str2 = new String();
System.out.print("輸入字串變數1所指向的記憶體位址內要儲存的資料:");
str1 = keyin.nextLine();
System.out.print("輸入字串變數2所指向的記憶體位址內要儲存的資料:");
str2 = keyin.nextLine();
System.out.print("字串變數1的內容");
if (str1 == str2)
System.out.print(" = ");
else
System.out.print(" ≠ ");
System.out.println("字串變數2的內容");
System.out.print("字串變數1所指向的記憶體位址內的資料");
if (str1.equals(str2))
System.out.print(" = ");
else
System.out.print(" ≠ ");
System.out.println("字串變數2所指向的記憶體位址內的資料");
keyin.close();
}
}
```
```java=
public class Ex02 {
public static void main(String[] args) {
String name1 = new String("ABCDEFG");
String name2 = new String("ABCDEFG");
System.out.println("name1 = " + name1);
System.out.println("name2 = " + name2);
System.out.println("name1 == name2 ==>" + (name1 == name2));
System.out.println("name1.equals(name2) ==>" + name1.equals(name2));
}
}
```
```java=
String name3;
name3 = "1234567890";
String name4;
name4 = "1234567890";
System.out.println("name3 = " + name3);
System.out.println("name4 = " + name4);
System.out.println("name3 == name4 ==>" + (name3 == name4));
System.out.println("name3.equals(name4) ==>" + name3.equals(name4));
```
### java.lang.Object 是所有 Java 物件的共同父類別，也就是所有類別都是繼承 java.lang.Object 這個類別
### java.lang.* 這個套件是所有 Java 程式都會引用的套件，所以引用 java.lang.* 的類別都不需要事先 import，除此之外的類別，在使用前都需要事先引入(import)
宣告字串物件變數並初始化之語法如下：
* String 字串物件變數名稱 = new String("文字資料");
* String 字串物件變數名稱 = new String();
* String 字串物件變數名稱 = "文字資料";
* String 字串物件變數名稱 = "";
```java=
import java.util.Random;
import java.util.Calendar;
public class Ex03 {
public static void main(String[] args) {
Math x;
Math y;
//System.out.println(x.PI);
//System.out.println(y.PI);
// Math 是原生物件(native object)
System.out.println(Math.PI);
Random r = new Random();
System.out.println(r.nextInt());
System.out.println(r.nextInt());
Calendar mydate = Calendar.getInstance();
System.out.println(mydate.getTime());
}
}
```
## 2024/05/15 上課筆記
for each 語法
透過陣列初始值的設定來指定一個陣列的大小
```java=
public class Ex01 {
public static void main(String[] args) {
int[] x;
// x = new int[10];
x = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] y = new int[20];
// 列舉陣列的元素內容 - for loop
for (int i=0; i<x.length; i++)
System.out.println(x[i]);
// 列舉陣列的元素內容- for each loop
for (int e:x)
System.out.println(e);
}
}
```
```java=
public class Ex02 {
public static void main(String[] args) {
// 宣告二維陣列
int[][] x;
x = new int[3][];
x[0] = new int[2];
x[1] = new int[3];
x[2] = new int[4];
x[0] = new int[] {11, 12};
x[1] = new int[] {21, 22, 23};
x[2] = new int[] {31, 32, 33, 34};
for(int[] y:x) {
for(int z:y) {
System.out.print(z + ", ");
}
System.out.println();
}
}
}
```
在Java程式語言中，錯誤主要可以分為以下幾種類型：
1. 語法錯誤 (Syntax Errors)，又稱編譯時錯誤 (Compile-time Errors)
這些錯誤是在編譯過程中發現的，通常是由於代碼不符合語法規則而導致的。常見的語法錯誤包括：
* 缺少分號 (;)
* 圓括號、方括號或花括號不匹配
* 關鍵字拼寫錯誤
* 類或方法定義不完整
示例：
```java=
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World!") // 缺少分號
}
}
```
2. 運行時錯誤 (Runtime Errors)，又稱邏輯錯誤 (Logical Errors)或語意錯誤(Symentic Error)
這些錯誤是在程式運行時發生的，通常是由於非法操作或無法預測的情況引起的。常見的運行時錯誤包括：
* 除以零 (ArithmeticException)
* 空指針異常 (NullPointerException)
* 陣列索引越界 (ArrayIndexOutOfBoundsException)
示例：
```java=
public class Main {
public static void main(String[] args) {
int[] array = new int[5];
System.out.println(array[5]); // 陣列索引越界異常
}
}
```
我們可以利用例外處理機制，來避免因為運行時錯誤 (Runtime Errors)，導致Java程式 crash
```java=
import java.util.Scanner;
import java.lang.Math;
import java.util.InputMismatchException;
public class Ex03 {
public static void main(String[] args) {
long[] x;
Scanner keyin = new Scanner(System.in);
System.out.print("請輸入陣列的大小:");
int size = keyin.nextInt();
x = new long[size];
for(int i=0; i<x.length; i++) {
x[i] = Math.round(Math.random() * 100);
System.out.print(x[i] + ", ");
}
System.out.println();
System.out.print("請輸入陣列的索引編號:");
try {
int index = keyin.nextInt();
System.out.println(x[index]);
}
catch (InputMismatchException e) {
System.out.println("輸入錯誤，請輸入整數");
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("超出陣列的大小: " + x.length);
}
}
}
```
```java=
import java.util.Scanner;
import java.lang.Math;
import java.util.InputMismatchException;
public class Ex03 {
public static void main(String[] args) {
long[] x;
Scanner keyin = new Scanner(System.in);
System.out.print("請輸入陣列的大小:");
try {
int size = keyin.nextInt();
x = new long[size];
for(int i=0; i<x.length; i++) {
x[i] = Math.round(Math.random() * 100);
System.out.print(x[i] + ", ");
}
System.out.println();
System.out.print("請輸入陣列的索引編號:");
int index = keyin.nextInt();
System.out.println(x[index]);
}
catch (InputMismatchException e) {
System.out.println("輸入錯誤，請輸入整數");
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("超出陣列的大小");
}
}
}
```
## 2024/05/08 上課筆記
宣告一個擁有「n」個元素的一維陣列之語法如下：
資料型態[ ] 陣列名稱 = new 資料型態[n];
```java=
import java.lang.Math;
public class Ex01 {
public static void main(String[] args) {
int x; // 宣告 x 整數變數
x = 1;
int[] y = new int[10]; // 宣告 y 整數陣列，並建立 y 整數陣列擁有「n=10」個元素
double[] z; // 宣告 z 浮點數陣列，
z = new double[20]; // 建立 z 浮點數陣列擁有「n=20」個元素
x = (int)(Math.random() * 100); // (int) 是強制型態轉換成 int
System.out.println("x = " + x);
// 存取陣列的元素
y[0] = (int)(Math.random() * 100); // 陣列是以一個名稱來代表該集合，並以索引來存取對應的陣列元素
System.out.println("y[0] = " + y[0]);
y[1] = (int)(Math.random() * 100);
System.out.println("y[1] = " + y[1]);
for(int i=0; i<10; i++) { // 利用迴圈，快速產生 10 個亂數，並指定給 y 陣列
y[i] = (int)(Math.random() * 100);
System.out.println("y[" + i + "] = " + y[i]);
}
for(int i=0; i<z.length; i++) { // 利用迴圈，快速產生n個亂數，並指定給 z 陣列
z[i] = Math.random() * 100;
System.out.println("z[" + i + "] = " + z[i]);
}
}
}
```
```java=
import java.lang.Math;
public class Ex02 {
public static void main(String[] args) {
int[] y = new int[10]; // 一維陣列的宣告與建立(建立包含歸零的動作)
// int[] y;
for(int i=0; i<y.length; i++) { // 利用迴圈，快速產生 10 個亂數，並指定給 y 陣列
System.out.println("y[" + i + "] = " + y[i]);
}
int x = 0;
// int x;
System.out.println("x = " + x);
int[][]z = new int[10][20]; // 二維陣列的宣告與建立(建立包含歸零的動作)
z[0][0] = 100;
z[2][1] = 200;
for (int row=0; row<z.length; row++) {
for (int col=0; col<z[row].length; col++) {
z[row][col] = (int)(Math.random() * 100);
System.out.println("z[" + row + "][" + col + "] =" + z[row][col]);
}
}
int[][]w; // 每一列不同大小的二維陣列
w = new int[10][];
w[0] = new int[5];
w[1] = new int[6];
w[9] = new int[15];
}
}
```
```java=
import java.util.Scanner;
import java.lang.Math;
public class Ex03 {
public static void main(String[] args) {
int dynamicArray[];
int arraySize;
Scanner keyin = new Scanner(System.in);
System.out.print("請輸入陣列的大小：");
arraySize = keyin.nextInt();
dynamicArray = new int[arraySize];
for(int i=0; i<dynamicArray.length; i++) {
dynamicArray[i] = (int)(Math.random() * 100);
System.out.println(i + "=>" + dynamicArray[i]);
}
}
}
```
## 2024/04/24 上課筆記
Java Online compiler: https://www.programiz.com/java-programming/online-compiler/
```java=
int i;
for (i=0; i<=10; i++) {
System.out.println(i);
}
```
改寫成 while 迴圈。
```java=
int i = 0;
while (i <= 10) {
System.out.println(i);
i++;
}
```
請用 switch-case 語法，及最少的break寫出以下點餐程式
1號餐有薯條
2號餐有薯條和雞塊
3號餐有薯條和雞塊和可樂
4號餐有漢堡
5號餐有漢堡和玉米濃湯
```java=
import java.util.Scanner;
public class Ex01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入您要點的餐號：");
int choice = scanner.nextInt();
System.out.println("您點的餐品包括：");
switch (choice) {
case 5:
System.out.println("玉米濃湯");
case 4:
System.out.println("漢堡");
break;
case 3:
System.out.println("可樂");
case 2:
System.out.println("雞塊");
case 1:
System.out.println("薯條");
break;
default:
System.out.println("抱歉，您輸入的餐號不存在！");
break;
}
}
}
```
輸入收縮壓與舒張壓後，依據以下條件，輸出相對應的訊息。
你需要宣告兩個變數：
收縮壓 systolic
舒張壓 diastolic
收縮壓＞＝210 mmHg 且 舒張壓 ＞＝120 mmHg 則輸出「極重度高血壓」！
收縮壓180~209 mmHg 且 舒張壓110~119 mmHg 則輸出「重度高血壓」！
收縮壓160~179 mmHg 且 舒張壓100~109 mmHg 則輸出「中度高血壓」！
收縮壓140~159 mmHg 且 舒張壓90~99 mmHg 則輸出「輕度高血壓」！
收縮壓130~139 mmHg 且 舒張壓85~89 mmHg 則輸出「正常但偏高之血壓」！
收縮壓＜130 mmHg 且 舒張壓＜85 mmHg 則輸出「正常血壓」！
以上條件都不滿足時，則輸出「無法判斷」
```java=
import java.util.Scanner;
public class Ex02 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入收縮壓(mmHg)：");
int systolic = scanner.nextInt();
System.out.println("請輸入舒張壓(mmHg)：");
int diastolic = scanner.nextInt();
if (systolic >= 210 && diastolic >= 120) {
System.out.println("極重度高血壓！");
} else if (systolic >= 180 && systolic <= 209 && diastolic >= 110 && diastolic <= 119) {
System.out.println("重度高血壓！");
} else if (systolic >= 160 && systolic <= 179 && diastolic >= 100 && diastolic <= 109) {
System.out.println("中度高血壓！");
} else if (systolic >= 140 && systolic <= 159 && diastolic >= 90 && diastolic <= 99) {
System.out.println("輕度高血壓！");
} else if (systolic >= 130 && systolic <= 139 && diastolic >= 85 && diastolic <= 89) {
System.out.println("正常但偏高之血壓！");
} else if (systolic < 130 && diastolic < 85) {
System.out.println("正常血壓！");
} else {
System.out.println("無法判斷！");
}
}
```
```java=
import java.util.Scanner;
public class Ex03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
double FV, PV, R;
int n=0;
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入利率：");
R = scanner.nextDouble();
PV = 1.0;
do {
FV = PV * (1 + R);
PV = FV;
n++;
} while (FV < 2);
System.out.println(n + " 期後，本利合為 " + FV + " 元.");
}
}
```
## 2024/04/17 上課筆記
==請簡述電腦程式語言分成那三大類，Java程式語言屬於哪一類？==
參考答案一：
電腦程式語言通常可以分為三大類：**低階語言、高階語言和組合語言**。
* 低階語言：這些語言更接近電腦硬體的語言，例如機器語言和組合語言。它們直接與電腦硬體交互作用，對硬體的控制更直接。這類語言通常用於系統程式設計和硬體驅動開發。
* 高階語言：這些語言更接近自然語言，更易於理解和使用。它們提供了更高的抽象層次，使得開發人員可以更容易地撰寫複雜的程式碼，而不需要深入了解電腦硬體的細節。高階語言通常用於應用程式開發、網頁開發等領域。
* 組合語言：這些語言介於低階語言和高階語言之間，提供了一些直接控制硬體的能力，同時也具有一定程度的抽象性。它們通常用於系統程式設計和性能優化。
Java程式語言屬於高階語言，它具有高度的跨平台性、物件導向特性和強大的應用程式開發功能，被廣泛應用於企業級應用程式開發、網頁應用程式開發、手機應用程式開發等領域。
參考答案二：
電腦程式語言的編譯方式通常可以分為三大類：**編譯型語言、解釋型語言和即時編譯型語言。**
* 編譯型語言：這種語言的程式碼在執行前會先被完全編譯成目標機器碼，並且編譯後的執行檔可以在沒有編譯器的情況下直接運行。編譯型語言的程式碼在運行時執行效能較高，但在跨平台性上較差，因為編譯後的執行檔通常是與特定平台相關的。C、C++等語言屬於編譯型語言。
* 解釋型語言：這種語言的程式碼在運行時逐行解釋並執行，通常需要一個解釋器或者運行時環境來執行程式。解釋型語言的程式碼具有良好的跨平台性，但執行效能通常較編譯型語言低。Python、JavaScript等語言屬於解釋型語言。
* 即時編譯型語言：這種語言的程式碼在執行時會被即時編譯成目標機器碼，並且生成的機器碼會直接被處理器執行。即時編譯型語言結合了編譯型語言和解釋型語言的特點，具有較好的執行效能和跨平台性。Java是一種即時編譯型語言，它的程式碼會被編譯成稱為Java虛擬機碼（bytecode）的中間碼，然後在Java虛擬機上運行。
==程式從撰寫階段到執行階段，可能產生的錯誤有哪兩種？哪一種是Eclipse 可以幫你檢查的？==
在程式從撰寫階段到執行階段，可能產生的錯誤可以分為兩大類：
* 編譯時錯誤（Compile-time errors）：這類錯誤發生在程式碼編譯的階段，通常是因為語法錯誤、類型錯誤或者符號錯誤等導致的。如果程式碼存在編譯時錯誤，編譯器會無法將程式碼轉換成可執行的機器碼或者中間碼，並且會提示相關的錯誤訊息。
* 執行時錯誤（Runtime errors）：這類錯誤發生在程式碼執行的階段，通常是因為程式碼邏輯錯誤、資源不足、外部資料異常等導致的。執行時錯誤會在程式執行時觸發，可能導致程式崩潰或者產生意外的行為。
**Eclipse可以幫你檢查的是編譯時錯誤（Compile-time errors）**。當你在Eclipse中編寫程式碼時，它會即時檢查你的程式碼是否存在語法錯誤、類型錯誤等編譯時錯誤，並且在發現錯誤時會在編輯器中提示相關的錯誤訊息，讓你可以及時進行修正。這樣可以在程式執行之前就發現並解決潛在的問題，提高程式碼的品質和可靠性。
==請簡述使用 Eclipse IDE 開發 Java 程式專案的步驟主要兩個步驟，假設你的專案名稱是 Ex20240417，其中有一個類別(class) Ex01==
在Eclipse IDE中開發Java程式專案的主要步驟如下：
1.建立Java專案：
打開Eclipse IDE並進入工作區。
選擇「File（檔案）」菜單，然後選擇「New（新建）」，再選擇「Java Project（Java專案）」。
在彈出的視窗中輸入專案名稱，例如「Ex20240417」，然後按下「Finish（完成）」按鈕。這樣就建立了一個名為「Ex20240417」的Java專案。
2.建立類別（class）：
在專案檢視（Package Explorer）中，右鍵點擊剛剛建立的專案「Ex20240417」，選擇「New（新建）」，再選擇「Class（類別）」。
在彈出的視窗中，輸入類別名稱，例如「Ex01」，然後按下「Finish（完成）」按鈕。這樣就建立了名為「Ex01」的類別。
完成以上兩個步驟後，就可以在「Ex01」類別中開始撰寫Java程式碼了。
==請簡述 Java 程式語言的基本資料型別分哪幾類？說明每一類的變數宣告時，所使用的關鍵字，以及數值如何指定給該變數（請整理在表格內）==
在Java程式語言中，基本資料型別可以分為以下幾類：
* 整數型別（Integer types）
* 浮點數型別（Floating-point types）
* 字元型別（Character types）
* 布林型別（Boolean type）
下表總結了每個基本資料型別、變數宣告所使用的關鍵字以及如何指定數值給該變數：
==請簡述 Java 的註解符號分哪三類？假設有一段註解文字內容是 "將西元年轉換民國年"，請使用這三類註解符號來表示==
在Java中，註解符號通常分為三類：
**單行註解：**以雙斜線（//）開始，直到該行的結束。單行註解通常用於對程式碼的某一行或某一段進行簡短的說明或解釋。
java
Copy code
// 將西元年轉換民國年
* **多行註解：**以斜線星號（/）開始，以星號斜線（/）結束。多行註解可以跨越多行，用於對較長的程式碼塊進行詳細的說明或解釋。
java
Copy code
/*
將西元年轉換民國年
這是一段多行註解的範例
*/
**文件註解（Javadoc 註解）：** 以斜線星號兩個星號（/\*\*）開始，以星號斜線（*/）結束。文件註解通常用於對類、方法、變數等進行詳細的說明，並且可以被Javadoc工具解析成HTML格式的文件。
java
Copy code
/**
* 將西元年轉換民國年
* 這是一個Javadoc註解的範例
*/
這三類註解符號在Java程式中扮演著不同的角色，可以幫助程式開發者更好地理解和維護程式碼。
### 例外處理
```=java
import java.util.Scanner;
import java.util.InputMismatchException;
public class Ex01 {
public static void main(String[] args) {
Scanner keyin = new Scanner(System.in);
int x;
System.out.println("請輸入一個整數：");
try {
x = keyin.nextInt();
System.out.println("輸出：" + x);
}
catch (InputMismatchException e)
{
System.out.println("警告：你輸入的不是整數！");
}
}
}
```
```java=
import java.util.Scanner;
import java.util.InputMismatchException;
import java.lang.Exception;
public class Ex01 {
public static void main(String[] args) {
Scanner keyin = new Scanner(System.in);
int x, y;
double z;
try {
System.out.println("請輸入第一個整數 x：");
x = keyin.nextInt();
System.out.println("x：" + x);
System.out.println("請輸入第二個整數 y：");
y = keyin.nextInt();
System.out.println("y：" + y);
z = x / y;
System.out.println("x / y：" + z);
}
catch (InputMismatchException e)
{
System.out.println("警告：你輸入的不是整數！");
}
catch (ArithmeticException e) {
System.out.println("警告：y 不得為 0！");
}
catch (Exception e) {
System.out.println("警告：發生不明意外！");
}
}
}
```
## 2024/03/27 上課筆記
看不到專案總管視窗的解決方式
寫 Java 程式就是 New 一個 class (類別檔)
如何查詢 .java 程式的檔案路徑(path)
認識 if else 條件式
認識 while 迴圈
認識 java.lang.Math 原生類別
認識產生隨機數 Math.random()
```java=
import java.util.Scanner;
import java.lang.Math;
public class Ex02 {
public static void main(String[] args) {
Scanner keyin = new Scanner(System.in);
int num;
double ans = Math.random();
System.out.println("隨機數" + ans);
int ans2 = (int)(ans * 10 + 1);
System.out.println("隨機數" + ans2);
System.out.print("請猜一個數:(1~10)");
num = keyin.nextInt();
System.out.println(num);
while (true) {
if (ans2 == num) {
System.out.println("答對");
break;
}
else {
System.out.println("答錯");
System.out.println("再試一次");
System.out.print("請再猜一個數:(1~10)");
num = keyin.nextInt();
System.out.println(num);
}
}
}
}
```
## 2024/03/20 上課筆記
認識長整數的 L 與 浮點數的 F
```java=
public class Ex01 {
public static void main(String[] args) {
// int x;
// x = 8;
long x = 8L;
System.out.println(x);
// double pi = 3.14;
float pi = 3.14F;
System.out.println(pi);
}
}
```
認識 Java 的輸入物件 java.util.Scanner
```java=
import java.util.Scanner;
public class Ex02 {
public static void main(String[] args) {
Scanner keyin;
keyin = new Scanner(System.in);
System.out.print("請輸入長度:");
int length;
length = keyin.nextInt();
System.out.println(length);
System.out.print("請輸入寬度:");
int width;
width = keyin.nextInt();
System.out.println(width);
}
}
```
認識 Java 的四則運算：運算符號、運算符號的優先權
```java=
import java.util.Scanner;
public class Ex02 {
public static void main(String[] args) {
Scanner keyin;
keyin = new Scanner(System.in);
System.out.print("請輸入長度:");
int length;
length = keyin.nextInt();
System.out.println(length);
System.out.print("請輸入寬度:");
int width;
width = keyin.nextInt();
System.out.println(width);
int total_length, area;
// total_length = length + length + width + width;
// total_length = length * 2 + width * 2;
total_length = (length + width) * 2;
System.out.println("四邊總長度:" + total_length);
area = length * width;
System.out.print("面積:" + area);
}
}
```
認識Java 基本變數型態的強制轉換
```java=
import java.util.Scanner;
public class Ex02 {
public static void main(String[] args) {
Scanner keyin;
keyin = new Scanner(System.in);
System.out.print("請輸入長度:");
int length;
length = keyin.nextInt();
System.out.println(length);
System.out.print("請輸入寬度:");
int width;
width = keyin.nextInt();
System.out.println(width);
int total_length, area;
// total_length = length + length + width + width;
// total_length = length * 2 + width * 2;
total_length = (length + width) * 2;
System.out.println("四邊總長度:" + total_length);
area = length * width;
System.out.println("面積:" + area);
//int ratio;
double ratio;
// ratio = length / width;
ratio = (double)length / (double)width;
System.out.println("長寬比例:" + ratio);
}
}
```
認識 Java 的各種變數型態的輸入方法：nextInt(), nextDouble() 等
```java=
import java.util.Scanner;
public class Ex03 {
public static void main(String[] args) {
Scanner keyin;
keyin = new Scanner(System.in);
System.out.print("請輸入長度:");
double length;
length = keyin.nextDouble();
System.out.println(length);
}
}
```
ChatGPT 的摘要
:::success
在這堂Java物件導向程式語言課程中，我們討論了幾個重要的概念：
Java程式的彈性和嚴謹性： 我們探討了Java程式語言的彈性和嚴謹性。與一些其他語言相比，Java在排版方面更加嚴格，但也更具彈性。程式碼的排版與縮排不會直接影響程式碼的運行，但是正確的排版能夠提高程式碼的可讀性和可維護性。
錯誤處理和排除： 我們強調了在程式設計中的錯誤處理和排除的重要性。即使程式碼能夠正確運行，但如果沒有處理好潛在的錯誤，仍然可能產生意外的結果。學生需要學會如何有效地處理各種可能的錯誤情況，以確保程式的穩定性和可靠性。
資料型別的準確性： 我們強調了在Java中資料型別的準確性。Java是一種靜態型別語言，因此在聲明變數或方法時，必須明確指定其資料型別。錯誤地使用了不正確的資料型別可能導致程式錯誤或不可預測的行為。
使用者輸入的處理： 我們討論了如何處理使用者輸入。在編寫程式時，必須考慮到各種不同的使用者輸入情況，並採取適當的措施來處理這些輸入，以確保程式的正確性和安全性。在這方面，我們特別強調了對於使用者輸入的驗證和轉換，以確保它們符合程式的要求。
總的來說，這堂課程強調了在Java程式設計中的彈性和嚴謹性，以及對於錯誤處理、資料型別準確性和使用者輸入的重視。通過這些概念的學習和理解，學生可以寫出更加穩健和可靠的Java程式。
:::
## 2024/03/13 上課筆記
認識整數與浮點數的變數宣告與值的設定
```java=
public static void main(String[] args) {
// TODO Auto-generated method stub
int x, y;
x = 10;
System.out.println(x);
y = 5;
System.out.println(y);
// int z;
double z, pi;
z = 20.0;
System.out.println(z);
pi = 3.14;
System.out.println(pi);
}
```
變數的值必須與變數的型態相容
變數在同一個區塊內不可以重複宣告
Java 程式碼的註解有三種：
```java=
單行註解: //
多行註解: /* ..
..
.. */
文件註解: /** ..
..
.. */
```
Java 的整數有分4種
| type | size(記憶體空間) |
| ------ | ------ |
| byte | 1 byte |
| short | 2 byte |
| int | 4 byte |
| long | 8 byte(位元組) |
以下是使用Markdown語法列出Java支援的所有整數型態的型態名稱、記憶體空間大小、最小整數和最大整數：
| 整數型態 | 記憶體空間大小 | 最小整數 | 最大整數 |
|----------|----------------|---------|---------|
| byte | 8位元(bit) | -128 | 127 |
| short | 16位元 | -32,768 | 32,767 |
| int | 32位元 | -2,147,483,648 | 2,147,483,647 |
| long | 64位元 | -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807 |
這些是Java的基本整數數據類型，它們在內存中所佔空間大小和範圍是固定的。
請注意，Java中的浮點數型態（如float和double）不是整數型態，因此沒有最小整數和最大整數的概念。但是，我可以列出Java支援的所有浮點數型態的型態名稱和記憶體空間大小：
| 浮點數型態 | 記憶體空間大小 |
|------------|----------------|
| float | 32位元(bit) |
| double | 64位元(bit) |
這些是Java中的基本浮點數數據類型，它們用於存儲帶有小數的數字。浮點數型態具有不同的精度和範圍，但與整數型態不同，它們可以表示小數和大數。
```java=
public class Ex01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int x, y;
x = 10;
System.out.println(x);
y = 5;
System.out.println(y);
// int z;
double z, pi;
z = 20.0;
System.out.println(z);
pi = 3.14;
System.out.println(pi);
//int money;
long money;
//money = 10000000000;
/* 註解 */
/** 註解 */
money = 10000000000L;
System.out.println(money);
//int maxInt, minInt;
long maxInt, minInt;
/*
minInt = -2147483648;
maxInt = 2147483647;
*/
minInt = -2147483648L-1;
maxInt = 2147483647L+1;
System.out.println(minInt);
System.out.println(maxInt);
}
public static void test() {
int z;
z = 20;
System.out.println(z);
}
}
```
## 2024/03/06 上課筆記
https://meet.google.com/qto-hgen-piu
## 講解如何應用生成式AI(ChatGPT, Microsoft Copilot)輔助自學
https://chat.openai.com/share/683536a8-62b2-46ea-b602-c45d31bea5d3
Prompt: 你是一位Java程式語言的講師，請以Java提供的資料型態作介紹
Prompt: 你是一位Java程式語言的講師，請以上述回答的內容做命題，給我兩題選擇題，每一題有四個選項
## 介紹 Java IDE - Eclipse 的操作
重新回復 Eclipse 視窗的佈置
## 介紹在 Eclipse 下如何新增一個新的 Java 專案
## 新增 Java Class 檔(Java 類別檔)的方式
## 認識 Eclipse 預設的編碼 - UTF8
## 設計你的第一個 "Hello World" Java 程式
請copy以下程式碼到你的程式視窗中
```java=
System.out.println("歡迎您來到Java的世界!");
```
## 放大/縮小程式碼視窗的文字
```java=
byte myByte = 127;
short myShort = 32000;
int myInt = 2000000;
long myLong = 123456789012345L; // 注意：long型態需加上L或l表示。
```
```java=
System.out.println(myByte);
System.out.println(myShort);
System.out.println(myInt);
System.out.println(myLong);
```
---
## 2024/02/21 上課筆記
# 課程筆記網址：https://pse.is/5mf78f
# https://hackmd.io/qS62SXTgQLaLL9HgZnNDXg?view
# 在Eclipse下開啟一個新的Java專案
## 程式語言排行榜
https://www.techrepublic.com/article/tiobe-index-language-rankings/
教科書的範例程式碼載點：https://tinyurl.com/ye5emsyv
(檔案解壓縮密碼：0634902)
## 第一個 Java 練習程式
```java=
public class Ex01 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Hello World!");
}
}
```
## JDK Windows 下載
https://www.oracle.com/tw/java/technologies/downloads/#jdk21-windows
Sign in with Wallet
Connect another wallet