概述

部分类

  • C# 的部分类(partial class)允许把同一个类拆分到多个文件中定义, 这些文件在编译时会被合并成一个完整的类.

抽象类和抽象方法

抽象类的特点：

  1. 不能被实例化
  2. 可以包含抽象方法（没有方法体）
  3. 子类必须实现抽象方法
  4. 可以包含普通方法（有方法体）
抽象类和抽象方法
using System;

// 抽象类
public abstract class Animal
{
    public abstract void Speak();

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

// 子类 Dog
public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Dog: Woof!");
    }
}

// 子类 Cat
public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Cat: Meow!");
    }
}

class Program
{
    static void Main()
    {
        // Animal a = new Animal(); // ❌ 错误：不能实例化抽象类

        Animal dog = new Dog();
        dog.Speak(); // Dog: Woof!
        dog.Eat();   // Animal is eating...

        Animal cat = new Cat();
        cat.Speak(); // Cat: Meow!
        cat.Eat();   // Animal is eating...
    }
}

密封类和密封方法

  • C# 的密封类是一种不能被继承的类.
密封类和密封方法
using System;

// 密封类
public sealed class Logger
{
    public void Log(string message)
    {
        Console.WriteLine($"[LOG] {message}");
    }
}

// 父类
public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaking");
    }
}

// 子类：重写并密封方法
public class Dog : Animal
{
    public sealed override void Speak()
    {
        Console.WriteLine("Dog barking");
    }
}

// 尝试重写（会报错）
// public class SmallDog : Dog
// {
//     public override void Speak() { } // ❌ 编译错误
// }

class Program
{
    static void Main()
    {
        // 使用密封类
        var logger = new Logger();
        logger.Log("System started");

        // 使用密封方法的类
        Animal a = new Dog();
        a.Speak();
    }
}

方法

  1. csharp 可以重写方法和属性, 但是静态方法不能重写.
  2. 只能使用 override 重写基类中的虚方法, 不能重写普通方法, 可以使用 new 隐藏基类中的方法.
普通方法的隐藏
虚方法的重写
class myBaseClass {
    public void Print() {
        Console.WriteLine("This is the base class.");
    }
}

class MyDerivedClass : myBaseClass {
    // 使用与基类成员名称相同的成员来屏蔽基类成员.
    // new 关键字显式告诉编译器隐藏一个基类成员.
    new public void Print() {
        Console.WriteLine("This is the derived class.");
    }
}

class Program {
    static void Main() {
        MyDerivedClass derived = new MyDerivedClass();
        myBaseClass myBase = (myBaseClass)derived;
        derived.Print();
        myBase.Print();
    }
}

class myBaseClass {
    virtual public void Print() {
        Console.WriteLine("This is the base class.");
    }
}

class MyDerivedClass : myBaseClass {
    // 使用与基类成员名称相同的成员来屏蔽基类成员.
    // override 关键字.
    override public void Print() {
        Console.WriteLine("This is the derived class.");
    }
}

class Program {
    static void Main() {
        MyDerivedClass derived = new MyDerivedClass();
        myBaseClass myBase = (myBaseClass)derived;
        derived.Print();
        myBase.Print();
    }
}

扩展方法

  • C# 的扩展方法（Extension Methods）允许你在不修改原类型、不继承它的情况下，为现有类型“添加新方法”.
  • 扩展方法必须放在 静态类 中，并且方法必须是 静态方法 ，第一个参数前加 this.
扩展方法
using System;
using System.Collections.Generic;
using MyExtensions;

namespace MyExtensions
{
    public static class ListExtensions
    {
        public static double AverageValue(this List<int> list)
        {
            if (list == null || list.Count == 0)
                return 0;

            double sum = 0;
            foreach (var n in list)
                sum += n;

            return sum / list.Count;
        }
    }
}

class Program
{
    static void Main()
    {
        var numbers = new List<int> { 10, 20, 30, 40 };

        // 引入扩展方法命名空间
        double avg = numbers.AverageValue();

        Console.WriteLine($"平均值是: {avg}");
    }
}
+ 在线测试