1. C#語言基礎

1.1 C#語法概覽

歡迎來到C#的世界！對于剛從Java轉過來的開發者來說，你會發現C#和Java有很多相似之處，但C#也有其獨特的魅力和強大之處。讓我們一起來探索C#的基本語法，并比較一下與Java的異同。

程序結構

C#程序的基本結構與Java非常相似。這里是一個簡單的C#程序：

using System;namespace HelloWorld
{class Program{static void Main(string[] args){Console.WriteLine("Hello, World!");}}
}

對比Java的版本：

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

你會發現，兩者的結構非常相似。主要的區別在于：

1. C#使用using關鍵字導入命名空間，而Java使用import。
2. C#的Main方法是static void Main(string[] args)，而Java是public static void main(String[] args)。
3. C#使用Console.WriteLine()輸出，Java使用System.out.println()。

在c# 9的最新語法上還可以更簡潔，是的沒錯，只需要一行代碼，不需要寫命名空間，類，方法，直接編寫代碼，當然這個方式只存在c#9以上的版本。

Console.WriteLine("Hello, World!");

命名約定

C#和Java的命名約定有些許不同：

• C#中，方法名和屬性名通常使用PascalCase（如CalculateTotal）。
• 局部變量和參數使用camelCase（如totalAmount）。
• 接口名稱以"I"開頭（如IDisposable）。

而Java中：

• 方法名和變量名都使用camelCase。
• 接口名稱不需要特殊前綴。

數據類型

C#和Java的基本數據類型很相似，但也有一些區別：

C#:

int x = 10;
long y = 100L;
float f = 3.14f;
double d = 3.14;
decimal m = 100.50m;
bool isTrue = true;
char c = 'A';
string s = "Hello";

Java:

int x = 10;
long y = 100L;
float f = 3.14f;
double d = 3.14;
boolean isTrue = true;
char c = 'A';
String s = "Hello";

注意C#特有的decimal類型，它提供了更高精度的小數計算，特別適合金融相關的應用。

數組

C#和Java的數組聲明稍有不同：

C#:

int[] numbers = new int[5];
string[] names = { "Alice", "Bob", "Charlie" };

Java:

int[] numbers = new int[5];
String[] names = { "Alice", "Bob", "Charlie" };

控制結構

C#和Java的控制結構幾乎完全相同：

// if語句
if (condition)
{// code
}
else if (anotherCondition)
{// code
}
else
{// code
}// for循環
for (int i = 0; i < 10; i++)
{// code
}// while循環
while (condition)
{// code
}// switch語句
switch (variable)
{case value1:// codebreak;case value2:// codebreak;default:// codebreak;
}

這些結構在Java中的寫法完全相同。

異常處理

C#和Java的異常處理也非常相似：

C#:

try
{// 可能拋出異常的代碼
}
catch (SpecificException ex)
{// 處理特定異常
}
catch (Exception ex)
{// 處理一般異常
}
finally
{// 總是要執行的代碼
}

Java的異常處理結構完全相同。

注釋

C#和Java的注釋方式也是一樣的：

// 這是單行注釋/*
* 這是多行注釋
*//// <summary>
/// 這是XML文檔注釋，類似于Java的Javadoc
/// </summary>

小結

通過這個概覽，你可以看到C#和Java在語法上有很多相似之處。這意味著作為一個Java開發者，你可以相對輕松地過渡到C#。然而，C#也有其獨特的特性和語法糖，使得某些任務更加簡潔和高效。

在接下來的章節中，我們將深入探討C#的各個方面，包括它獨特的特性如屬性、事件、委托等。這些概念可能對Java開發者來說比較新，但它們是C#強大功能的關鍵所在。記住，學習一門新的語言不僅是學習語法，更是學習一種新的思維方式。讓我們繼續我們的C#學習之旅吧！

1.2 變量和數據類型

在C#中，變量和數據類型是編程的基礎。對于從Java轉過來的開發者來說，你會發現很多熟悉的概念，但C#也有一些獨特的特性。讓我們深入探討C#的變量和數據類型，并與Java進行比較。

變量聲明

C#和Java的變量聲明方式非常相似：

C#:

int age = 25;
string name = "Alice";
bool isStudent = true;

Java:

int age = 25;
String name = "Alice";
boolean isStudent = true;

主要區別在于：

1. C#使用string（小寫），而Java使用String（大寫）。
2. C#使用bool，而Java使用boolean。

基本數據類型

C#和Java都有類似的基本數據類型，但C#提供了更多的選擇：

注意C#提供了無符號整數類型（byte, ushort, uint, ulong）和decimal類型，這些在Java中是沒有的。

值類型和引用類型

C#和Java都區分值類型和引用類型，但C#的處理更加靈活：

1. 值類型（Value Types）：

   • 在C#中，所有的基本數據類型（int, float, bool等）和struct都是值類型。
   • 值類型直接存儲它們的數據。

2. 引用類型（Reference Types）：

   • 類（class）、接口（interface）、委托（delegate）和數組（array）是引用類型。
   • 引用類型存儲對其數據（對象）的引用。

C#獨特之處：

• C#允許使用struct關鍵字創建自定義值類型。
• C#的string雖然是引用類型，但具有值類型的一些特性（如不可變性）。

可空類型

C#引入了可空類型的概念，這在Java中是沒有的：

int? nullableInt = null;
bool? nullableBool = null;

可空類型允許值類型也可以賦值為null，這在處理數據庫或用戶輸入時非常有用。

var關鍵字

C#提供了var關鍵字用于隱式類型聲明：

var x = 10; // 編譯器推斷x為int類型
var name = "Alice"; // 編譯器推斷name為string類型

Java從Java 10開始引入了類似的var關鍵字，但使用范圍更受限制。

常量

C#使用const關鍵字聲明常量：

const int MaxValue = 100;
const string AppName = "MyApp";

Java使用final關鍵字：

final int MAX_VALUE = 100;
final String APP_NAME = "MyApp";

枚舉

C#和Java都支持枚舉，但C#的枚舉更加靈活：

C#:

enum Days
{Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday
}// 可以指定底層類型和值
enum Status : byte
{Active = 1,Inactive = 0,Suspended = 2
}

Java:

enum Days {MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY
}

C#的枚舉可以指定底層類型，而Java的枚舉實際上是特殊的類。

類型轉換

C#提供了多種類型轉換方法：

1. 隱式轉換：

   int x = 10;
   long y = x; // 隱式轉換，不需要顯式轉換
   

2. 顯式轉換（強制類型轉換）：

   doubled = 3.14;
   int i = (int)d; // 顯式轉換，可能會損失精度
   

3. 使用Convert類：

   string s = "123";
   int i = Convert.ToInt32(s);
   

4. 使用Parse方法：

   string s = "3.14";
   double d = double.Parse(s);
   

5. TryParse方法（安全轉換）：

   string s = "123";
   int result;
   if (int.TryParse(s, out result))
   {Console.WriteLine($"Converted value: {result}");
   }
   else
   {Console.WriteLine("Conversion failed");
   }
   

Java的類型轉換相對簡單一些，主要依賴于強制類型轉換和包裝類的方法。

小結

雖然C#和Java在變量和數據類型方面有很多相似之處，但C#提供了更多的選擇和靈活性。C#的可空類型、更豐富的基本數據類型、更靈活的枚舉和方便的類型轉換方法，都為開發者提供了更多的工具來處理各種數據場景。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以讓你的代碼更加簡潔和表達力更強。在實際編程中，合理利用這些特性可以提高代碼的可讀性和性能。

