C#类和字段

张秋雨

已于 2023-11-06 01:33:56 修改

阅读量50

点赞数

文章标签： c#

于 2023-11-05 21:03:20 首次发布

本文链接：https://blog.csdn.net/u010833969/article/details/134234834

版权

1.类

a.类的定义

类是一种数据结构，包含数据成员，函数成员（方法，属性，事件，索引器，运算符，构造函数，析构函数）和嵌套类型。

类支持继承，继承是一种使子类（派生类）可以对基类进行扩展和专用化的机制。

b.面向对象编程方法

封装，继承，对态性

1.封装，类是属性和方法的集合，为了实现某项功能而定义类后，使用这不需要了解类体内部每句代码的具体含义，只需要通过对象来调用类内某个属性和方法即可以实现功能

2.继承，通过继承可以创建子类（派生类）和父类之间的层次关系，子类（派生类）可以从其父类中继承属性和丰富，通过这种关系模型可以简化类的操作。

例：

如定义了A类，接下来准备定义B类，而B类中有很多属性和方法与A类相同，那么就可以使B类继承于A类。这样就无须再在B类中定义A类已有的属性和方法。（为了避免重复写属性和方法）

class 水果类      

{
  
   public 颜色；  //在水果类中定义颜色属性

}

 Class 苹果类：水果类      // 相对与苹果类，水果类是父类

{


    // 苹果类中其他的属性和方法

}

     // 苹果类继承了水果类的颜色属性

3.多态性

类的多态性指不同的类进行同一操作可以有不同的行为。

C#中的多态性可以通过以下三种方式实现：

接口多态性：通过定义接口并让类实现该接口，使用接口引用来实现多态性。在运行时，根据对象的实际类型来确定调用哪个实现方法。
继承多态性：通过继承来实现多态性。在父类中定义一个方法，并在子类中重写该方法，使用父类引用来调用子类的方法。
后期绑定：通过使用方法重写和虚方法来实现多态性。在基类中定义一个虚方法，并在派生类中重写该方法。在运行时，根据对象的实际类型来确定调用哪个实现方法。

C#多态性的应用场景非常广泛，以下是一些常见的应用场景：

事件处理：在GUI应用程序中，当用户点击按钮或触发某个事件时，可以使用多态性来处理不同类型的事件。通过定义事件委托，可以实现在事件触发时动态调用相应的方法。
接口实现：当一个类实现了一个接口，并提供了该接口所需的方法时，可以使用多态性来调用该类的实例。在运行时，根据对象的实际类型来确定调用哪个实现方法。
抽象类和虚方法：通过定义抽象类和虚方法，可以让子类继承并重写父类的方法。在运行时，根据对象的实际类型来确定调用哪个实现方法。
策略模式：策略模式是一种行为设计模式，可以在不改变对象的行为和上下文的情况下，动态地切换不同的行为。通过使用多态性，可以根据对象的实际类型来调用相应的方法。
状态模式：状态模式是一种行为设计模式，可以让一个对象在其内部状态改变时改变其行为。通过使用多态性，可以根据对象的实际状态来调用相应的方法。

A.多态性事件处理

using System;  
  
public class Animal  
{  
    public event Action<string> SoundMade;  
      
    public void MakeSound()  
    {  
        SoundMade?.Invoke(this, "动物发出声音");  
    }  
}  
  
public class Dog : Animal         //动物
{  
    public override void MakeSound()  
    {  
        base.MakeSound();  
        SoundMade?.Invoke(this, "狗发出汪汪汪的声音");  
    }  
}  
  
public class Cat : Animal  
{  
    public override void MakeSound()  
    {  
        base.MakeSound();  
        SoundMade?.Invoke(this, "猫发出喵喵喵的声音");  
    }  
}  
  
