C#中的方法上部

方法重载

在C#中，方法重载（Method Overloading）是一种允许在同一个类中定义多个同名方法，但参数列表不同的特性。参数列表不同可以是参数的类型不同、参数的数量不同，或者是两者都不同。方法重载使得调用者可以根据需要选择正确的方法版本。

方法重载的规则：

1. 方法名相同：重载的方法必须在同一个类或结构体中，并且方法名相同。

2. 参数列表不同：参数的数量、类型或顺序必须至少有一个不同。

3. 返回类型不参与重载：方法的返回类型不参与重载决策，即不能仅通过返回类型来区分重载的方法。

4. 访问修饰符不参与重载：方法的访问修饰符（如 public、private 等）也不参与重载决策。

示例代码

下面是一个简单的示例，展示如何在C#中实现方法重载：

using System;
​
class Program
{
    static void Main()
    {
        // 调用重载方法
        Print(5);
        Print(5, 10);
        Print("Hello, World!");
    }
​
    // 重载方法1：接受一个整数参数
    static void Print(int number)
    {
        Console.WriteLine("Printing int: " + number);
    }
​
    // 重载方法2：接受两个整数参数
    static void Print(int number1, int number2)
    {
        Console.WriteLine("Printing two ints: " + number1 + " and " + number2);
    }
​
    // 重载方法3：接受一个字符串参数
    static void Print(string text)
    {
        Console.WriteLine("Printing string: " + text);
    }
}

输出

Printing int: 5
Printing two ints: 5 and 10
Printing string: Hello, World!

注意事项

• 方法选择：在编译时，编译器会根据方法调用时提供的参数类型和数量来确定调用哪个重载的方法。

• 参数类型转换：如果参数可以通过隐式类型转换匹配到某个重载版本，那么该版本会被调用。例如，如果有一个接受 int 参数的方法和一个接受 double 参数的方法，传递一个整数 5 时，可能会调用任何一个方法，具体取决于编译器的决策。

• 参数默认值：不能仅通过参数的默认值来区分重载的方法。例如，不能有一个方法定义为 void Method(int a = 0) 和另一个定义为 void Method(int a)。

方法重载是C#中一个非常有用的功能，它提高了代码的可读性和灵活性。

方法重写

在C#中，方法重写（Method Overriding）是面向对象编程中的一个核心概念，它允许派生类（子类）提供一个与基类（父类）中具有相同名称、相同参数列表和相同返回类型的方法的具体实现。方法重写是多态性的一种表现，它使得派生类可以改变从基类继承来的方法的行为。

方法重写的关键点：

1. 继承：方法重写发生在继承的上下文中，即派生类重写基类中的方法。

2. 方法签名：重写的方法必须具有与基类中被重写方法完全相同的签名，包括方法名、参数列表和返回类型。

3. 访问修饰符：派生类中重写的方法不能拥有比基类方法更严格的访问修饰符。

4. virtual/override关键字：基类中的方法需要用 virtual 关键字声明，而派生类中的方法则用 override 关键字来实现。

示例代码

下面是一个简单的示例，展示如何在C#中实现方法重写：

using System;
​
class BaseClass
{
    // 声明一个虚拟方法
    public virtual void Display()
    {
        Console.WriteLine("Display method of BaseClass");
    }
}
​
class DerivedClass : BaseClass
{
    // 重写基类中的虚拟方法
    public override void Display()
    {
        Console.WriteLine("Display method of DerivedClass");
    }
}
​
class Program
{
    static void Main()
    {
        BaseClass baseObj = new BaseClass();
        DerivedClass derivedObj = new DerivedClass();
​
        baseObj.Display();       // 输出：Display method of BaseClass
        derivedObj.Display();    // 输出：Display method of DerivedClass
​
        // 多态性示例
        BaseClass obj = new DerivedClass();
        obj.Display();           // 输出：Display method of DerivedClass
    }
}

输出

Display method of BaseClass
Display method of DerivedClass
Display method of DerivedClass

注意事项

• 抽象方法：基类也可以声明抽象方法（使用 abstract 关键字），这意味着基类不提供方法的实现，而派生类必须提供实现。

• new关键字：如果派生类想要隐藏继承的方法而不是重写它，可以使用 new 关键字。这在某些情况下是有用的，比如当你想要避免意外地重写方法时。

• 方法调用：在多态的情况下，即通过基类引用调用方法时，实际执行的是派生类中重写的方法（如果存在的话）。

方法重写是实现多态性的关键机制，它允许派生类根据需要改变继承自基类的行为。