在接下來的學習中，我們將深入探討C#的更多高級特性，如屬性、索引器、泛型等。這些概念將進一步展示C#相對于Java的獨特優勢。繼續保持學習的熱情，你會發現C#是一個功能豐富、富有表現力的語言！

1.3 運算符和表達式

C#的運算符和表達式與Java有很多相似之處，但也有一些獨特的特性。讓我們深入了解C#的運算符和表達式，并與Java進行比較。

算術運算符

C#和Java的算術運算符基本相同：

• 加法 (+)
• 減法 (-)
• 乘法 (*)
• 除法 (/)
• 取模 (%)

示例：

int a = 10, b = 3;
int sum = a + b;      // 13
int difference = a - b; // 7
int product = a * b;   // 30
int quotient = a / b;  // 3 (整數除法)
int remainder = a % b; // 1

注意：C#和Java在整數除法時都會舍去小數部分，如果要得到精確結果，至少有一個操作數應該是浮點數。

賦值運算符

C#和Java的賦值運算符也基本相同：

• 簡單賦值 (=)
• 復合賦值 (+=, -=, *=, /=, %=)

C#特有的復合賦值運算符：

• ??= (空合并賦值運算符，C# 8.0引入)

示例：

int x = 5;
x += 3;  // 等同于 x = x + 3
x -= 2;  // 等同于 x = x - 2string name = null;
name ??= "John";  // 如果name為null，賦值為"John"

比較運算符

C#和Java的比較運算符完全相同：

• 等于 (==)
• 不等于 (!=)
• 大于 (>)
• 小于 (<)
• 大于等于 (>=)
• 小于等于 (<=)

示例：

int a = 5, b = 7;
bool isEqual = (a == b);// false
bool isNotEqual = (a !=b); // true
bool isGreater = (a > b);// false
bool isLess = (a < b);     // true
bool isGreaterOrEqual = (a >= b); // false
bool isLessOrEqual = (a <= b);// true

邏輯運算符

C#和Java的邏輯運算符也是相同的：

• 邏輯與 (&&)
• 邏輯或 (||)
• 邏輯非 (!)

示例：

bool a = true, b = false;
bool andResult = a && b;  // false
bool orResult = a || b;   // true
bool notResult = !a;      // false

位運算符

C#和Java的位運算符也基本相同：

• 按位與 (&)
• 按位或 (|)
• 按位異或 (^)
• 按位取反 (~)
• 左移 (<<)
• 右移 (>>)

C#特有的位運算符：

• 無符號右移 (>>>)

示例：

int a = 60;// 二進制: 0011 1100
int b = 13;  // 二進制: 0000 1101int c = a & b;  // 12(二進制: 0000 1100)
int d = a | b;  // 61 (二進制: 0011 1101)
int e = a ^ b;  // 49 (二進制: 0011 0001)
int f = ~a;     // -61 (二進制: 1100 0011, 補碼表示)
int g = a << 2; // 240 (二進制: 1111 0000)
int h = a >> 2; // 15 (二進制: 0000 1111)

條件運算符

C#和Java都有三元條件運算符：

int a = 10, b = 20;
int max = (a > b) ? a : b;  // 20

C#特有的條件運算符：

• 空合并運算符 (??)
• 空條件運算符(?.)

示例：

string name = null;
string displayName = name ?? "Guest";  // "Guest"class Person
{public string Name { get; set; }
}Person person = null;
int? nameLength = person?.Name?.Length;  // null

類型測試運算符

C#提供了一些Java中沒有的類型測試運算符：

• is 運算符：檢查對象是否與特定類型兼容
• as 運算符：執行類型轉換，如果轉換失敗，返回null

示例：

object obj = "Hello";
if (obj is string)
{Console.WriteLine("obj is a string");
}string str = obj as string;
if (str != null)
{Console.WriteLine($"The string is: {str}");
}

Lambda 表達式

C#和Java都支持Lambda表達式，但語法略有不同：

C#:

Func<int, int> square = x => x * x;
int result = square(5);  // 25

Java:

Function<Integer, Integer> square = x -> x * x;
int result = square.apply(5);  // 25

空合并運算符(??)

C#特有的空合并運算符可以簡化處理可能為null的情況：

string name = null;
string displayName = name ?? "Guest";  // "Guest"

在Java中，你可能需要這樣寫：

String name = null;
String displayName = (name != null) ? name : "Guest";

表達式體成員 (Expression-bodied members)

C#允許使用更簡潔的語法來定義屬性和方法：

public class Circle
{public double Radius { get; set; }public double Diameter => Radius * 2;public double CalculateArea() => Math.PI * Radius * Radius;
}

這種語法在Java中是不存在的。

字符串插值

C#提供了非常方便的字符串插值語法：

string name = "Alice";
int age = 30;
string message = $"My name is {name} and I am {age} years old.";

Java在較新的版本中也引入了類似的功能，但語法不同：

String name = "Alice";
int age = 30;
String message = String.format("My name is %s and I am %d years old.", name, age);

小結

雖然C#和Java在運算符和表達式方面有很多相似之處，但C#提供了一些額外的特性，如空合并運算符、空條件運算符、表達式體成員等，這些可以讓代碼更加簡潔和表達力更強。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以讓你的代碼更加優雅和易讀。在實際編程中，合理利用這些特性可以提高代碼質量和開發效率。

在接下來的學習中，我們將深入探討C#的更多高級特性，如LINQ、異步編程等。這些概念將進一步展示C#相對于Java的獨特優勢。繼續保持學習的熱情，你會發現C#是一個功能豐富、表達力強的語言！

1.4 控制流語句

控制流語句是編程語言的基本構建塊，用于控制程序的執行路徑。C#和Java在這方面非常相似，但C#也有一些獨特的特性。讓我們深入了解C#的控制流語句，并與Java進行比較。

if-else 語句

C#和Java的if-else語句幾乎完全相同：

int x = 10;
if (x > 5)
{Console.WriteLine("x is greater than 5");
}
else if (x < 5)
{Console.WriteLine("x is less than 5");
}
else
{Console.WriteLine("x is equal to 5");
}

C#特有的特性：

1. 可空類型的使用：

int? x = null;
if (x.HasValue)
{Console.WriteLine($"x has a value: {x.Value}");
}
else
{Console.WriteLine("x is null");
}

2. 模式匹配（C# 7.0+）：

object obj = "Hello";
if (obj is string s)
{Console.WriteLine($"The string is: {s}");
}

switch 語句

C#的switch語句比Java的更加靈活：

int day = 3;
switch (day)
{case 1:Console.WriteLine("Monday");break;case 2:Console.WriteLine("Tuesday");break;case 3:case 4:case 5:Console.WriteLine("Midweek");break;default:Console.WriteLine("Weekend");break;
}

C#特有的特性：

1. 模式匹配（C# 7.0+）：

object obj = 123;
switch (obj)
{case int i when i > 100:Console.WriteLine($"Large integer: {i}");break;case string s:Console.WriteLine($"String value: {s}");break;case null:Console.WriteLine("Null value");break;default:Console.WriteLine("Unknown type");break;
}

2. switch 表達式（C# 8.0+）：

string GetDayType(int day) => day switch
{1 => "Monday",2 => "Tuesday",3 or 4 or 5 => "Midweek",_ => "Weekend"
};

循環語句

C#和Java的循環語句非常相似：

1. for循環：

for (int i = 0; i < 5; i++)
{Console.WriteLine(i);
}

2. while 循環：

int i = 0;
while (i < 5)
{Console.WriteLine(i);i++;
}

3. do-while 循環：

int i = 0;
do
{Console.WriteLine(i);i++;
} while (i < 5);

4. foreach 循環：

string[] fruits = { "apple", "banana", "cherry" };
foreach (string fruit in fruits)
{Console.WriteLine(fruit);
}

C#特有的特性：

1. LINQ與foreach的結合：

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (var num in numbers.Where(n => n % 2 == 0))
{Console.WriteLine(num);
}

跳轉語句

C#和Java都支持以下跳轉語句：

1. break：跳出當前循環或switch語句
2. continue：跳過當前循環的剩余部分，開始下一次迭代
3. return：從方法中返回，并可選擇返回一個值

C#特有的跳轉語句：

1. goto：雖然不推薦使用，但C#保留了goto語句

int i = 0;
start:if (i < 5){Console.WriteLine(i);i++;goto start;}

異常處理

C#和Java的異常處理機制非常相似：

try
{int result = 10 / 0;
}
catch (DivideByZeroException ex)
{Console.WriteLine($"Division by zero error: {ex.Message}");
}
catch (Exception ex)
{Console.WriteLine($"An error occurred: {ex.Message}");
}
finally
{Console.WriteLine("This always executes");
}

C#特有的特性：

1. 異常過濾器（C# 6.0+）：

try
{// 可能拋出異常的代碼
}
catch (Exception ex) when (ex.InnerException != null)
{Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
}

2. using 語句（簡化資源管理）：

using (var file = new System.IO.StreamReader("file.txt"))
{string content = file.ReadToEnd();Console.WriteLine(content);
}
// file自動關閉

3. using 聲明（C# 8.0+）：

using var file = new System.IO.StreamReader("file.txt");
string content = file.ReadToEnd();
Console.WriteLine(content);
// file 在作用域結束時自動關閉

小結

雖然C#和Java在控制流語句方面有很多相似之處，但C#提供了一些額外的特性，如模式匹配、switch表達式、異常過濾器等，這些可以讓代碼更加簡潔和表達力更強。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以讓你的代碼更加優雅和易讀。特別是模式匹配和switch表達式，它們可以大大簡化復雜的條件邏輯。

在實際編程中，合理利用這些特性可以提高代碼質量和開發效率。例如，使用模式匹配可以使類型檢查和轉換更加簡潔，使用switch表達式可以使復雜的條件判斷更加清晰。

在接下來的學習中，我們將深入探討C#的更多高級特性，如LINQ、異步編程等。這些概念將進一步展示C#相對于Java的獨特優勢。繼續保持學習的熱情，你會發現C#是一個功能豐富、表達力強的語言！

1.5 方法和參數

方法（在Java中稱為函數）是編程中最基本的代碼組織單元。C#和Java在方法定義和使用上有很多相似之處，但C#提供了一些額外的特性，使得方法定義和調用更加靈活。讓我們深入探討C#的方法和參數，并與Java進行比較。

方法定義

C#和Java的基本方法定義非常相似：

public int Add(int a, int b)
{return a + b;
}

Java中的等效代碼：

public int add(int a, int b) {return a + b;
}

主要區別：

1. C#方法名通常使用PascalCase，而Java使用camelCase。
2. C#支持方法重載，Java也支持。

參數傳遞

C#和Java都支持值傳遞和引用傳遞，但C#提供了更多選項：

1. 值參數（默認）：

public void IncrementValue(int x)
{x++; // 不影響原始值
}

2. 引用參數（ref 關鍵字）：

public void IncrementRef(ref int x)
{x++; // 修改原始值
}// 調用
int num = 5;
IncrementRef(ref num);
Console.WriteLine(num); // 輸出 6

Java沒有直接等效的引用參數，但可以通過包裝類或數組實現類似效果。

3. 輸出參數（out 關鍵字）：

public bool TryParse(string s, out int result)
{return int.TryParse(s, out result);
}// 調用
if (TryParse("123", out int number))
{Console.WriteLine($"Parsed number: {number}");
}

Java沒有直接等效的輸出參數。

4. 參數數組（params 關鍵字）：

public int Sum(params int[] numbers)
{return numbers.Sum();
}// 調用
int total = Sum(1, 2, 3, 4, 5);

Java使用可變參數（varargs）實現類似功能：

public int sum(int... numbers) {return Arrays.stream(numbers).sum();
}

方法重載

C#和Java都支持方法重載，允許在同一個類中定義多個同名但參數列表不同的方法：

public class Calculator
{public int Add(int a, int b){return a + b;}public double Add(double a, double b){return a + b;}
}

Java的方法重載與C#基本相同。

可選參數

C#支持可選參數，這在Java中直到最近才引入：

public void Greet(string name, string greeting = "Hello")
{Console.WriteLine($"{greeting}, {name}!");
}// 調用
Greet("Alice"); // 輸出: Hello, Alice!
Greet("Bob", "Hi"); // 輸出: Hi, Bob!

在Java中，你通常需要使用方法重載來實現類似功能：

public void greet(String name) {greet(name, "Hello");
}public void greet(String name, String greeting) {System.out.println(greeting + ", " + name + "!");
}

命名參數

C#支持命名參數，可以提高代碼的可讀性：

public void CreateUser(string name, int age, bool isAdmin = false)
{//方法實現
}// 調用
CreateUser(name: "Alice", age: 30, isAdmin: true);
CreateUser(age: 25, name: "Bob"); // 可以改變參數順序

Java不支持命名參數，但可以使用建造者模式來實現類似的效果。

表達式體方法

C# 6.0引入了表達式體方法，可以使簡單方法的定義更加簡潔：

public int Add(int a, int b) => a + b;public string GetFullName(string firstName, string lastName) => $"{firstName} {lastName}";

Java不支持這種語法糖。

本地函數

C# 7.0引入了本地函數，允許在方法內定義函數：

public int Factorial(int n)
{int LocalFactorial(int x){return x <= 1 ? 1 : x * LocalFactorial(x - 1);}return LocalFactorial(n);
}

Java不直接支持本地函數，但可以使用匿名內部類或lambda表達式來實現類似功能。

異步方法

C#對異步編程的支持非常強大，使用async和await關鍵字：

public async Task<string> FetchDataAsync(string url)
{using var client = new HttpClient();return await client.GetStringAsync(url);
}// 調用
string data = await FetchDataAsync("https://api.example.com");

Java也支持異步編程，但語法和使用方式與C#不同，通常使用CompletableFuture：

public CompletableFuture<String> fetchDataAsync(String url) {return CompletableFuture.supplyAsync(() -> {// 使用HttpClient獲取數據return "data";});
}// 調用
String data = fetchDataAsync("https://api.example.com").join();

擴展方法

C#允許你為現有類型添加新方法，而不需要修改原始類型的定義：

public static class StringExtensions
{public static bool IsNullOrEmpty(this string str){return string.IsNullOrEmpty(str);}
}// 使用
string name = "Alice";
bool isEmpty = name.IsNullOrEmpty();

Java不支持擴展方法，但可以使用靜態工具類來實現類似功能。

泛型方法

C#和Java都支持泛型方法，允許你編寫可以處理多種類型的方法：

public T Max<T>(T a, T b) where T : IComparable<T>
{return a.CompareTo(b) > 0 ? a : b;
}// 使用
int maxInt = Max(5, 10);
string maxString = Max("apple", "banana");

Java的泛型方法語法略有不同：

public <T extends Comparable<T>> T max(T a, T b) {return a.compareTo(b) > 0 ? a : b;
}

方法組合與函數式編程

C#對函數式編程有很好的支持，可以輕松組合和傳遞方法：

Func<int, int> square = x => x * x;
Func<int, int> addOne = x => x + 1;Func<int, int> squareThenAddOne = x => addOne(square(x));int result = squareThenAddOne(5); // 26

Java也支持函數式編程，但語法略有不同：

Function<Integer, Integer> square = x -> x * x;
Function<Integer, Integer> addOne = x -> x + 1;Function<Integer, Integer> squareThenAddOne = square.andThen(addOne);int result = squareThenAddOne.apply(5); // 26

小結

雖然C#和Java在方法和參數的基本概念上很相似，但C#提供了更多的特性和靈活性。C#的引用參數、輸出參數、命名參數、可選參數等特性可以讓方法定義和調用更加靈活和清晰。此外，C#的異步方法、擴展方法和表達式體方法等特性可以讓代碼更加簡潔和易讀。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以大大提高你的編程效率和代碼質量。例如，命名參數和可選參數可以減少方法重載的需求，擴展方法可以讓你更容易地擴展現有類型的功能，而async/await則可以大大簡化異步編程的復雜性。

在實際編程中，合理利用這些特性可以讓你的代碼更加清晰、簡潔和易于維護。例如，使用命名參數可以提高代碼的可讀性，使用擴展方法可以使你的代碼更加模塊化，而使用異步方法可以提高應用程序的響應性。

隨著你對C#的深入學習，你會發現更多強大的特性和用法。保持學習和實踐的熱情，你將能夠充分利用C#的強大功能，成為一個高效的.NET開發者！

1.6 類和對象

類和對象是面向對象編程的核心概念，C#和Java在這方面有很多相似之處，但C#提供了一些額外的特性和語法糖，使得類的定義和使用更加靈活和簡潔。讓我們深入探討C#的類和對象，并與Java進行比較。

類的定義

C#和Java的基本類定義非常相似：

public class Person
{public string Name { get; set; }public int Age { get; set; }public void SayHello(){Console.WriteLine($"Hello, my name is {Name} and I'm {Age} years old.");}
}

Java中的等效代碼：

public class Person {private String name;private int age;public String getName() { return name; }public void setName(String name) { this.name = name; }public int getAge() { return age; }public void setAge(int age) { this.age = age; }public void sayHello() {System.out.println("Hello, my name is " + name + " and I'm " + age + " years old.");}
}

主要區別：

1. C#使用屬性（Properties）代替了Java的getter和setter方法。
2. C#的方法名通常使用PascalCase，而Java使用camelCase。

構造函數

C#和Java的構造函數定義類似：

public class Person
{public string Name { get; set; }public int Age { get; set; }public Person(string name, int age){Name = name;Age = age;}
}

C#特有的特性：

1. 構造函數初始化器：

public class Employee : Person
{public string Company { get; set; }public Employee(string name, int age, string company) : base(name, age){Company = company;}
}

2. 主構造函數（C# 9.0+）：

public class Person(string name, int age)
{public string Name { get; set; } = name;public int Age { get; set; } = age;
}

屬性

C#的屬性是一個強大的特性，可以替代Java中的getter和setter方法：

public class Person
{private string name;public string Name{get { return name; }set { name = value; }}// 自動實現的屬性public int Age { get; set; }// 只讀屬性public bool IsAdult => Age >= 18;
}

C# 6.0+引入了更簡潔的屬性語法：

public class Person
{public string Name { get; set; } = "John Doe";public int Age { get; set; }public bool IsAdult => Age >= 18;
}

靜態成員

C#和Java都支持靜態成員：

public class MathHelper
{public static double PI = 3.14159;public static int Add(int a, int b){return a + b;}
}// 使用
double pi = MathHelper.PI;
int sum = MathHelper.Add(5, 3);

繼承

C#和Java的繼承語法略有不同：

public class Animal
{public virtual void MakeSound(){Console.WriteLine("The animal makes a sound");}
}public class Dog : Animal
{public override void MakeSound(){Console.WriteLine("The dog barks");}
}

Java中的等效代碼：

public class Animal {public void makeSound() {System.out.println("The animal makes a sound");}
}public class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("The dog barks");}
}

主要區別：

1. C#使用冒號(:)表示繼承，Java使用extends關鍵字。
2. C#需要使用virtual和override關鍵字來實現方法重寫，Java只需要使用@Override注解。

接口

C#和Java的接口定義類似，但C#允許接口包含默認實現（C# 8.0+）：

public interface IAnimal
{void MakeSound();void Move() => Console.WriteLine("The animal moves");
}public class Dog : IAnimal
{public void MakeSound(){Console.WriteLine("The dog barks");}// Move方法使用接口的默認實現
}

Java8+也支持接口默認方法：

public interface Animal {void makeSound();default void move() {System.out.println("The animal moves");}
}

匿名類型

C#支持匿名類型，可以快速創建簡單的對象：

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"{person.Name} is {person.Age} years old");

