C#基础篇（04）什么是面向对象编程？

面向对象编程(Object-Oriented Programming, OOP)是C#的核心编程范式，它通过"对象"的概念来组织代码和数据。以下是C#中面向对象编程的全面介绍：

一、面向对象编程的四大支柱

1. 封装 (Encapsulation)

• 将数据(字段)和操作数据的方法(函数)捆绑在一起
• 通过访问修饰符控制访问级别：
  • public：完全公开访问
  • private：仅类内部可访问(默认)
  • protected：类内部和派生类可访问
  • internal：同一程序集内可访问

public class BankAccount
{
    private decimal _balance; // 私有字段
    
    public decimal GetBalance() // 公开方法
    {
        return _balance;
    }
    
    public void Deposit(decimal amount)
    {
        if(amount > 0)
            _balance += amount;
    }
}

2. 继承 (Inheritance)

• 子类继承父类的特征和行为
• 实现代码重用和层次分类
• C#只支持单继承(一个类只能继承一个父类)

public class Animal  // 基类
{
    public void Eat() => Console.WriteLine("Eating...");
}

public class Dog : Animal  // 派生类
{
    public void Bark() => Console.WriteLine("Woof!");
}

3. 多态 (Polymorphism)

• 同一操作作用于不同对象可以有不同的行为
• 通过虚方法/抽象方法/接口实现

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

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

4. 抽象 (Abstraction)

• 隐藏复杂实现细节，只暴露必要功能
• 通过抽象类和接口实现

public abstract class Vehicle
{
    public abstract void Move();  // 抽象方法
}

public class Car : Vehicle
{
    public override void Move() => Console.WriteLine("Car is moving");
}

二、C#中的OOP核心概念

1. 类和对象

• ​类​：对象的蓝图/模板
• ​对象​：类的具体实例

// 定义类
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// 创建对象
Person person1 = new Person { Name = "Alice", Age = 25 };

2. 构造函数

• 用于初始化对象
• 可以有多个(构造函数重载)

public class Rectangle
{
    public int Width { get; }
    public int Height { get; }
    
    public Rectangle() : this(1, 1) {}  // 调用另一个构造函数
    
    public Rectangle(int width, int height)
    {
        Width = width;
        Height = height;
    }
}

3. 属性和字段

• ​字段​：存储数据的变量
• ​属性​：控制对字段的访问

public class Student
{
    private string _name;  // 字段
    
    public string Name    // 属性
    {
        get => _name;
        set => _name = value ?? throw new ArgumentNullException(nameof(value));
    }
}

4. 方法

• 类中定义的行为/功能

public class Calculator
{
    public int Add(int a, int b) => a + b;
    
    public double Add(double a, double b) => a + b;  // 方法重载
}

5. 静态成员

• 属于类而非特定实例

public class MathUtility
{
    public static double PI => 3.14159;
    
    public static int Square(int x) => x * x;
}

// 使用
double pi = MathUtility.PI;
int squared = MathUtility.Square(5);

三、高级OOP特性

1. 接口 (Interface)

• 定义契约而不提供实现
• 类可以实现多个接口

public interface ILogger
{
    void Log(string message);
}

public class FileLogger : ILogger
{
    public void Log(string message) => File.AppendAllText("log.txt", message);
}

2. 抽象类 (Abstract Class)

• 不能实例化，只能被继承
• 可以包含抽象方法和具体实现

public abstract class Animal
{
    public abstract void MakeSound();
    
    public void Sleep() => Console.WriteLine("Sleeping...");
}

public class Cat : Animal
{
    public override void MakeSound() => Console.WriteLine("Meow!");
}

3. 密封类 (Sealed Class)

• 不能被继承

public sealed class FinalClass
{
    // 类成员
}

4. 部分类 (Partial Class)

• 类的定义可以拆分到多个文件中

// File1.cs
public partial class MyClass
{
    public void Method1() { ... }
}

// File2.cs
public partial class MyClass
{
    public void Method2() { ... }
}

四、OOP设计原则

1. ​单一职责原则(SRP)​​：一个类应该只有一个改变的理由
2. ​开放-封闭原则(OCP)​​：对扩展开放，对修改封闭
3. ​里氏替换原则(LSP)​​：子类应该能够替换其父类
4. ​接口隔离原则(ISP)​​：客户端不应被迫依赖它们不使用的接口
5. ​依赖倒置原则(DIP)​​：依赖抽象而非具体实现

五、C#特有的OOP特性

1. ​属性​：比Java等语言的getter/setter更优雅的实现
2. ​索引器​：使对象可以像数组一样被访问
3. ​运算符重载​：自定义运算符行为
4. ​扩展方法​：在不修改类的情况下添加新方法
5. ​记录类型(C# 9+)​​：不可变数据类型的简洁语法

// 记录类型示例
public record Person(string FirstName, string LastName);

面向对象编程是C#的基石，掌握这些概念可以帮助你编写更模块化、可维护和可扩展的代码。