C#面向对象特征的具体实现及作用详解

面向对象的三大特征

在C#编程中，实现面向对象编程的三大特征是：封装、继承和多态。

封装

封装是一种将数据和代码进行合理组织的过程。对于一个类来说，封装意味着将数据和方法打包在一起，控制数据的访问级别以及提供对数据的安全访问。在C#中，可以通过访问修饰符限制属性和方法的访问级别，达到封装的目的。

继承

继承是一种允许一个类从另一个类中继承数据和方法的过程。C#中使用class关键字定义类，并使用冒号符号指定基类。派生类可以调用基类的方法和属性，也可以覆盖基类的方法或者扩展基类的功能。

例如：

class Animal {
    public void Voice() {
        Console.WriteLine("Animal is making voice.");
    }
}

class Cat : Animal {
    public void CatchMouse() {
        Console.WriteLine("Cat is catching mouse.");
    }
}

class Dog : Animal {
    public void WatchDoor() {
        Console.WriteLine("Dog is watching door.");
    }
}

在上述代码中，Cat和Dog类都继承自Animal类，可以调用基类的方法Voice()，同时还可以扩展自己的功能。

多态

多态是一种允许一个类表现出多种形态的过程。在C#中，多态可以通过重载和覆盖来实现。重载是指在一个类中定义多个同名的方法，在调用时根据传入的参数类型或数量来选择不同的重载方法；覆盖是指派生类覆盖基类的虚方法或抽象方法，从而实现多态。

例如：

class Person {
    public virtual void Say() {
        Console.WriteLine("Person is saying something.");
    }
}

class Student : Person {
    public override void Say() {
        Console.WriteLine("Student is saying something.");
    }
}

class Teacher : Person {
    public override void Say() {
        Console.WriteLine("Teacher is saying something.");
    }
}

在上述代码中，Person类定义了一个虚方法Say()，而Student和Teacher类分别覆盖了这个方法。当对Student或Teacher的实例调用Say()方法时，会根据具体的对象类型调用不同的实现。

示例说明

示例一：汽车销售系统

假设我们正在开发一个汽车销售系统，其中需要实现车辆的销售和维修功能。为了达到良好的可维护性和可扩展性，我们需要将车辆和维修工这两个实体进行封装。

public class Vehicle {
    private string model;
    private double price;
    private string manufacturer;

    public string Model { get => model; set => model = value; }
    public double Price { get => price; set => price = value; }
    public string Manufacturer { get => manufacturer; set => manufacturer = value; }

    public Vehicle(string model, double price, string manufacturer) {
        this.model = model;
        this.price = price;
        this.manufacturer = manufacturer;
    }

    public void Sell() {
        Console.WriteLine("The vehicle is sold.");
    }
}

public class Repairman {
    private string name;
    private int age;

    public string Name { get => name; set => name = value; }
    public int Age { get => age; set => age = value; }

    public Repairman(string name, int age) {
        this.name = name;
        this.age = age;
    }

    public void Repair(Vehicle vehicle) {
        Console.WriteLine("The vehicle is repaired by {0}.", this.name);
    }
}

在上述代码中，我们将车辆和维修工分别封装成了Vehicle和Repairman类。Vehicle类包含了车辆的基本信息以及销售方法Sell()，而Repairman类包含了维修工的基本信息以及维修方法Repair()。维修方法接收一个Vehicle类型的参数，可以将修理过程中需要用到的车辆信息作为参数传递进来。

示例二：多态实现图形绘制

假设我们正在开发一个图形绘制工具，其中包含了多种图形的绘制功能，例如矩形、圆形、三角形等。为了实现多态，我们需要定义Shape类作为基类，并在派生类中实现具体的图形绘制方法。

public abstract class Shape {
    public abstract void Draw();
}

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

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

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

在上述代码中，我们定义了一个抽象类Shape作为基类，并在其中定义了一个抽象方法Draw()。派生类Rectangle、Circle和Triangle分别实现了Draw()方法，从而实现了多态。当需要绘制一个具体的图形时，只需要创建该图形的实例，并调用其Draw()方法即可。

例如：

Shape shape = new Rectangle();
shape.Draw(); // 输出：Drawing a rectangle.

shape = new Circle();
shape.Draw(); // 输出：Drawing a circle.

shape = new Triangle();
shape.Draw(); // 输出：Drawing a triangle.