public class Program  
{  
    static void Main(string[] args)  
    {  
        Animal myDog = new Dog();  
        Animal myCat = new Cat();  
        myDog.SoundMade += (sender, message) => Console.WriteLine(message); // 输出 "狗发出汪汪汪的声音"  
        myCat.SoundMade += (sender, message) => Console.WriteLine(message); // 输出 "猫发出喵喵喵的声音"  
        myDog.MakeSound();   
        myCat.MakeSound();   
        Console.ReadKey();  
    }  
}




在这个例子中，定义了一个抽象类Animal，它包含一个抽象方法MakeSound()。

然后定义了两个子类Dog和Cat，它们继承了Animal类并重写了MakeSound()方法。

在主函数中，分别创建了一个Dog对象和一个Cat对象，它们都被声明为Animal类型的引用。

在调用MakeSound()方法时，由于对象实际类型不同，所以会调用相应子类的实现方法，输出不同的声音。

这就体现了多态性的应用。

B.多态性接口实现。接口定义了一组方法，这些方法可以在任何类中实现。当一个类实现了一个接口，它必须实现该接口中的所有方法。通过这种方式，可以实现多态性，即一个接口引用变量可以引用多个类实例，每个类实例都可以以自己的方式实现接口中的方法。

using System;  
  
interface IAnimal   //名为IAnimal的接口，它包含一个名为Speak()的方法。
{  
    void Speak();  // Speak method of interface IAnimal.   
}  
  


class Dog : IAnimal   

{  
    public void Speak()   
    {  
        Console.WriteLine("Woof!");  // 在 Dog 类中实现 IAnimal 接口的 Speak 方法。
    }  
}  
  


class Cat : IAnimal   
{  
    public void Speak()   
    {  
        Console.WriteLine("Meow!");  // 在 Cat 类中实现 IAnimal 接口的 Talk 方法。
    }  
}  
  


class Program  
{  
    static void Main(string[] args)  
    {  
        IAnimal myDog = new Dog(); // 创建 Dog 对象并将其赋值给 IAnimal 类型引用变量 myDog。

        IAnimal myCat = new Cat(); //创建 Cat 对象并将其赋值给 IAnimal 类型引用变量 myCat。

        myDog.Speak(); // 调用 Dog 类的 Talk 方法，输出: “ Woof!”

        myCat.Speak();  //调用 Cat 类的 Talk 方法，输出: “喵!”   
        Console.ReadKey();  
    }  
}



定义了一个名为IAnimal的接口，它包含一个名为Speak()的方法。

Dog和Cat类都实现了这个接口，并重写了Speak()方法。

在主函数中，分别创建了一个Dog对象和一个Cat对象，它们都被声明为IAnimal类型的引用。

当调用Speak()方法时，由于对象实际类型不同，所以会调用相应子类的实现方法，输出不同的声音。

这就体现了多态性的应用。

C.抽象方法与多态性

多态性是面向对象编程中的一个重要概念，它允许我们使用一个接口表示不同的类型，并在运行时根据对象的实际类型来执行相应的方法实现。多态性可以通过抽象和虚方法来实现。

抽象方法与多态性

抽象方法是一种只有声明没有实现的方法，定义抽象方法的类必须被标记为抽象类。任何继承抽象类的派生类都必须提供这些方法的具体实现。抽象类不能被实例化，只能被其他类继承。

通过抽象类和抽象方法，我们可以定义一个通用的接口，这个接口可以被多个不同的子类实现。在运行时，根据对象的实际类型，我们可以调用相应子类的实现方法，这就是多态性的体现。

例如，我们可以定义一个抽象类Animal，其中包含一个抽象方法MakeSound()：

public abstract class Animal  //抽象类Animal
{  
    public abstract void MakeSound();  //抽象方法MakeSound()：

}



//创建两个继承自Animal的子类Dog和Cat，它们分别提供MakeSound()方法的具体实现
public class Dog : Animal  
{  
    public override void MakeSound()  
    {  
        Console.WriteLine("Woof!");  
    }  
}  
  