Java也支持匿名類，但主要用于創建接口或抽象類的匿名實現。

Record類型（C# 9.0+）

C# 9.0引入了Record類型，用于創建不可變的引用類型：

public record Person(string Name, int Age);var alice = new Person("Alice", 30);
var bob = alice with { Name = "Bob" }; // 創建一個新記錄，只修改Name

Java 14+引入了類似的Record特性：

public record Person(String name, int age) {}

對象初始化器

C#支持對象初始化器，可以在創建對象時直接設置屬性：

var person = new Person
{Name = "Alice",Age = 30
};

Java不直接支持這種語法，通常使用建造者模式來實現類似效果。

擴展方法

C#允許為現有類型添加新方法，而不需要修改原始類型：

public static class StringExtensions
{public static bool IsNullOrEmpty(this string str){return string.IsNullOrEmpty(str);}
}// 使用
string name = "Alice";
bool isEmpty = name.IsNullOrEmpty();

Java不支持擴展方法，但可以使用靜態工具類來實現類似功能，或者使用manifold 插件支持。

部分類（Partial Classes）

C#支持部分類，允許將一個類的定義分散到多個文件中：

// File1.cs
public partial class MyClass
{public void Method1() { }
}// File2.cs
public partial class MyClass
{public void Method2() { }
}

