.NET 面向对象 - 封装、继承与多态

class Student
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void Study()
    {
        Console.WriteLine($"{Name} is studying.");
    }
}

var Misaka = new Student { Name = "Misaka", Age = 14 };
Misaka.Study(); // 输出: Misaka is studying.

class Person(int age)
{
    private int age = age; // 年龄是私有的，外部无法直接访问

    public bool IsAdult()  // 通过一个公共方法来判断是否是成年人
    {
        return age >= 18;
    }
}

class Example
{
    private int _field; // 字段
    public int Property { get; set; } // 属性
}

class Person
{
    private int _age; // 私有字段

    public int Age // 公共属性
    {
        get => _age; // 访问器：获取年龄
        set
        {
            if (value < 0) // 验证输入
                throw new ArgumentException("Age cannot be negative.");
            _age = value; // 设置年龄
        }
    }
}

class Person
{
    public int Age {
        get;
        set => field = (value >= 0)
            ? value
            : throw new ArgumentOutOfRangeException(nameof(value), "Age cannot be negative.");
    }
}

// 错误的设计
class PasswordManager
{
    private string _password;

    public string Password
    {
        set => _password = value; // 只写属性，设置密码
    }

    public bool VerifyPassword(string input)
    {
        return input == _password; // 验证密码的方法
    }
}

class Person
{
    public string Name { get; init; } // 只能在对象初始化时设置
}

var person = new Person { Name = "Alice" };
person.Name = "Bob"; // 无法修改 Name 属性

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void Eat()
    {
        Console.WriteLine($"{Name} is eating.");
    }
}

class Student : Person // Student 继承自 Person
{
    public string School { get; set; }

    public void Study()
    {
        Console.WriteLine($"{Name} is studying at {School}.");
    }
}

class Person
{
    public string Name { get; }
    public int Age { get; }

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

// 传统写法
class Student : Person
{
    public string School { get; }

    // 借助 base 关键字调用基类的构造函数
    public Student(string name, int age, string school) : base(name, age)
    {
        School = school;
    }
}

// 现代写法
class Student(string name, int age, string school) : Person(name, age)
{
    public string School { get; } = school;
}

abstract class Animal
{
    public abstract void MakeSound(); // 抽象方法，没有实现
}

class Dog : Animal
{
    public override void MakeSound() // 实现抽象方法
    {
        Console.WriteLine("Woof!");
    }
}

// 定义接口
public interface ILogger
{
    // 类必须实现它
    void Log(string message);

    // 默认接口方法
    // 现有的实现类（如 ConsoleLogger）不需要修改代码也能直接“继承”这个功能
    void LogError(string message) 
    {
        Console.WriteLine($"[ERROR]: {message}");
    }
}

// 现有的实现类，只实现了 Log 方法
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[INFO]: {message}");
    }
}

class Program
{
    static void Main()
    {
        ILogger logger = new ConsoleLogger();
        
        // 调用普通接口方法
        logger.Log("这是一个日志消息");

        // 调用默认接口方法
        // 注意：默认方法只能通过接口变量调用，不能通过类变量调用
        logger.LogError("这是一个错误消息");
    }
}

sealed class FinalClass
{
    public void DoSomething()
    {
        Console.WriteLine("This class cannot be inherited.");
    }
}

// 报错 CS0509 'DerivedClass': cannot derive from sealed type 'FinalClass'
class DerivedClass : FinalClass
{
    public void DoSomethingElse()
    {
        Console.WriteLine("This will never compile.");
    }
}

class Engine
{
    public void Start() => Console.WriteLine("Engine started.");
}

class Car
{
    private Engine _engine = new Engine(); // 组合关系

    public void Start()
    {
        _engine.Start(); // 使用组合的对象来实现功能
        Console.WriteLine("Car started.");
    }
}

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape.");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

class Square : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a square.");
    }
}

void DrawShape(Shape shape)
{
    shape.Draw(); // 多态调用，根据实际类型调用对应的 Draw 方法
}

class Base
{
    public virtual void Method()
    {
        Console.WriteLine("Base implementation.");
    }
}

class Derived : Base
{
    // 重写基类的虚方法，提供新的实现，但不是必须的
    public override void Method()
    {
        Console.WriteLine("Derived implementation.");
    }
}

class Base
{
    public void Method()
    {
        Console.WriteLine("Base implementation.");
    }
}

class Derived : Base
{
    // 使用 new 关键字隐藏基类的方法，而不是重写它
    public new void Method()
    {
        Console.WriteLine("Derived implementation.");
    }
}

Base baseObj = new Derived();

// 如果是 override，那么调用的是 Derived 的 Method 方法，输出 "Derived implementation."
// 如果是 new，那么调用的是 Base 的 Method 方法，输出 "Base implementation."
baseObj.Method();

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

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

Animal myAnimal = new Dog();
myAnimal.Speak(); // 输出: "Dog barks"

public interface IPaymentProcessor
{
    bool ProcessPayment(decimal amount);
}

public class PayPalProcessor : IPaymentProcessor
{
    public bool ProcessPayment(decimal amount)
    {
        // PayPal-specific implementation
        return true;
    }
}

public class StripeProcessor : IPaymentProcessor
{
    public bool ProcessPayment(decimal amount)
    {
        // Stripe-specific implementation
        return true;
    }
}

public abstract class BasePaymentGateway : IPaymentProcessor
{
    public bool ProcessPayment(decimal amount)
    {
        // 处理共性逻辑，如日志、重试等
        LogPaymentAttempt(amount);
        
        // 调用抽象方法执行具体的支付逻辑
        return ExecuteTransactionCore(amount);
    }

    protected abstract bool ExecuteTransactionCore(decimal amount);

    private void LogPaymentAttempt(decimal amount)
    {
        // 记录支付尝试的日志
    }
}

public class PayPalGateway : BasePaymentGateway
{
    protected override bool ExecuteTransactionCore(decimal amount)
    {
        // PayPal-specific transaction logic
        return true;
    }
}

public class StripeGateway : BasePaymentGateway
{
    // 同时借助修饰符来封装了 Stripe 的 API 密钥等敏感信息，使得它们只能在 StripeGateway 类内部访问。
    private readonly string _apiKey;

    protected override bool ExecuteTransactionCore(decimal amount)
    {
        // Stripe-specific transaction logic
        return true;
    }
}

public class PaymentService
{
    private readonly IPaymentProcessor _paymentProcessor;

    public PaymentService(IPaymentProcessor paymentProcessor)
    {
        _paymentProcessor = paymentProcessor;
    }

    public void MakePayment(decimal amount)
    {
        if (_paymentProcessor.ProcessPayment(amount))
        {
            Console.WriteLine("Payment successful.");
        }
        else
        {
            Console.WriteLine("Payment failed.");
        }
    }
}