public class Cat : Animal  
{  
    public override void MakeSound()  
    {  
        Console.WriteLine("Meow!");  
    }  
}


在主函数中，我们可以创建一个Animal类型的引用，并分别将其赋值为Dog和Cat类型的对象。

然后我们调用MakeSound()方法，根据对象的实际类型，会调用相应子类的实现方法：

Animal myAnimal = new Dog(); // myAnimal变量实际是Dog类型，所以调用Dog的MakeSound()方法，输出"Woof!"  
myAnimal = new Cat(); // myAnimal变量实际是Cat类型，所以调用Cat的MakeSound()方法，输出"Meow!"

D.虚方法和多态性

虚方法是可以在派生类中被重写的方法。在基类中声明为虚方法的默认行为是在派生类中提供新的实现。如果派生类不希望覆盖这个方法，它可以被声明为“sealed”，这样就不能被重写。

通过虚方法，我们可以定义一个通用的接口，这个接口可以被多个不同的子类实现。在运行时，根据对象的实际类型，我们可以调用相应子类的实现方法，这就是多态性的体现。

public class Animal  //定义一个基类Animal，其中包含一个虚方法MakeSound()：
{  
    public virtual void MakeSound()  
    {  
        Console.WriteLine("The animal makes a sound");  
    }  
}


创建两个继承自Animal的子类Dog和Cat，它们分别提供MakeSound()方法的具体实现：

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

E.多态策略模式

public interface IStrategy  //定义一个策略接口：
{  
    void Execute();  
}



//定义几个具体的策略类，它们实现了该接口：

public class ConcreteStrategyA : IStrategy  
{  
    public void Execute()  
    {  
        Console.WriteLine("执行策略A");  
    }  
}  
  
public class ConcreteStrategyB : IStrategy  
{  
    public void Execute()  
    {  
        Console.WriteLine("执行策略B");  
    }  
}



//定义一个上下文类，用于持有策略对象并调用其方法：

public class Context  
{  
    private IStrategy _strategy;  
  
    public Context(IStrategy strategy)  
    {  
        _strategy = strategy;  
    }  
  
    public void SetStrategy(IStrategy strategy)  
    {  
        _strategy = strategy;  
    }  
  
    public void DoSomething()  
    {  
        _strategy.Execute();  
    }  
}


//最后在客户端代码中使用上下文对象来调用策略对象的方法：
class Program  
{  
    static void Main(string[] args)  
    {  
        Context context = new Context(new ConcreteStrategyA()); // 初始化为策略A 
 
        context.DoSomething(); // 执行策略A，输出 "执行策略A"  

        context.SetStrategy(new ConcreteStrategyB()); // 切换为策略B  

        context.DoSomething(); // 执行策略B，输出 "执行策略B"  
    }  
}

F.多态性状态模式

public interface IState  //定义一个状态接口：
{  
    void Handle();  
}


//定义几个具体的状态类，它们实现了该接口：

public class StateA : IState  
{  
    public void Handle()  
    {  
        Console.WriteLine("处理状态A");  
    }  
}  
  
public class StateB : IState  
{  
    public void Handle()  
    {  
        Console.WriteLine("处理状态B");  
    }  
}

//定义一个上下文类，用于持有状态对象并调用其方法：

public class Context  
{  
    private IState _state;  
  
    public Context(IState state)  
    {  
        _state = state;  
    }  
  
    public void SetState(IState state)  
    {  
        _state = state;  
    }  
  
    public void Request()  
    {  
        _state.Handle();  
    }  
}


//在客户端代码中使用上下文对象来调用状态对象的方法：


class Program  
{  
    static void Main(string[] args)  
    {  
        Context context = new Context(new StateA()); // 初始化为状态A  

        context.Request(); // 处理状态A，输出 "处理状态A"  

        context.SetState(new StateB()); // 切换为状态B  

        context.Request(); // 处理状态B，输出 "处理状态B"  
    }  
}