unity C#中的封装、继承和多态简单易懂的经典实例

news2024/10/5 20:24:19

文章目录

- - 封装 (Encapsulation)
  - 继承 (Inheritance)
  - 多态 (Polymorphism)

C#中的封装、继承和多态是面向对象编程（OOP）的三大核心特性。下面分别对这三个概念进行深入解释，并通过实例来说明它们在实际开发中的应用。

封装 (Encapsulation)

实例1：

public class BankAccount
{
    private decimal balance; // 私有变量，封装内部状态

    public BankAccount(decimal initialBalance)
    {
        this.balance = initialBalance;
    }

    // 公共方法，提供访问私有数据的受控方式
    public decimal GetBalance()
    {
        return balance;
    }

    public void Deposit(decimal amount)
    {
        if (amount > 0)
            balance += amount;
    }

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

在这个例子中，BankAccount 类封装了账户余额（balance），外部不能直接修改它，只能通过 Deposit 和 Withdraw 方法来进行操作，这样保证了数据的安全性和完整性。

继承 (Inheritance)

实例2：

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

    public virtual void Eat()
    {
        Console.WriteLine("动物正在吃东西...");
    }
}

public class Dog : Animal
{
    public bool IsTrained { get; set; }

    // 重写父类方法以提供更具体的行为
    public override void Eat()
    {
        Console.WriteLine("狗狗正在吃狗粮...");
    }

    public void Bark()
    {
        Console.WriteLine("狗狗在叫！");
    }
}

// 使用示例：
Dog myDog = new Dog() { Name = "小黑", Age = 3, IsTrained = true };
myDog.Eat(); // 输出 "狗狗正在吃狗粮..."
myDog.Bark(); // 输出 "狗狗在叫！"

在这里，Dog 类从 Animal 类继承而来，继承了其属性并重写了 Eat 方法，同时添加了一个独有的 Bark 方法，体现了“继承”带来的代码复用和扩展性。

多态 (Polymorphism)

实例3：

public abstract class Shape
{
    public abstract double Area();
}

public class Circle : Shape
{
    public double Radius { get; set; }

    public override double Area()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Square : Shape
{
    public double Side { get; set; }

    public override double Area()
    {
        return Side * Side;
    }
}

public static class Program
{
    public static void DisplayArea(Shape[] shapes)
    {
        foreach (var shape in shapes)
        {
            Console.WriteLine($"形状的面积为: {shape.Area()}");
        }
    }

    public static void Main()
    {
        var circle = new Circle() { Radius = 5 };
        var square = new Square() { Side = 10 };

        Shape[] shapes = { circle, square };
        DisplayArea(shapes); // 输出不同形状的具体面积
    }
}

此例中，Circle 和 Square 都是从抽象基类 Shape 派生出来的，它们都实现了 Area 抽象方法。在 DisplayArea 函数中，通过 Shape 类型的数组可以容纳不同类型的形状对象，这是多态性的体现，即同一接口(Area 方法)下不同的实现。

实例4（接口实现多态）：

public interface IRunnable
{
    void Run();
}

public class Car : IRunnable
{
    public void Run()
    {
        Console.WriteLine("汽车正在行驶...");
    }
}

public class Airplane : IRunnable
{
    public void Run()
    {
        Console.WriteLine("飞机正在飞行...");
    }
}

public static class Program
{
    public static void MakeRun(IRunnable vehicle)
    {
        vehicle.Run();
    }

    public static void Main()
    {
        Car car = new Car();
        Airplane airplane = new Airplane();

        MakeRun(car); // 输出 "汽车正在行驶..."
        MakeRun(airplane); // 输出 "飞机正在飞行..."
    }
}

这里展示了通过接口实现多态的例子。IRunnable 接口定义了一个通用行为 Run，尽管 Car 和 Airplane 的运行方式完全不同，但都可以实现这个接口，从而使得 MakeRun 方法能够处理任何实现了 IRunnable 的对象。

实例5（虚方法与动态绑定）：

public class BaseClass
{
    public virtual void ShowMessage()
    {
        Console.WriteLine("这是基础类的消息");
    }
}

public class DerivedClass : BaseClass
{
    public override void ShowMessage()
    {
        Console.WriteLine("这是派生类的消息");
    }
}

public static class Program
{
    public static void DisplayMessage(BaseClass obj)
    {
        obj.ShowMessage();
    }

    public static void Main()
    {
        BaseClass baseObj = new BaseClass();
        DerivedClass derivedObj = new DerivedClass();

        DisplayMessage(baseObj); // 输出 "这是基础类的消息"
        DisplayMessage(derivedObj); // 输出 "这是派生类的消息"，尽管传入的是基类引用
    }
}