c#类（类的多态讲解）

最新推荐文章于 2024-11-26 19:00:00 发布

原创最新推荐文章于 2024-11-26 19:00:00 发布 · 1.3k 阅读

7 ·

CC 4.0 BY-SA版权

▶c# 专栏收录该内容

11 篇文章

订阅专栏

类

类修饰符 class 类名
｛

｝

public:是类的修饰符，下面介绍常使用的几个类修饰符
new：仅允许在嵌套类声明时使用，表明类中隐藏了由基类中继承而来的、与基类中同名的成员。
public：不限制对该类的访问。
protected：只能从其所在类和所在类的子类（派生类）进行访问。
internal：只有其所在类才能访问。
private：只有.Net中的应用程序或库才能访问。
abstract：抽象类，不允许建立类的实例。
sealed：密封类，不允许被继承。

构造函数和析构函数

构造函数和析构函数是类中比较特殊的两种成员函数，主要用来对对象进行初始化和回收对象资源。一般来说，对象的生命周期从构造函数开始，以析构函数结束。

简明来说就是当我实例化了一个ProgramClass类，他在第一时间就会执行构造函数，当我用完了ProgramClass类，他会自动执行析构函数。

析构函数

不能在结构中定义析构函数。只能对类使用析构函数。

一个类只能有一个析构函数。

无法继承或重载析构函数。

无法调用析构函数。它们是被自动调用的。

析构函数既没有修饰符，也没有参数。

析构函数一般都是在程序结束时才执行

类代码：

class ProgramClass
    {
        public ProgramClass()//构造函数,
        {
            Console.WriteLine("构造函数");
        }
        public void Shownum()
        {
            Console.WriteLine("这是Shownum函数");
        }
        ~ProgramClass()//析构函数
        {
            Console.WriteLine("析构函数");
        }

    }

主函数代码：

static void Main(string[] args)
        {
            /*测试构造函数和析构函数*/
            ProgramClass pc = new ProgramClass();
            pc.Shownum();
        }

输出：

构造函数
这是Shownum函数
析构函数

类的面向对象特性

主要内容在上一篇（面向对象OOP的三个基本特征）

类的封装

class Myclass //创建一个类
    {
        private int x = 0;//创建私有变量x
        private int y = 0;//创建私有变量y
        public int X//属性
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        public int Y
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
            }
        }
         public int Add()
        {
            return x + y;
        }
    }

主函数：

            /*类的封装*/
            Myclass mc = new Myclass();//实例化对象
            mc.X = 6;
            mc.Y = 7;
            Console.WriteLine("x+y={0}", mc.Add());

类的多态

在类的继承中，C#允许在基类与派生类中声明具有同名的方法，而且同名的方法可以有不同的代码，也就是说在基类与派生类的相同功能中可以有不同的实现方法，从而为解决同一问题提供多种途径。
多态性就是指在程序运行时，执行的虽然是一个调用方法的语句，却可以根据派生类对象的类型的不同完成方法不同的具体实现。

在C#中可以通过多种途径实现多态性：

虚方法：将父类的方法标记为虚方法，使用关键字virtual，此方法在子类中可以重写（使用关键字override）

2.== 抽象类与抽象方法==：如果我们不需要使用父类创建对象，它的存在只是为供子类继承。可以将父类写成抽象（关键字abstract）类，将父类的方法写成抽象方法，子类中的方法仍用关键字override重写。

3.接口实现：

我们选择使用虚方法实现多态还是抽象方类抽象方法实现多态，取决于我们是否需要使用基类实例化的对象。

抽象类：不需要使用基类实例化的对象
虚方法：需要使用基类实例化的对象

举例：

现有Clerk（基类），ProjectManager（继承类），此时需要使用虚方法来实现多态，因为我们需要使用Clerk创建的对象，这些对象是普通员工对象职员（Clerk）需要有工作计划，经理（ProjectManager）也需要有工作计划
现有Drink类作为基类，Milk，Tea类继承Drink，我们需要使用的是Milk和Tea创建对象，无需Drink创建对象，此时将Drink写成抽象类

茶（Tea）可以饥渴，牛奶（Milk）也可以解渴————此时抽象出一个饮料（Drink）类作为基类

采用虚拟方法代码如下：

class Clerk
{
    public virtual void WorkPlan()    // 此处采用virtual方法
    {
         Console.WriteLine("我是职员，我需要有工作计划");
    }
}    
class ProjectManager:Clerk  // 继承于Clerk
 {
        public override void WorkPlan()　　// 用override进行重写
        {
            Console.WriteLine("我是经理，我也需要有工作计划");
        }
 }
        

class Program              
{
      static void Main(string[] args)
      {
          Clerk myClerk = new Clerk();
          ProjectManager myPM = new ProjectManager();
          Clerk[] clerk = { myClerk, myPM };
          foreach (Clerk outclerk in clerk)
              outclerk.WorkPlan();
          Console.ReadKey();     
      }
}

采用抽象方法代码如下：

abstract class Drink
{
    public abstract void drink();   // 使用抽象化方法时，不能有方法体
}

class Milk:Drink
{
    public override void drink()
    {
        Console.WriteLine("我是牛奶，我可以解渴");
    }
}

class Tea:Drink
{
    public override void drink()
    {
        Console.WriteLine("我是茶，我可以解渴");
    }
}


 class Program 
 {
        　　  static void Main(string[] args)
        　　  {
　　　　Drink myMilk = new Milk();  // 此处注意抽象类Drink是不能进行实例化的
　　　　Drink myTea = new Tea();
　　　　Drink[] drink = { myMilk, myTea };
　　　　foreach (Drink outDrink in drink)
    　　　　outDrink.drink();
　　　　Console.ReadKey();
　　 }
 }

我的多态程序

类：

 class Myclass
    {
        private int x = 0;
        private int y = 0;
        public int X
        {
            get
            {
                return x;
            }
            set
            {
                x = value;
            }
        }
        public int Y
        {
            get
            {
                return y;
            }
            set
            {
                y = value;
            }
        }
        public virtual int Add()
        //定义一个virtual类型的方法，以便在子类（派生类）中重写该方法
        {
            return X + Y;
        }
    }
    class MyClass2 : Myclass
    {
        public override int Add()//重写求和方法
        {
            //int x = 5;
            //int y = 7;
            return X+ Y;
        }
    }

主函数：

            /*类的多态*/
            MyClass2 mc2 = new MyClass2();
            //使用子类（派生类）MyClass2的对象实例化基类Myclass的对象
            Myclass mc1=(Myclass)mc2;
            mc1.X = 3;
            mc1.Y = 5;
            Console.WriteLine(mc2.Add());
            Console.WriteLine(mc1.Add());