Java不支持部分類的概念。

索引器（Indexers）

C#支持索引器，允許類像數組一樣通過索引訪問：

public class StringCollection
{private List<string> items = new List<string>();public string this[int index]{get { return items[index]; }set { items[index] = value; }}
}// 使用
var collection = new StringCollection();
collection[0] = "Hello";
Console.WriteLine(collection[0]); // 輸出: Hello

Java沒有直接等效的特性，通常需要定義專門的get和set方法。

運算符重載

C#允許為自定義類型定義運算符的行為：

public struct Complex
{public double Real { get; set; }public double Imaginary { get; set; }public static Complex operator +(Complex c1, Complex c2){return new Complex { Real = c1.Real + c2.Real,Imaginary = c1.Imaginary + c2.Imaginary};}
}// 使用
var c1 = new Complex { Real = 1, Imaginary = 2 };
var c2 = new Complex { Real = 3, Imaginary = 4 };
var result = c1 + c2;

Java不支持運算符重載。

嵌套類型

C#和Java都支持嵌套類型，但C#的訪問規則更加靈活：

public class OuterClass
{private int outerField = 10;public class InnerClass{public void AccessOuterField(OuterClass outer){Console.WriteLine(outer.outerField);}}
}

在C#中，嵌套類可以訪問外部類的私有成員，而在Java中，內部類需要外部類的實例才能訪問其私有成員。

密封類和方法

C#使用sealed關鍵字來防止類被繼承或方法被重寫：

