【C#】面向对象的三大特性，还记得吗，简单代码举例回顾

全栈小5

于 2024-01-16 12:34:41 发布

阅读量1.3k

点赞数 30

分类专栏： C# 文章标签： c#

本文链接：https://blog.csdn.net/lmy_520/article/details/135616324

版权

C# 专栏收录该内容

128 篇文章 10 订阅

订阅专栏

欢迎来到《小5讲堂》
大家好，我是全栈小5。
这是《C#》序列文章，每篇文章将以博主理解的角度展开讲解，
特别是针对知识点的概念进行叙说，大部分文章将会对这些概念进行实际例子验证，以此达到加深对知识点的理解和掌握。
温馨提示：博主能力有限，理解水平有限，若有不对之处望指正！

在这里插入图片描述

基本概念

C# 面向对象的三大特性是封装、继承和多态。

封装
指将对象的某些内部状态和行为封装起来，只暴露必要的接口供其他对象使用，并且隐藏其实现细节，从而保证了对象的安全性和可维护性。
继承
指通过继承一个已有的类来创建一个新类，新类继承了父类的属性和方法，并可以新增或重写一些方法，从而在代码复用和扩展性方面提供了便利。
多态
指同一种类型的对象，在不同的情况下，可以有不同的状态和行为。在面向对象编程中，多态通常通过继承和接口实现。

封装

假设Person 类定义了两个私有字段 name 和 age，它们被封装在类的内部，外部无法直接访问。
为了对外提供对这些私有字段的访问和设置，在类中定义了公开的访问器和设置器 (getter 和 setter)。

通过访问器 (getter)，可以获取私有字段的值；通过设置器 (setter)，可以给私有字段赋值。
这样，可以在类的外部使用这些访问器和设置器来访问和修改私有字段的值，同时可以在访问和设置的过程中加入相应的逻辑控制。

在 Main 方法中，创建了一个 Person 对象，使用设置器给对象的 name 和 age 字段赋值，然后使用 ShowInfo() 方法来展示这些字段的值。
通过封装，将字段的访问和修改限制在了类的内部，避免了直接操作字段的不良影响，并提供了控制和保护字段的能力。

using System;

// 定义一个类
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 ShowInfo()
    {
        Console.WriteLine($"姓名：{name}，年龄：{age}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Person person = new Person();
        person.Name = "张三";
        person.Age = 25;
        person.ShowInfo();  // 输出：姓名：张三，年龄：25
    }
}

继承

假设Vehicle 类是一个父类，拥有一个构造函数和一个 ShowInfo() 方法。
Car 类则是 Vehicle 类的子类，通过继承 Vehicle 类，Car 类继承了父类的属性和方法，并添加了自己的私有字段 price 和 ShowPrice() 方法。

在 Main 方法中，创建了一个 Car 对象，并调用了其父类继承的 ShowInfo() 方法和自己添加的 ShowPrice() 方法。
通过继承，可以直接使用父类的代码，减少了重复编写相似代码的工作量，并且可以根据需求在子类中进行功能扩展。

using System;

// 定义一个父类
class Vehicle
{
    protected string brand;
    protected int year;

    public Vehicle(string brand, int year)
    {
        this.brand = brand;
        this.year = year;
    }

    public void ShowInfo()
    {
        Console.WriteLine($"品牌：{brand}，年份：{year}");
    }
}

// 定义一个子类，继承自父类
class Car : Vehicle
{
    private int price;

    public Car(string brand, int year, int price) : base(brand, year)
    {
        this.price = price;
    }

    public void ShowPrice()
    {
        Console.WriteLine($"价格：{price}万元");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Car car = new Car("奥迪", 2022, 30);
        car.ShowInfo();   // 输出：品牌：奥迪，年份：2022
        car.ShowPrice();  // 输出：价格：30万元
    }
}

多态

假设Animal 类定义了一个虚方法 MakeSound()，并且该方法被派生类 Dog 和 Cat 分别重写了。
当分别使用 Animal、Dog 和 Cat 类型的对象调用 MakeSound() 方法时，根据对象的实际类型，运行时会自动选择适当的方法去执行。
这就是多态的体现，同一种类型的对象在不同的情况下表现出不同的行为。

using System;

// 定义一个动物类
class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("动物发出声音");
    }
}

// 定义一个狗类，继承自动物类
class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("狗叫：汪汪汪!");
    }
}

// 定义一个猫类，继承自动物类
class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("猫叫：喵喵喵!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal animal1 = new Animal();  // 创建动物对象
        Animal animal2 = new Dog();     // 创建狗对象
        Animal animal3 = new Cat();     // 创建猫对象

        animal1.MakeSound();  // 输出：动物发出声音
        animal2.MakeSound();  // 输出：狗叫：汪汪汪!
        animal3.MakeSound();  // 输出：猫叫：喵喵喵!
    }
}