多态

多态性（Polymorphism）是面向对象编程（OOP）的一个核心概念，它允许你以一种统一的接口来处理不同类型的对象。在C#中，多态性可以通过方法重写（Method Overriding）和方法重载（Method Overloading）来实现。多态性使得代码更加灵活和可扩展。

多态性的类型

1. 编译时多态（静态多态）：通过方法重载实现。

2. 运行时多态（动态多态）：通过方法重写和接口实现来实现。

运行时多态的关键点

1. 继承：子类继承父类。

2. 方法重写：子类重写父类的方法。

3. 父类引用：使用父类的引用来引用子类的对象。

4. 虚方法和重写方法：父类中的方法使用 virtual 关键字声明，子类中的方法使用 override 关键字实现。

示例代码

下面是一个示例，展示如何在C#中实现运行时多态：

using System;
​
class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Some sound");
    }
}
​
class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}
​
class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Meow");
    }
}
​
class Program
{
    static void Main()
    {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
​
        myDog.MakeSound();  // 输出：Bark
        myCat.MakeSound();  // 输出：Meow
​
        // 多态性示例：使用父类数组
        Animal[] animals = new Animal[] { myDog, myCat };
        foreach (Animal animal in animals)
        {
            animal.MakeSound();  // 输出：Bark 和 Meow
        }
    }
}

输出

Bark
Meow
Bark
Meow

说明

• 基类 Animal：定义了一个虚方法 MakeSound。

• 派生类 Dog 和 Cat：分别重写了 MakeSound 方法。

• 多态性：使用 Animal 类型的引用来引用 Dog 和 Cat 对象，并调用 MakeSound 方法。实际调用的方法取决于对象的实际类型。

接口实现的多态性

除了方法重写，多态性还可以通过接口实现来实现：

using System;
​
interface IAnimal
{
    void MakeSound();
}
​
class Dog : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}
​
class Cat : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Meow");
    }
}
​
class Program
{
    static void Main()
    {
        IAnimal myDog = new Dog();
        IAnimal myCat = new Cat();
​
        myDog.MakeSound();  // 输出：Bark
        myCat.MakeSound();  // 输出：Meow
​
        // 多态性示例：使用接口数组
        IAnimal[] animals = new IAnimal[] { myDog, myCat };
        foreach (IAnimal animal in animals)
        {
            animal.MakeSound();  // 输出：Bark 和 Meow
        }
    }
}

输出

Bark
Meow
Bark
Meow

总结

多态性使得你可以编写更加通用和灵活的代码，通过统一的接口来处理不同类型的对象。在C#中，多态性主要通过方法重写和接口实现来实现，从而提高代码的可维护性和可扩展性。

方法重写和重载的区别

方法重写（Method Overriding）和方法重载（Method Overloading）是面向对象编程中两个非常重要的概念，它们都涉及到方法的声明，但用途和规则有所不同。以下是它们的主要区别：

方法重载（Method Overloading）

1. 同一类中：发生在同一个类中。

2. 方法名相同：重载的方法必须有相同的方法名。

3. 参数列表不同：参数的数量、类型或顺序必须至少有一个不同。

4. 返回类型无关：方法的返回类型不影响重载决策。

5. 编译时解析：编译器在编译时根据方法的参数列表来确定调用哪个方法。

6. 目的：允许你为同一个操作提供多个实现，这些操作的参数类型或数量不同。

方法重写（Method Overriding）

1. 继承关系中：发生在派生类与其基类之间。

2. 方法名和参数列表相同：重写的方法必须有与基类中被重写的方法相同的方法名和参数列表。

3. 访问修饰符限制：派生类中重写的方法不能拥有比基类方法更严格的访问修饰符。

4. 返回类型限制：派生类中重写的方法返回类型必须与基类方法返回类型相同或者是其派生类型。

5. 运行时多态：在运行时，根据对象的实际类型来调用相应的方法。

6. 目的：允许派生类提供基类方法的具体实现，改变继承来的方法的行为。

示例

方法重载示例：

class Calculator
{
    // 重载方法：加法运算，两个整数
    public int Add(int a, int b)
    {
        return a + b;
    }
​
    // 重载方法：加法运算，三个整数
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }
}

方法重写示例：

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Some sound");
    }
}
​
class Dog : Animal
{
    // 重写基类方法
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}

总结

• 方法重载是同一个类中方法名相同但参数列表不同的方法。

• 方法重写是派生类中与基类具有相同方法名和参数列表的方法，它改变了基类方法的行为。