public sealed class FinalClass
{// 這個類不能被繼承
}public class BaseClass
{public virtual void VirtualMethod() { }
}public class DerivedClass : BaseClass
{public sealed override void VirtualMethod() { }// 這個方法不能在子類中被重寫
}

Java使用final關鍵字實現類似功能。

析構函數和終結器

C#支持析構函數（用于結構體）和終結器（用于類）：

public class ResourceHolder
{private IntPtr resource;public ResourceHolder(){resource = AllocateResource();}~ResourceHolder(){FreeResource(resource);}private IntPtr AllocateResource() { /*分配資源 */ }private void FreeResource(IntPtr handle) { /* 釋放資源 */ }
}

Java不支持析構函數，但有類似的finalize()方法（雖然不推薦使用）。

屬性訪問器的可訪問性

C#允許為屬性的getter 和 setter 單獨設置訪問級別：

public class Person
{public string Name { get; private set; }public Person(string name){Name = name;}
}

Java不支持這種細粒度的訪問控制。

init only setters（C#9.0+）

var circle = new Circle { Radius = 5 };
var bigCircle = new Circle { Diameter = 20 };public class Circle
{private double _radius;public double Radius{get => _radius;init => _radius = value;}public double Diameter{get => 2 * _radius;init => _radius = value / 2;}
}

頂級語句（C# 9.0+）

從C# 9.0開始，可以在文件級別直接編寫代碼，而不需要顯式的Main方法：

Console.WriteLine("Hello, World!");

這個特性簡化了小型程序和腳本的編寫。Java仍然需要一個包含main方法的類。

模式匹配（C# 7.0+）

C#支持高級的模式匹配，可以在switch語句和is表達式中使用：

object obj = "Hello";if (obj is string s && s.Length > 5)
{Console.WriteLine($"It's a long string: {s}");
}var result = obj switch
{string s => $"It's a string: {s}",int i => $"It's an int: {i}",_ => "It's something else"
};

Java支持有限形式的模式匹配（從Java 14開始），但不如C#靈活。

小結

C#提供了豐富的特性來定義和使用類和對象，許多這些特性在Java中是沒有直接等價物的。這些特性不僅可以讓代碼更加簡潔和表達力更強，還可以提高開發效率和代碼質量。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以讓你以新的方式思考和組織代碼。例如，索引器可以讓你的自定義類型像數組一樣使用，運算符重載可以讓你的類型更自然地參與數學運算，而模式匹配則可以簡化復雜的類型檢查和轉換邏輯。

在實際編程中，合理利用這些特性可以大大提高代碼的可讀性和可維護性。例如，使用屬性可以簡化數據封裝，使用記錄類型可以簡化不可變數據模型的創建，而使用模式匹配可以使復雜的條件邏輯更加清晰。

隨著你對C#的深入學習和實踐，你會發現更多強大的特性和用法。保持學習和實踐的熱情，你將能夠充分利用C#的強大功能，成為一個高效的.NET開發者！記住，編程語言只是工具，關鍵是要理解背后的概念和原理，并能夠在實際問題中靈活應用這些知識。

1.7 繼承和多態

繼承和多態是面向對象編程的核心概念，C#和Java在這方面有許多相似之處，但C#提供了一些額外的特性和語法，使得繼承和多態的實現更加靈活和強大。讓我們深入探討C#的繼承和多態，并與Java進行比較。

基本繼承

C#和Java的基本繼承語法略有不同：

C#:

public class Animal
{public string Name { get; set; }public virtual void MakeSound(){Console.WriteLine("The animal makes a sound");}
}public class Dog : Animal
{public override void MakeSound(){Console.WriteLine("The dog barks");}
}

Java:

public class Animal {private String name;public String getName() { return name; }public void setName(String name) { this.name = name; }public void makeSound() {System.out.println("The animal makes a sound");}
}public class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("The dog barks");}
}

主要區別：

1. C#使用冒號(:)表示繼承，Java使用extends關鍵字。
2. C#需要使用virtual和override關鍵字來實現方法重寫，Java只需要使用@Override注解。
3. C#默認使用屬性（Properties）而不是getter和setter方法。

構造函數和繼承

在C#中，派生類的構造函數可以顯式調用基類的構造函數：

public class Animal
{public string Name { get; set; }public Animal(string name){Name = name;}
}public class Dog : Animal
{public string Breed { get; set; }public Dog(string name, string breed) : base(name){Breed = breed;}
}

Java中的等效代碼：

public class Animal {private String name;public Animal(String name) {this.name = name;}
}public class Dog extends Animal {private String breed;public Dog(String name, String breed) {super(name);this.breed = breed;}
}

密封類和方法

C#使用sealed關鍵字來防止類被繼承或方法被重寫：

public sealed class FinalClass
{// 這個類不能被繼承
}public class BaseClass
{public virtual void VirtualMethod() { }
}public class DerivedClass : BaseClass
{public sealed override void VirtualMethod() { }// 這個方法不能在子類中被重寫
}

Java使用final關鍵字實現類似功能：

public final class FinalClass {// 這個類不能被繼承
}public class BaseClass {public void virtualMethod() { }
}public class DerivedClass extends BaseClass {@Overridepublic final void virtualMethod() { }// 這個方法不能在子類中被重寫
}

抽象類和方法

C#和Java都支持抽象類和方法：

C#:

public abstract class Shape
{public abstract doubleCalculateArea();
}public class Circle : Shape
{public double Radius { get; set; }public override double CalculateArea(){return Math.PI * Radius * Radius;}
}

Java:

public abstract class Shape {public abstract double calculateArea();
}public class Circle extends Shape {private double radius;public void setRadius(double radius) { this.radius = radius; }@Overridepublic double calculateArea() {return Math.PI * radius * radius;}
}

接口

C#和Java都支持接口，但C# 8.0+允許接口定義默認實現：

C#:

public interface IDrawable
{void Draw();void Erase() => Console.WriteLine("Default erase behavior");
}public class Square : IDrawable
{public void Draw(){Console.WriteLine("Drawing a square");}// Erase方法使用默認實現
}

Java 8+也支持接口默認方法：

public interface Drawable {void draw();default void erase() {System.out.println("Default erase behavior");}
}public class Square implements Drawable {@Overridepublic void draw() {System.out.println("Drawing a square");}// erase方法使用默認實現
}

多重繼承

C#和Java都不支持類的多重繼承，但都允許一個類實現多個接口：

public interface IDrawable
{void Draw();
}public interface IResizable
{void Resize(int width, int height);
}public class Rectangle : IDrawable, IResizable
{public void Draw(){Console.WriteLine("Drawing a rectangle");}public void Resize(int width, int height){Console.WriteLine($"Resizing to {width}x{height}");}
}

泛型約束

C#支持泛型約束，可以限制泛型參數的類型：

public class GenericRepository<T> where T : class, new()
{public T CreateNew(){return new T();}
}

Java也支持泛型約束，但語法略有不同：

public class GenericRepository<T extends Object & Serializable> {public T createNew() throws InstantiationException, IllegalAccessException {return T.class.newInstance();}
}

協變和逆變

C#支持泛型接口和委托的協變和逆變：

public interface IEnumerable<out T> { /* ... */ }
public interface IComparer<in T> { /* ... */ }IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings; // 協變IComparer<object> objectComparer = /* ... */;
IComparer<string> stringComparer = objectComparer; // 逆變

Java也支持泛型的協變和逆變，但語法不同：

List<String> strings = new ArrayList<>();
List<? extends Object> objects = strings; // 協變Comparator<Object> objectComparator = /* ... */;
Comparator<? super String> stringComparator = objectComparator; // 逆變

隱藏基類成員

