精华内容
下载资源
问答
  • C# 虚方法和抽象方法

    2021-06-07 11:44:09
    虚方法 关键字:virtual 添加关键字virtual之后,会把方法定义为虚方法,

    虚方法

    关键字:virtual

    添加关键字virtual之后,会把方法定义为虚方法

    实例

    public class VirA{
    
        public virtual void VirTest(){
        // 这是一个虚方法
        }
    }
    

    虚方法可以被子类派生,用override重写VirTest

    public class VirChild:VirA{
    
        public override void VirTest(){
            base.VirTest();
            //重写父类的方法
        }
    }

    这样一个简单的重写就完成了

    重写之后,还可以通过base.VirTest调用父类原本的代码

    override派生过的方法,还可以被继续派生

    public class VirGrandson:VirChild{
    
        public override void VirTest(){
            base.VirTest();
            //重写父类的方法
        }
    }

    VirGrandson——继承——>VirChild——继承——>VirA

    特点:

    虚方法更容易维护,修改或者维护时,可以不改动底层源码,直接修改它的重写方法

     

    抽象方法

    关键字:abstract

    添加关键字abstract之后,会把方法定义为抽象方法

    抽象方法只能定义在抽象类内

    实例

    ///抽象类
    public abstract class AbsParent
    {
        ///抽象方法
        public abstract void AbsTest();
    
    }

    我们定义了一个抽象类和抽象方法

    public class AbsChild: AbsParent
    {
        public override void AbsTest()
        {
           //实现抽象类
           //无法使用base.AbsTest()
        }
    }
    

    继承抽象方法不能使用base.AbsTest,因为它没有方法实体

    
    public class AbsGroundSun : AbsChild
    {
        public override void AbsTest()
        {
            base.AbsTest();
        }
    }

    还可以再被继承,派生.这个时候可以使用base的方法了,因为我们的AbsChild已经实现了方法主体

    特点

    抽象方法必须放在抽象类中

    抽象方法不能是私有的

    抽象类被继承的时候,子类必须实现抽象类里面的所有抽象方法

    抽象方法被实现一定是用override关键字,不能用new, (new 相当于是一个新的方法了,和父类的方法都没关系了,没有血缘关系,只是长得像)

    抽象类中可以拥有其他类型的方法

    和接口的区别

    抽象类是单继承的,接口可以多继承

    抽象类里面除了抽象方法,还可以写普通方法,虚方法,静态方法,接口只能写规范,不能写方法主体,也不能写别的方法

    就像这张图一样,我们只能继承人啊,不能再是猫,狗或者别的物种了

    但是接口就像技能一样,有时间就可以学一个新技能

    抽象方法和虚方法的区别

    抽象方法只写个规范,不写方法实体(可以把它看成一个懒虫,啥也不干)

    虚方法有自己的方法主体(就像一个勤劳的农民伯伯),子类继承了它之后还可以调用他的方法(请它出山坐诊,和诸葛亮一样啊,不给退休,干到死)

     

    掰掰

    展开全文
  • C#虚方法和抽象方法

    万次阅读 2011-05-28 16:03:00
    方法 的方式调用, 无论有没有在子类使用override去重写 virtual关键字只是明确标示此方法可以被重写, 其实它一般的方法没有什么区别 相应的 sealed关键字标示此方法不可以被重写虚方法和抽象方法的区别:1.虚方法...

    虚方法:

    1、virtual方法表示此方法可以被重写, 也就是说这个方法具有多态.父类中的方法是通用方法,可以在子类中重写以重新规定方法逻辑.
    2、virtual方法可以直接使用,和普通方法一样
    3、不是必须重写的. 子类可以使用base.方法 的方式调用, 无论有没有在子类使用override去重写

    virtual关键字只是明确标示此方法可以被重写, 其实它和一般的方法没有什么区别
    相应的
    sealed关键字标示此方法不可以被重写

    虚方法和抽象方法的区别:

    1.虚方法可以有实现体,抽象方法不能有实现体。

    2.抽象方法
        要求派生类必须重载这个方法;


    虚方法
        告诉编译器,这个方法可以重写。
        当基类的方法与派生类的方法重名时,
        可以选择派生类的方法从基类继承并重写,
        还是,把基类的方法隐藏起来。 


    本段来自CSDN博客:http://blog.csdn.net/tflb521/archive/2009/08/20/4466134.aspx

     

     

    c#虚方法详解:在派生类中的应用

     

    若一个实例方法的声明中含有 virtual 修饰符,则称该方法为虚拟方法。若其中没有 virtual 修饰符,则称该方法为非虚拟方法。

    非虚拟方法的实现是不会变的:无论是在声明它的类的实例上调用该方法还是在派生类的实例上调用,实现都是相同的。与此相反,一个虚拟方法的实现可以由派生类取代。取代所继承的虚拟方法的实现的过程称为重写该方法(第 10.5.4 节)。

    在一个虚拟方法调用中,该调用所涉及的那个实例的运行时类型确定了要被调用的究竟是该方法的哪一个实现。在非虚拟方法调用中,相关的实例的编译时类型是决定性因素。准确地说,当在具有编译时类型 C 和运行时类型 R 的实例(其中 R 为 C 或者从 C 派生的类)上用参数列表 A 调用名为 N 的方法时,调用按下述规则处理:

    •首先,将重载决策应用于 C、N 和 A,以从在 C 中声明的和由 C 继承的方法集中选择一个特定的方法 M。第 7.5.5.1 节对此进行了描述。
    •然后,如果 M 为非虚拟方法,则调用 M。
    •否则(M 为虚拟方法),就会调用就 R 而言 M 的派生程度最大的那个实现。
    对于在一个类中声明的或者由类继承的每个虚拟方法,存在一个就该类而言的派生程度最大的实现。就类 R 而言虚拟方法 M 的派生度最大的实现按下述规则确定:

    •如果 R 中含有关于 M 的 virtual 声明,则这是 M 的派生程度最大的实现。
    •否则,如果 R 中含有关于 M 的 override 声明,则这是 M 的派生程度最大的实现。
    •否则,就 R 而言 M 的派生程度最大的实现与就 R 的直接基类而言 M 的派生程度最大的实现相同。
    下列实例阐释虚拟方法和非虚拟方法之间的区别:

    using System;
    class A
    {
       public void F() { Console.WriteLine("A.F"); }
       public virtual void G() { Console.WriteLine("A.G"); }
    }
    class B: A
    {
       new public void F() { Console.WriteLine("B.F"); }
       public override void G() { Console.WriteLine("B.G"); }
    }
    class Test
    {
       static void Main() {
          B b = new B();
          A a = b;
          a.F();
          b.F();
          a.G();
          b.G();
       }
    }在该示例中,A 引入一个非虚拟方法 F 和一个虚拟方法 G。类 B 引入一个新的非虚拟方法 F,从而隐藏了继承的 F,并且还重写了继承的方法 G。此例产生输出:

    A.F
    B.F
    B.G
    B.G请注意,语句 a.G() 实际调用的是 B.G 而不是 A.G。这是因为,对调用哪个实际方法实现起决定作用的是该实例的运行时类型(即 B),而不是该实例的编译时类型(即 A)。

    由于一个类中声明的方法可以隐藏继承来的方法,因此同一个类中可以包含若干个具有相同签名的虚拟方法。这不会造成多义性问题,因为除派生程度最大的那个方法外,其他方法都被隐藏起来了。在下面的示例中

    using System;
    class A
    {
       public virtual void F() { Console.WriteLine("A.F"); }
    }
    class B: A
    {
       public override void F() { Console.WriteLine("B.F"); }
    }
    class C: B
    {
       new public virtual void F() { Console.WriteLine("C.F"); }
    }
    class D: C
    {
       public override void F() { Console.WriteLine("D.F"); }
    }
    class Test
    {
       static void Main() {
          D d = new D();
          A a = d;
          B b = d;
          C c = d;
          a.F();
          b.F();
          c.F();
          d.F();
       }
    }C 类和 D 类均含有两个具有相同签名的虚拟方法:A 引入的虚拟方法和 C 引入的虚拟方法。但是,由 C 引入的方法隐藏了从 A 继承的方法。因此,D 中的重写声明所重写的是由 C 引入的方法,D 不可能重写由 A 引入的方法。此例产生输出:

    B.F
    B.F
    D.F
    D.F请注意,通过访问 D 的实例(借助一个派生程度较小的类型,它的方法没有被隐藏起来),可以调用被隐藏的虚拟方法。


    本段来自CSDN博客:http://blog.csdn.net/sofoo/archive/2004/11/03/165691.aspx

    展开全文
  • 虚方法 虚方法存在于相对于需要实现多态的子类的父类当中,同时也是实现多态的最基本的方法。 具体语法:父类的方法,用virtual修饰,表示虚方法。继承它的子类,在内部用override进行重写。 下面进行案例分析: ...

    虚方法

    虚方法存在于相对于需要实现多态的子类的父类当中,同时也是实现多态的最基本的方法。

    具体语法:父类的方法,用virtual修饰,表示虚方法。继承它的子类,在内部用override进行重写。

    下面进行案例分析:

    猫和狗都是动物,他们都会叫,但是叫声不一样。提取出相同的部分,即叫声,将叫声实现为多态。

    新建父类:Animal,新建子类Cat、Dog,代码如下:

    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Animal animal = new Animal();
                animal.Cry();
    
                Cat cat = new Cat();
                cat.Cry();
    
                Dog dog = new Dog();
                dog.Cry();
    
                Console.ReadKey();
            }
        }
    
        /// <summary>
        /// 动物类
        /// </summary>
        public class Animal
        {
            public virtual void Cry()
            {
                Console.WriteLine("动物在叫!");
            }
        }
    
        /// <summary>
        /// 猫类
        /// </summary>
        public class Cat : Animal
        {
            public override void Cry()
            {
                Console.WriteLine("小猫喵喵!");
            }
        }
    
        /// <summary>
        /// 狗类
        /// </summary>
        public class Dog : Animal
        {
            public override void Cry()
            {
                Console.WriteLine("小狗汪汪!");
            }
        }
    
    }

    执行结果:

     

    抽象方法和抽象类

    抽象方法和抽象类的关键字都是:abstract

    如果父类的方法很抽象,而且没有具体的do(做什么)即方法体,必须要子类进行重写才有实际意义的话,这种情况就需要用抽象方法了。

    实例代码:

    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Cat cat = new Cat();
                cat.Eat();
    
                Dog dog = new Dog();
                dog.Eat();
    
                Console.ReadKey();
            }
        }
    
        /// <summary>
        /// 动物类
        /// </summary>
        public abstract class Animal
        {
            public abstract void Eat();
        }
    
        /// <summary>
        /// 猫类
        /// </summary>
        public class Cat : Animal
        {
            public override void Eat()
            {
                Console.WriteLine("小猫在吃猫粮!");
            }
        }
    
        /// <summary>
        /// 狗类
        /// </summary>
        public class Dog : Animal
        {
            public override void Eat()
            {
                Console.WriteLine("小狗在吃狗粮!");
            }
        }
    
    }
    

    执行结果:

     

    抽象方法,必须存在于抽象类当中。相反,抽象类中不一定全部是抽象方法。比如我们可以在里面写上普通方法,有实现的虚方法或者没有实现的虚方法都可以。抽象方法没有方法体,继承了抽象类的子类,必须实现父类的所有的抽象方法。

    在虚方法中,假如子类需要完成多态的表现,而父类的方法实际上也有实际意义,那父类可以选择实现,等需要子类重写的时候去重写实现调用,父类的方法暂时没有实际意义,也可以不用具体实现。所以,父类的虚方法可以实现(有方法体),也可以不实现(没有方法体)。而抽象方法必须通过子类的重写来实现。

     

    抽象类使用场景:

    1.父类方法不知道如何去使用

    2.父类没有默认实现,而且不需要实例化

    总的来说:抽象方法和虚方法差不多,实现的功能都差不多。抽象类保证了所有的抽象方法必须得到重写,而虚方法可以根据需要来选择是否进行重写。

     

    接口:Interface

    接口和抽象类差不多,区别在于,接口内包含的全部是未实现的方法。而且接口类和方法的关键词不需要再声明abstract,接口类的关键词,interface,一般定义接口名称,按照约定,我们会在名称前面加上一个I。例如下图的打印机接口。

     

    里面有一个未实现的方法。下面定义一个惠普打印机实现类,继承自接口IPrinter 

    实例完整代码:

    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                HPPrinter hp = new HPPrinter();
                hp.Print();
    
                Console.ReadKey();
            }
        }
    
        /// <summary>
        /// 打印接接口
        /// </summary>
        public interface IPrint
        {
            void Print();
        }
    
        /// <summary>
        /// 惠普打印机类
        /// </summary>
        class HPPrinter : IPrint
        {
            public void Print()
            {
                Console.WriteLine("惠普打印机正在打印文件!");
            }
        }
    
    }
    

    执行结果:

     

     

    接口定义了所有类继承接口时应遵循的语法合同。接口定义了语法合同 "是什么" 部分,派生类定义了语法合同 "怎么做" 部分。

    例如上面实例中,接口IPrint定义了一个打印机(是什么),派生类HPPrinter说明了是惠普打印机打印文件(怎么做)。

    接口定义了属性、方法和事件,这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构。接口使得实现接口的类或结构在形式上保持一致。

    抽象类在某种程度上与接口类似,但是,它们大多只是用在当只有少数方法由基类声明由派生类实现时。

     

     

    展开全文
  • C#虚方法和抽象方法 .

    2015-07-28 17:21:23
    虚方法: 1、virtual方法表示此方法可以被重写, 也就是说这个方法具有多态.父类中的方法是通用方法,可以在子类中重写以重新规定方法逻辑. 2、virtual方法可以直接使用,普通方法一样 3、不是必须重写的. 子类...

    虚方法:

    1、virtual方法表示此方法可以被重写, 也就是说这个方法具有多态.父类中的方法是通用方法,可以在子类中重写以重新规定方法逻辑.
    2、virtual方法可以直接使用,和普通方法一样
    3、不是必须重写的. 子类可以使用base.方法 的方式调用, 无论有没有在子类使用override去重写

    virtual关键字只是明确标示此方法可以被重写, 其实它和一般的方法没有什么区别
    相应的
    sealed关键字标示此方法不可以被重写

    虚方法和抽象方法的区别:

    1.虚方法可以有实现体,抽象方法不能有实现体。

    2.抽象方法
        要求派生类必须重载这个方法;


    虚方法
        告诉编译器,这个方法可以重写。
        当基类的方法与派生类的方法重名时,
        可以选择派生类的方法从基类继承并重写,
        还是,把基类的方法隐藏起来。 


    本段来自CSDN博客:http://blog.csdn.net/tflb521/archive/2009/08/20/4466134.aspx

     

     

    c#虚方法详解:在派生类中的应用

     

    若一个实例方法的声明中含有 virtual 修饰符,则称该方法为虚拟方法。若其中没有 virtual 修饰符,则称该方法为非虚拟方法。

    非虚拟方法的实现是不会变的:无论是在声明它的类的实例上调用该方法还是在派生类的实例上调用,实现都是相同的。与此相反,一个虚拟方法的实现可以由派生类取代。取代所继承的虚拟方法的实现的过程称为重写该方法(第 10.5.4 节)。

    在一个虚拟方法调用中,该调用所涉及的那个实例的运行时类型确定了要被调用的究竟是该方法的哪一个实现。在非虚拟方法调用中,相关的实例的编译时类型是决定性因素。准确地说,当在具有编译时类型 C 和运行时类型 R 的实例(其中 R 为 C 或者从 C 派生的类)上用参数列表 A 调用名为 N 的方法时,调用按下述规则处理:

    •首先,将重载决策应用于 C、N 和 A,以从在 C 中声明的和由 C 继承的方法集中选择一个特定的方法 M。第 7.5.5.1 节对此进行了描述。
    •然后,如果 M 为非虚拟方法,则调用 M。
    •否则(M 为虚拟方法),就会调用就 R 而言 M 的派生程度最大的那个实现。
    对于在一个类中声明的或者由类继承的每个虚拟方法,存在一个就该类而言的派生程度最大的实现。就类 R 而言虚拟方法 M 的派生度最大的实现按下述规则确定:

    •如果 R 中含有关于 M 的 virtual 声明,则这是 M 的派生程度最大的实现。
    •否则,如果 R 中含有关于 M 的 override 声明,则这是 M 的派生程度最大的实现。
    •否则,就 R 而言 M 的派生程度最大的实现与就 R 的直接基类而言 M 的派生程度最大的实现相同。
    下列实例阐释虚拟方法和非虚拟方法之间的区别:

    using System;
    class A
    {
       public void F() { Console.WriteLine("A.F"); }
       public virtual void G() { Console.WriteLine("A.G"); }
    }
    class B: A
    {
       new public void F() { Console.WriteLine("B.F"); }
       public override void G() { Console.WriteLine("B.G"); }
    }
    class Test
    {
       static void Main() {
          B b = new B();
          A a = b;
          a.F();
          b.F();
          a.G();
          b.G();
       }
    }在该示例中,A 引入一个非虚拟方法 F 和一个虚拟方法 G。类 B 引入一个新的非虚拟方法 F,从而隐藏了继承的 F,并且还重写了继承的方法 G。此例产生输出:

    A.F
    B.F
    B.G
    B.G请注意,语句 a.G() 实际调用的是 B.G 而不是 A.G。这是因为,对调用哪个实际方法实现起决定作用的是该实例的运行时类型(即 B),而不是该实例的编译时类型(即 A)。

    由于一个类中声明的方法可以隐藏继承来的方法,因此同一个类中可以包含若干个具有相同签名的虚拟方法。这不会造成多义性问题,因为除派生程度最大的那个方法外,其他方法都被隐藏起来了。在下面的示例中

    using System;
    class A
    {
       public virtual void F() { Console.WriteLine("A.F"); }
    }
    class B: A
    {
       public override void F() { Console.WriteLine("B.F"); }
    }
    class C: B
    {
       new public virtual void F() { Console.WriteLine("C.F"); }
    }
    class D: C
    {
       public override void F() { Console.WriteLine("D.F"); }
    }
    class Test
    {
       static void Main() {
          D d = new D();
          A a = d;
          B b = d;
          C c = d;
          a.F();
          b.F();
          c.F();
          d.F();
       }
    }C 类和 D 类均含有两个具有相同签名的虚拟方法:A 引入的虚拟方法和 C 引入的虚拟方法。但是,由 C 引入的方法隐藏了从 A 继承的方法。因此,D 中的重写声明所重写的是由 C 引入的方法,D 不可能重写由 A 引入的方法。此例产生输出:

    B.F
    B.F
    D.F
    D.F请注意,通过访问 D 的实例(借助一个派生程度较小的类型,它的方法没有被隐藏起来),可以调用被隐藏的虚拟方法。


    本段来自CSDN博客:http://blog.csdn.net/sofoo/archive/2004/11/03/165691.aspx

    展开全文
  • C# 虚方法抽象方法区别.pdf
  • 主要介绍了C#中的虚方法和抽象方法的运用,文中讲解非常细致,代码帮助大家更好的理解学习,感兴趣的朋友可以了解下
  • c#虚方法抽象方法

    2019-04-24 18:05:58
    虚方法抽象方法的区别 虚方法 抽象方法 用virtual修饰 用abstract修饰 要有方法体 不允许有方法体 可以被子类override 必须被子类override 除了密封类都可以写 只能在抽象类中 1.抽象方法在子类中...
  • 抽象方法是只有定义、没有实际方法体的函数,它只能在抽象函数中出现,并且在子类中必须重写; 虚方法则有自己的函数体,已经提供了函数实现...抽象方法是可以看成是没有实现体的虚方法如果类中包含抽象方法,那么类就
  • C#虚方法和抽象类的对比虚方法和抽象类的区别主要在于前者父类可以写方法而后者不可以写方法。具体代码解释如下 虚方法中父类子类的写法/*虚方法父类*/ class 父类名 { public virtual void 方法名() { ...
  • 虚方法抽象方法(adstract)一样使用override关键字重写 &amp;amp;lt;3&amp;amp;gt;虚方法在子类中可以实现,也可以不实现。 &amp;amp;lt;4&amp;amp;gt;虚方法必须有方法体哪怕是空的 &amp;...
  • 抽象类派生的非抽象方法必包括继承的所有抽象方法和抽象访问器的实现 必需用override重写 什么时候要用到抽象类,方法 比如你要去定义许多动物的类,动物们同属于animal类,动物们都会eat,walk,所以可以去定义一...
  • 前言:在前面的博文中,我介绍了C#中的虚方法抽象方法,本博文将对两者的区别进行详细叙述。参考博文:浅谈C#虚方法与隐藏方法的区别、深究C#中的抽象类、抽象属性、抽象方法 文章目录一、虚方法的回顾二、抽象...
  • C# 虚方法抽象方法区别

    千次阅读 2015-02-17 21:40:46
    抽象方法是只有定义、没有实际方法体的函数,它只能在抽象函数中出现,并且在子类中必须重写;虚方法则有自己的函数体,已经提供了函数实现,但是允许在子类中重写或覆盖。...抽象方法是可以看成是没有实现体的虚方法
  • C#虚方法和抽象方法

    千次阅读 热门讨论 2018-08-17 11:51:25
       当子类方法父类方法相同时,可以隐藏基类方法,也可以用虚方法,这时子类就可以重写父类的方法了,这就是类的多态形式,重写还可以用在抽象方法中,并且是抽象方法的类就必须重写,虚方法和抽象方法都能让...
  • C#类、接口、虚方法和抽象方法-接口与抽象类的区别实例 C#类、接口、虚方法和抽象方法-接口与抽象类的区别实例
  • 1.虚方法  关键字virtual,如果父类中存在虚方法,则子类可以用override进行方法的重写,当然也可以不重写 2.抽象方法  关键字abstract,抽象方法必须存在于抽象类之后,但是抽象类不仅仅只有抽象方法,也可由有...
  • C#关键字 虚方法和抽象方法

    千次阅读 2010-05-15 18:00:00
    虚方法vitual和抽象方法abstract的区别: 1虚方法和抽象方法都是为了多态而诞生的 2虚方法利用关键词virtual表示,抽象方法利用abstract表示 3虚方法有实现的主题,可以有实现,也可以没有实现,而抽象方法仅仅...
  • C#基础】虚方法和抽象方法

    热门讨论 2016-02-14 10:42:21
    学过C#的人,应该都听过说虚方法和抽象方法,但是对于初学者来说,虚方法和抽象方法,还可能会时常搞混他们的关系。因此我们非常有必要抽出时间,把他们放在一起,进行对比,揭开他们神秘的外纱。  虚方法和抽象...
  • **虚方法:**即为基类中定义的允许在派生类中重写的方法,使用virtual关键字定义。如: public virtual void EatFood() { Console.WriteLine("Animal吃东西"); } 注意:虚方法也可以被直接调用。如: Animal a = ...
  • 4.如果类是抽象类,可以有虚方法,可以实现也可以不实现 抽象方法 1,抽象成员只能存在于抽象类中, 2,标记的关键字为abstract 3,声明抽象类不能有实现。 4.由于抽象成员没有任何实现...
  • 虚方法抽象方法 很多时候都用在 多态 这里!! 对于多态: 就是说 父类定义的 虚方法 ,如果有子类改写,那么 其不同子类的对象 优先调用各自的 改写方法,如果没改写,就调用父类的 打个比方...
  • 主要讲述了c#中的简单工厂和虚方法抽象类、抽象方法的语法用法
  • (1) 抽象方法只作声明,而不包含实现,可以看成是没有实现体的虚方法 (2) 抽象类不能被实例化 (3) 抽象类可以但不是必须有抽象属性和抽象方法,但是一旦有了抽象方法,就一定要把这个类声明为抽象类 (4) 具体派生...
  • 抽象方法和抽象类都是由abstract修饰 abstract的使用注意 抽象方法没有方法抽象成员只能存在于抽象类中 抽象类可以有非抽象成员 抽象类的派生类必须实现抽象方法抽象类只能用作基类,无法实例化 代码: ...
  • C#:简述虚方法和抽象类方法其子类的重写同异点 在讲解标题内容之前先简单分析虚方法和抽象类的定义 虚方法(virtual)是有方法体的,它是一个完整的函数,可实现输入,什么时候需要附加virtual来修饰一个方法(在...
  • 今天在云和学院学了很多,我这次只能先总结一下C#中的虚方法和抽象的运用。 理论: 虚方法: •用virtual修饰的方法叫做虚方法虚方法可以在子类中通过override关键字来重写 •常见的虚方法:ToString() ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,573
精华内容 7,029
关键字:

c#虚方法和抽象方法

c# 订阅