C#入門-Day8：物件導向

類別（Class）

類別是 C# 中的基本構造，用於封裝數據和行為。類別是對象的藍圖，可以包含字段、屬性、方法和事件。

using System;

public class Person
{
    // 字段
    private string name;
    private int age;

    // 屬性
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    public int Age
    {
        get { return age; }
        set { age = value; }
    }

    // 方法
    public void Greet()
    {
        Console.WriteLine($"Hello, my name is {name} and I am {age} years old.");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Person person = new Person();
        person.Name = "Alice";
        person.Age = 30;
        person.Greet();  // Output: Hello, my name is Alice and I am 30 years old.
    }
}

繼承（Inheritance）

繼承允許類別從另一個類別派生，繼承其字段和方法。C# 支持單繼承，但可以實現多個介面。

using System;

public class Animal
{
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine("Barking...");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Dog dog = new Dog();
        dog.Eat();  // Output: Eating...
        dog.Bark();  // Output: Barking...
    }
}

多型（Polymorphism）

多型允許對象通過父類或介面類型來呼叫方法，行為由實際對象決定。這通常通過方法重寫（override）實現。

using System;

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal sound");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Bark");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Animal animal = new Dog();
        animal.Speak();  // Output: Bark
    }
}

封裝（Encapsulation）

封裝是將數據和方法封裝在類別內部，通過屬性和方法來控制對它們的訪問。

using System;

public class Account
{
    private double balance;

    public double Balance
    {
        get { return balance; }
        private set { balance = value; }
    }

    public void Deposit(double amount)
    {
        if (amount > 0)
        {
            Balance += amount;
        }
    }

    public void Withdraw(double amount)
    {
        if (amount > 0 && amount <= Balance)
        {
            Balance -= amount;
        }
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Account account = new Account();
        account.Deposit(100);
        account.Withdraw(30);
        Console.WriteLine(account.Balance);  // Output: 70
    }
}

介面（Interface）

介面定義了成員的簽名，不包含實現。類別可以實現介面，提供這些成員的具體實現。

using System;

public interface IAnimal
{
    void Speak();
}

public class Dog : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("Bark");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        IAnimal animal = new Dog();
        animal.Speak();  // Output: Bark
    }
}

抽象類別（Abstract Class）

抽象類別不能實例化，可以包含抽象方法（無實現）和具體方法（有實現）。子類必須實現所有抽象方法。

using System;

public abstract class Animal
{
    public abstract void Speak();
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Bark");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Dog dog = new Dog();
        dog.Speak();  // Output: Bark
        dog.Eat();    // Output: Eating...
    }
}

靜態類別（Static Class）

靜態類別不能實例化，所有成員都必須是靜態的，常用於工具類或擴展方法。

using System;

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

public class Program
{
    public static void Main(string[] args)
    {
        int result = MathHelper.Add(3, 4);
        Console.WriteLine(result);  // Output: 7
    }
}

列舉（Enumerations）

列舉是一種特殊的數據類型，包含一組命名常數。

using System;

public enum DaysOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

public class Program
{
    public static void Main(string[] args)
    {
        DaysOfWeek today = DaysOfWeek.Monday;
        Console.WriteLine(today);  // Output: Monday
    }
}

委派（Delegates）

委派是一種類型安全的函數指標，允許方法作為參數傳遞。

using System;

public class Program
{
    public delegate void PrintDelegate(string message);

    public static void PrintMessage(string message)
    {
        Console.WriteLine(message);
    }

    public static void Main(string[] args)
    {
        PrintDelegate del = PrintMessage;
        del("Hello, delegate!");  // Output: Hello, delegate!
    }
}

Lambda 表達式

Lambda 表達式是匿名函數，用於簡潔地表示委派或表達式樹。

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var evenNumbers = numbers.Where(n => n % 2 == 0);

        foreach (var num in evenNumbers)
        {
            Console.WriteLine(num);  // Output: 2 4
        }
    }
}

泛型（Generics）

泛型允許類別、介面和方法在聲明時不指定特定的數據類型，增加了代碼的重用性和類型安全性。

using System;

public class GenericList<T>
{
    private T[] elements;
    private int count;

    public GenericList(int size)
    {
        elements = new T[size];
        count = 0;
    }

    public void Add(T element)
    {
        if (count < elements.Length)
        {
            elements[count++] = element;
        }
    }

    public T GetElement(int index)
    {
        if (index < count)
        {
            return elements[index];
        }
        throw new IndexOutOfRangeException();
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        GenericList<int> intList = new GenericList<int>(5);
        intList.Add(1);
        intList.Add(2);
        Console.WriteLine(intList.GetElement(1));  // Output: 2
    }
}

反射（Reflection）

反射允許在運行時檢查和操作類型的元數據。

using System;
using System.Reflection;

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

public class Program
{
    public static void Main(string[] args)
    {
        Type type = typeof(Person);
        Console.WriteLine($"Class: {type.Name}");

        PropertyInfo[] properties = type.GetProperties();
        foreach (PropertyInfo property in properties)
        {
            Console.WriteLine($"Property: {property.Name}");
        }

        MethodInfo method = type.GetMethod("Greet");
        Console.WriteLine($"Method: {method.Name}");

        object person = Activator.CreateInstance(type);
        type.GetProperty("Name").SetValue(person, "Alice");
        type.GetProperty("Age").SetValue(person, 30);
        method.Invoke(person, null);  // Output: Hello, my name is Alice and I am 30 years old.
    }
}