C#使用new關鍵字來隱藏基類成員：

public class BaseClass
{public void Method(){Console.WriteLine("BaseClass.Method");}
}public class DerivedClass : BaseClass
{public new void Method(){Console.WriteLine("DerivedClass.Method");}
}

Java沒有直接等效的語法，但可以通過重新定義方法來實現類似效果。

基類訪問

C#使用base關鍵字來訪問基類成員，類似于Java中的super：

public class DerivedClass : BaseClass
{public override void Method(){base.Method(); // 調用基類方法Console.WriteLine("Additional behavior in derived class");}
}

構造函數鏈

C#允許在一個類中定義多個構造函數，并使用this關鍵字鏈接它們：

public class Person
{public string Name { get; set; }public int Age { get; set; }public Person(string name) : this(name, 0){}public Person(string name, int age){Name = name;Age = age;}
}

顯式接口實現

C#允許顯式實現接口方法，這在實現多個具有相同方法簽名的接口時特別有用：

public interfaceIA
{void Method();
}public interface IB
{void Method();
}public class MyClass : IA, IB
{void IA.Method(){Console.WriteLine("IA.Method");}void IB.Method(){Console.WriteLine("IB.Method");}public void Method(){Console.WriteLine("MyClass.Method");}
}

Java不支持這種顯式接口實現。

抽象屬性

C#允許在抽象類中定義抽象屬性：

public abstract class Animal
{public abstract string Sound { get; }
}public class Dog : Animal
{public override string Sound => "Woof";
}

派生類中的新成員

C#允許在派生類中添加新的成員，而不需要特殊語法：

public class Animal
{public virtual void MakeSound() { }
}public class Dog : Animal
{public override void MakeSound(){Console.WriteLine("Woof");}public void Fetch() //新方法{Console.WriteLine("Dog is fetching");}
}

泛型繼承

C#支持泛型類的繼承，并允許在派生類中指定或保持開放泛型類型參數：

public class GenericBase<T>
{public T Data { get; set; }
}public class StringDerived : GenericBase<string>
{public void PrintUpperCase(){Console.WriteLine(Data.ToUpper());}
}public class GenericDerived<T> : GenericBase<T>
{public void PrintType(){Console.WriteLine(typeof(T).Name);}
}

接口的多重繼承雖然C#不支持類的多重繼承，但接口可以繼承多個接口：

public interfaceIA
{void MethodA();
}public interface IB
{void MethodB();
}public interface IC : IA, IB
{void MethodC();
}public class MyClass : IC
{public void MethodA() { }public void MethodB() { }public void MethodC() { }
}

繼承鏈中的構造函數調用順序

在C#中，當創建一個派生類的實例時，構造函數的調用順序是從最基礎的類開始，一直到最派生的類：

public class A
{public A() { Console.WriteLine("A"); }
}public class B : A
{public B() { Console.WriteLine("B"); }
}public class C : B
{public C() { Console.WriteLine("C"); }
}// 使用
var c = new C(); // 輸出: A B C

虛方法表（VMT）和動態分發

C#使用虛方法表來實現多態。當你調用一個虛方法時，實際調用的方法是在運行時根據對象的實際類型決定的：

Animal animal = new Dog();
animal.MakeSound(); // 調用Dog的MakeSound方法

這種機制稱為動態分發，它是多態的核心實現方式。

接口默認實現中的鉆石問題解決

當一個類實現多個具有相同默認方法的接口時，C#要求顯式實現該方法：

public interfaceIA
{void Method() => Console.WriteLine("IA.Method");
}public interface IB
{void Method() => Console.WriteLine("IB.Method");
}public class MyClass : IA, IB
{public void Method() // 必須實現，否則編譯錯誤{((IA)this).Method(); // 調用IA的默認實現// 或((IB)this).Method(); // 調用IB的默認實現}
}

最佳實踐

1. 優先使用組合而不是繼承：繼承創建了強耦合，而組合更靈活。

2. 遵循里氏替換原則（LSP）：子類應該可以替換其基類，而不改變程序的正確性。

3. 謹慎使用密封類和方法：雖然它們可以提高性能和安全性，但也限制了擴展性。

4. 使用接口進行抽象：接口提供了更好的解耦和靈活性。

5. 避免深層繼承層次：深層繼承可能導致復雜性和維護困難。

6. 合理使用抽象類：當你需要在基類中提供一些實現時，使用抽象類而不是接口。

7. 正確使用virtual和override關鍵字：這些關鍵字明確表達了你的意圖，使代碼更易理解和維護。

抽象類vs接口

雖然抽象類和接口都可以用來定義抽象類型，但它們有一些關鍵區別：

1. 抽象類可以包含實現，接口（在C# 8.0之前）只能包含方法簽名。
2. 一個類只能繼承一個抽象類，但可以實現多個接口。
3. 抽象類可以有構造函數，接口不能。
4. 抽象類可以包含字段，接口不能。

選擇使用抽象類還是接口取決于你的設計需求：

public abstract class Animal
{protected string name;public Animal(string name){this.name = name;}public abstract void MakeSound();
}public interface IMovable
{void Move();
}public class Dog : Animal, IMovable
{public Dog(string name) : base(name) { }public override void MakeSound(){Console.WriteLine("Woof!");}public void Move(){Console.WriteLine("Dog is running");}
}

多接口繼承與默認實現

C# 8.0引入的接口默認實現允許我們在不破壞現有代碼的情況下向接口添加新方法：

public interface ILogger
{void Log(string message);void LogError(string message) => Log($"ERROR: {message}");
}public class ConsoleLogger : ILogger
{public void Log(string message){Console.WriteLine(message);}// 可以選擇重寫或使用默認的LogError實現
}

泛型約束中的繼承

C#允許在泛型約束中使用繼承關系：

public class Animal { }
public class Dog : Animal { }public class Kennel<T> where T : Animal
{public void AddAnimal(T animal) { }
}var dogKennel = new Kennel<Dog>(); // 有效
// var intKennel = new Kennel<int>(); // 編譯錯誤

隱藏繼承成員

有時你可能想在派生類中隱藏基類的成員，而不是覆蓋它。C#使用new關鍵字來實現這一點：

public class Base
{public virtual void Method(){Console.WriteLine("Base.Method");}
}public class Derived : Base
{public new void Method(){Console.WriteLine("Derived.Method");}
}Base b = new Derived();
b.Method(); // 輸出: Base.MethodDerived d = new Derived();
d.Method(); // 輸出: Derived.Method

協變和逆變在委托中的應用

C#支持在委托中使用協變和逆變：

delegate T Factory<out T>();
delegate void Action<in T>(T obj);class Animal { }
class Dog : Animal { }class Program
{static Dog CreateDog() => new Dog();static void HandleAnimal(Animal a) { }static void Main(){Factory<Dog> dogFactory = CreateDog;Factory<Animal> animalFactory = dogFactory; // 協變Action<Animal> animalHandler = HandleAnimal;Action<Dog> dogHandler = animalHandler; // 逆變}
}

虛擬屬性和索引器

C#允許將屬性和索引器聲明為虛擬的，這樣它們可以在派生類中被重寫：

public class Base
{public virtual int Property { get; set; }public virtual int this[int index]{get =>0;set { }}
}public class Derived : Base
{private int[] data = new int[10];public override int Property{get => base.Property;set => base.Property = value * 2;}public override int this[int index]{get => data[index];set => data[index] = value;}
}

抽象類中的密封方法

雖然看起來有點矛盾，但C#允許在抽象類中定義密封方法。這可以用來提供一個不能被重寫的實現：

public abstract class Base
{public abstract void AbstractMethod();public virtual void VirtualMethod() { }public sealed void SealedMethod() { }
}public class Derived : Base
{public override void AbstractMethod() { }public override void VirtualMethod() { } // 可以重寫//無法重寫SealedMethod
}

接口中的靜態成員

從C# 8.0開始，接口可以包含靜態成員，包括字段、方法、屬性等：

public interface IMyInterface
{static int MyProperty { get; set; }static void MyMethod() => Console.WriteLine("Hello from interface!");
}

繼承鏈中的構造函數和字段初始化順序

了解C#中構造函數和字段初始化的順序非常重要：

1. 派生類的字段初始化器
2. 派生類的構造函數
3. 基類的字段初始化器
4. 基類的構造函數

public class Base
{public int BaseField = 1;public Base(){Console.WriteLine($"Base constructor, BaseField = {BaseField}");}
}public class Derived : Base
{public int DerivedField = BaseField + 1;public Derived(){Console.WriteLine($"Derived constructor, DerivedField = {DerivedField}");}
}// 輸出:
// Base constructor, BaseField = 1
// Derived constructor, DerivedField = 2

使用接口作為類型參數

接口可以用作方法的類型參數，這提供了更大的靈活性：

public void ProcessItems<T>(IEnumerable<T> items) where T : IComparable<T>
{foreach (var item in items.OrderBy(i => i)){Console.WriteLine(item);}
}

小結

C#提供了豐富而靈活的繼承和多態機制，允許開發者創建復雜的類層次結構和接口設計。相比Java，C#在某些方面提供了更細粒度的控制和更多的語法糖，如顯式接口實現、抽象屬性等。

作為一個從Java轉向C#的開發者，你會發現這些特性可以幫助你創建更加清晰、靈活和可維護的代碼。例如，顯式接口實現可以解決方法名沖突問題，抽象屬性可以更優雅地定義必須由派生類實現的屬性。

然而，重要的是要記住，這些強大的特性也帶來了復雜性。在使用繼承和多態時，始終要考慮代碼的可維護性和可讀性。遵循SOLID原則，合理使用組合和繼承，避免創建過于復雜的繼承層次結構。

通過深入理解和合理使用這些特性，你可以充分利用C#的強大功能，創建出更加靈活、可擴展和易于維護的代碼。在實際項目中，根據具體需求和設計目標來選擇合適的特性和模式，將幫助你成為一個更出色的C#開發者。

當然，讓我們繼續深入探討C#中繼承和多態的一些高級概念和最佳實踐：

抽象工廠模式

抽象工廠模式是一種創建型設計模式，它使用繼承和多態來提供一種創建相關對象家族的方式，而無需指定它們的具體類。這在C#中可以優雅地實現：

public interface IButton { void Paint(); }
public interface ICheckbox { void Paint(); }public interface IGUIFactory
{IButton CreateButton();ICheckbox CreateCheckbox();
}public class WinButton : IButton
{public void Paint() => Console.WriteLine("Windows Button");
}public class MacButton : IButton
{public void Paint() => Console.WriteLine("Mac Button");
}public class WinCheckbox : ICheckbox
{public void Paint() => Console.WriteLine("Windows Checkbox");
}public class MacCheckbox : ICheckbox
{public void Paint() => Console.WriteLine("Mac Checkbox");
}public class WinFactory : IGUIFactory
{public IButton CreateButton() => new WinButton();public ICheckbox CreateCheckbox() => new WinCheckbox();
}public class MacFactory : IGUIFactory
{public IButton CreateButton() => new MacButton();public ICheckbox CreateCheckbox() => new MacCheckbox();
}// 使用
IGUIFactory factory = new WinFactory();
var button = factory.CreateButton();
button.Paint(); //輸出: Windows Button

模板方法模式

模板方法模式定義了一個算法的骨架，允許子類重新定義算法的某些步驟，而不改變算法的結構：

public abstract class DataProcessor
{public void ProcessData(){OpenFile();ExtractData();ParseData();AnalyzeData();SendReport();CloseFile();}protected abstract void ExtractData();protected abstract void ParseData();protected abstract void AnalyzeData();protected virtual void OpenFile(){Console.WriteLine("Opening file...");}protected virtual void SendReport(){Console.WriteLine("Sending report...");}protected virtual void CloseFile(){Console.WriteLine("Closing file...");}
}public class PDFProcessor : DataProcessor
{protected override void ExtractData(){Console.WriteLine("Extracting data from PDF...");}protected override void ParseData(){Console.WriteLine("Parsing PDF data...");}protected override void AnalyzeData(){Console.WriteLine("Analyzing PDF data...");}
}

策略模式

策略模式定義了一系列算法，并使它們可以互相替換。這個模式利用了多態性：

public interface ISortStrategy
{void Sort(List<int> data);
}public class BubbleSort : ISortStrategy
{public void Sort(List<int> data){Console.WriteLine("Performing bubble sort");// 實現冒泡排序}
}public class QuickSort : ISortStrategy
{public void Sort(List<int> data){Console.WriteLine("Performing quick sort");// 實現快速排序}
}public class Sorter
{private ISortStrategy _strategy;public Sorter(ISortStrategy strategy){_strategy = strategy;}public void SetStrategy(ISortStrategy strategy){_strategy = strategy;}public void SortData(List<int> data){_strategy.Sort(data);}
}// 使用
var sorter = new Sorter(new BubbleSort());
sorter.SortData(new List<int> { 3, 1, 4, 1, 5, 9});
sorter.SetStrategy(new QuickSort());
sorter.SortData(new List<int> { 3, 1, 4, 1, 5, 9 });

裝飾器模式

裝飾器模式允許你動態地給對象添加新的行為，而不改變其結構：

public interface ICoffee
{string GetDescription();double GetCost();
}public class SimpleCoffee : ICoffee
{public string GetDescription() => "Simple Coffee";public double GetCost() => 1;
}public abstract class CoffeeDecorator : ICoffee
{protected ICoffee _coffee;public CoffeeDecorator(ICoffee coffee){_coffee = coffee;}public virtual string GetDescription() => _coffee.GetDescription();public virtual double GetCost() => _coffee.GetCost();
}public class MilkDecorator : CoffeeDecorator
{public MilkDecorator(ICoffee coffee) : base(coffee) { }public override string GetDescription() => $"{base.GetDescription()}, Milk";public override double GetCost() => base.GetCost() + 0.5;
}public class SugarDecorator : CoffeeDecorator
{public SugarDecorator(ICoffee coffee) : base(coffee) { }public override string GetDescription() => $"{base.GetDescription()}, Sugar";public override double GetCost() => base.GetCost() + 0.2;
}// 使用
ICoffee coffee = new SimpleCoffee();
coffee = new MilkDecorator(coffee);
coffee = new SugarDecorator(coffee);
Console.WriteLine($"Description: {coffee.GetDescription()}");
Console.WriteLine($"Cost: ${coffee.GetCost()}");

使用協變和逆變優化接口設計

協變和逆變可以使得泛型接口更加靈活：

// 協變接口
public interface IProducer<out T>
{T Produce();
}// 逆變接口
public interface IConsumer<in T>
{void Consume(T item);
}public class Animal { }
public class Dog : Animal { }public class DogProducer : IProducer<Dog>
{public Dog Produce() => new Dog();
}public class AnimalConsumer : IConsumer<Animal>
{public void Consume(Animal animal) { }
}// 使用
IProducer<Animal> animalProducer = new DogProducer(); // 協變
IConsumer<Dog> dogConsumer = new AnimalConsumer(); // 逆變

使用接口隔離原則（ISP）

接口隔離原則建議將大接口分割成更小、更具體的接口：

// 不好的設計
public interface IWorker
{void Work();void Eat();void Sleep();
}// 更好的設計
public interface IWorkable
{void Work();
}public interface IEatable
{void Eat();
}public interface ISleepable
{void Sleep();
}public class Human : IWorkable, IEatable, ISleepable
{public void Work() { }public void Eat() { }public void Sleep() { }
}public class Robot : IWorkable
{public void Work() { }
}

使用組合優于繼承雖然繼承是一個強大的工具，但它也可能導致緊耦合。

在許多情況下，組合可能是一個更好的選擇：

// 使用繼承
public class Bird
{public virtual void Fly(){Console.WriteLine("Flying...");}
}public class Penguin : Bird
{public override void Fly(){throw new NotSupportedException("Penguins can't fly");}
}// 使用組合
public interface IFlyable
{void Fly();
}public class FlyingBehavior : IFlyable
{public void Fly(){Console.WriteLine("Flying...");}
}public class Bird
{private IFlyable _flyingBehavior;public Bird(IFlyable flyingBehavior){_flyingBehavior = flyingBehavior;}public void Fly(){_flyingBehavior.Fly();}
}public class Penguin : Bird
{public Penguin() : base(new NullFlyingBehavior()) { }
}public class NullFlyingBehavior : IFlyable
{public void Fly() { } // Do nothing
}

小結

這些高級概念和模式展示了如何在實際應用中利用C#的繼承和多態特性來創建靈活、可擴展的代碼。設計模式如抽象工廠、策略、裝飾器等，都是繼承和多態的具體應用，可以幫助你解決常見的設計問題。

同時，我們也看到了一些重要的設計原則，如接口隔離原則和組合優于繼承。這些原則可以幫助你創建更加模塊化、易于維護的代碼。

在實際開發中，選擇使用繼承還是組合，或者選擇哪種設計模式，都需要根據具體的問題和上下文來決定。重要的是要理解這些概念背后的原理，并能夠靈活地應用它們。

作為一個從Java轉向C#的開發者，你會發現這些概念在兩種語言中都是適用的，但C#提供了一些額外的特性（如顯式接口實現、擴展方法等）可以讓這些模式的實現更加優雅。

繼續深入學習和實踐這些概念，你將能夠設計出更加健壯、靈活的軟件系統，成為一個更優秀的C#開發者。

1.8 接口和抽象類

接口和抽象類都是C#中用于定義抽象類型的重要工具，但它們有不同的用途和特性。讓我們詳細探討這兩個概念，并比較它們與Java中對應概念的異同。

接口（Interfaces）

接口在C#中定義了一組方法、屬性、事件或索引器的簽名，但不提供實現。它們用于定義一個類應該具有的能力，而不關心這些能力如何實現。

C#中接口的基本語法：

public interface IAnimal
{string Name { get; set; }void MakeSound();
}public class Dog : IAnimal
{public string Name { get; set; }public void MakeSound(){Console.WriteLine("Woof!");}
}

C# 8.0中的接口新特性：

1. 默認實現：

public interface IAnimal
{string Name { get; set; }void MakeSound();void Eat() => Console.WriteLine($"{Name} is eating.");
}

2. 靜態成員：

public interface IAnimal
{static int Count { get; set; }static void IncrementCount() => Count++;
}

3. 私有成員：

public interface IAnimal
{private static int count;public static int Count => count;static void IncrementCount() => count++;
}

與Java的比較：

Java8引入了接口默認方法，類似于C# 8.0的默認實現。但C#的接口更加靈活，允許靜態成員和私有成員。

抽象類（Abstract Classes）

抽象類是一種不能被實例化的類，用于定義其他類的共同特征。它可以包含抽象方法（沒有實現的方法）和具體方法（有實現的方法）。

C#中抽象類的基本語法：

public abstract class Animal
{public string Name { get; set; }public abstract void MakeSound();public virtual void Eat(){Console.WriteLine($"{Name} is eating.");}
}public class Dog : Animal
{public override void MakeSound(){Console.WriteLine("Woof!");}
}

與Java的比較：

C#和Java的抽象類概念非常相似。兩種語言中，抽象類都可以包含抽象方法和具體方法，都不能被實例化，都可以被其他類繼承。

接口 vs 抽象類

讓我們比較一下接口和抽象類的主要區別：

1. 多重繼承：

   • C#類可以實現多個接口，但只能繼承一個類（包括抽象類）。
   • Java的情況相同。

2. 成員類型：

   • C# 8.0之前，接口只能包含方法、屬性、事件和索引器的簽名。
   • C# 8.0及以后，接口可以包含默認實現、靜態成員和私有成員。
     -抽象類可以包含字段、構造函數、析構函數，以及實現方法。

3. 訪問修飾符：

   • 接口成員默認是公共的，不能有私有成員（C# 8.0之前）。
   • 抽象類可以有各種訪問修飾符的成員。

4. 構造函數：

   • 接口不能包含構造函數。
   • 抽象類可以包含構造函數。

5. 密封成員：

   • 接口不能有密封成員。
   • 抽象類可以包含密封方法，防止它們被重寫。

何時使用接口，何時使用抽象類？

1. 使用接口當：

   • 你想定義一個能力或行為，而不關心實現細節。
   • 你需要多重繼承。
   • 你想在不相關的類之間定義共同的行為。

2. 使用抽象類當：

   • 你想定義一個模板，其中包含一些共同的實現。
   • 你需要在相關的類之間共享代碼。
   • 你需要定義非公共的成員。

實際應用示例

讓我們看一個更復雜的例子，展示接口和抽象類的結合使用：

public interface IPayable
{decimalCalculatePay();
}public abstract class Employee : IPayable
{public string Name { get; set; }public int Id { get; set; }protected Employee(string name, int id){Name = name;Id = id;}public abstract decimal CalculatePay();public virtual void DisplayInfo(){Console.WriteLine($"Employee: {Name}, ID: {Id}");}
}public class FullTimeEmployee : Employee
{public decimal MonthlySalary { get; set; }public FullTimeEmployee(string name, int id, decimal monthlySalary) : base(name, id){MonthlySalary = monthlySalary;}public override decimal CalculatePay(){return MonthlySalary;}
}public class PartTimeEmployee : Employee
{public decimal HourlyRate { get; set; }public int HoursWorked { get; set; }public PartTimeEmployee(string name, int id, decimal hourlyRate) : base(name, id){HourlyRate = hourlyRate;}public override decimal CalculatePay(){return HourlyRate * HoursWorked;}public override void DisplayInfo(){base.DisplayInfo();Console.WriteLine($"Hourly Rate: {HourlyRate}");}
}public class Contractor : IPayable
{public string Name { get; set; }public decimal ContractAmount { get; set; }public Contractor(string name, decimal contractAmount){Name = name;ContractAmount = contractAmount;}public decimal CalculatePay(){return ContractAmount;}
}// 使用示例
public class PayrollSystem
{public void ProcessPayroll(List<IPayable> payables){foreach (var payable in payables){Console.WriteLine($"Paying {payable.CalculatePay():C}");if (payable is Employee employee){employee.DisplayInfo();}}}
}// 主程序
class Program
{static void Main(string[] args){var payables = new List<IPayable>{new FullTimeEmployee("Alice", 1, 5000m),new PartTimeEmployee("Bob", 2, 20m) { HoursWorked = 80 },new Contractor("Charlie", 3000m)};var payrollSystem = new PayrollSystem();payrollSystem.ProcessPayroll(payables);}
}