c#中抽象方法的概念
2017-10-28 14:30:55 m0_37938006 阅读数 369
抽象类的概念:有时我们表达一些抽象的东西,它是一种概括,不需要它成为一种实体,所以面向对象便有了抽象类。

具体来讲:一个员工,它属于一个公司,但是公司只是一个名称,我们不需要它成为一个实体,所以公司就是一个抽象类。

抽象类的特点:

抽象类使用abstract修饰符,并且它只能是用作基类。
抽象类不能实例化,当使用new运算符对其实例时会出现编译错误。
允许(但不要求)抽象类包含抽象成员。(非抽象类不能包括抽象成员)
抽象类不能被密封。
抽象类可以被抽象类所继承,结果仍是抽象类

抽象方法:
抽象方法的特点:

抽象方法是隐式的虚方法,抽象方法只能在抽象类中声明。 
抽象方法不能使用private、static和virtual修饰符。(抽象的方法默认是一个virtual方法) 
抽象方法不能在派生类用base关键字进行访问。 
抽象方法声明不提供实际的实现,没有方法体。若要实现抽象方法,需要在派生类(非抽象类)中进行重写该抽象方法,继承类只有实现过所有抽象类的抽象方法后才能被实例化。

抽象类抽象方法的定义、使用:

    public abstract class myClass
    {
        private string id = "";
        private string name = "";
        public string ID
        {
            get{  return id; }
            set{ id = value; }
        }
        public string Name
        {
            get{return name; }
            set{ name = value;}
        }
        /// <summary>
        /// 抽象方法,用来输出信息
        /// </summary>
        public abstract void ShowInfo();
    }
    public class DriveClass : myClass   //继承抽象类
    {
        /// <summary>
        /// 重写抽象类中输出信息的方法
        /// </summary>
        public override void ShowInfo()
        {
            Console.WriteLine($"编号:{ID},姓名:{Name}");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            DriveClass driveclass = new DriveClass();   //实例化派生类
            myClass myclass = driveclass;               //使用派生类对象实例化抽象类
            myclass.ID = "xs001";                      //使用抽象类对象访问抽象类中的编号属性
            myclass.Name = "王二";                        //使用抽象类对象访问抽象类中的姓名属性
            myclass.ShowInfo();                         //使用抽象类对象调用抽象类中的的抽象方法
        }
    }


2016-11-12 17:35:07 aiTCR 阅读数 616

前言

听过很多的抽象具体,之前的自考懂不懂的就是抽象。今天可以明白点了。嘻嘻!!!

内容

抽象方法:abstract修饰的方法,只需要声明而不需要实现。

先来个例子感觉感觉吧!

    public abstract class Person        //父类是抽象类
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }
        private int _age;
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public abstract void Say();  //抽象方法没有方法体


        public void Sleep()
        {
            Console.WriteLine("可以睡觉了!!");
        }
    }
    public class Teacher :Person       //子类继承父类
    {
        public override void Say()     
        {
            Console.WriteLine("上课了!!");  //重写的方法来实现父类中的抽象方法。
        }
    }

在抽象类中的抽象方法,因为他抽象所以不能具体实现什么了,需要再用别的不是抽象的类中的方法来具体实现他。

父类中用abstract修饰的抽象方法,子类必须用override修饰的方法重写。

注意:

  1. 抽象方法必须在抽象类中,抽象类可以由非抽象成员。
  2. 抽象方法没有方法体,不能实例化 也不能点儿出来。
  3. 子类必须重写抽象父类中的抽象方法。

总结

多实践,多找联系!

虚方法与抽象方法的比较:

这里写图片描述

2008-05-21 14:50:00 sunzhenlin2008 阅读数 908

抽象(abstract)方法在逻辑上类似于虚方法,只是不能像虚方法那样被调用,而只是一个接口的声明而非实现

  1. 抽象方法不能是静态的,含有抽象方法的类一定是抽象类,也一定要加abstract类修饰符。
  2. 抽象类并不一定要含有抽象方法。
  3. 继承含有抽象方法的抽象类的子类必须覆盖并实现(直接使用override)该方法,或者组合使用abstract override使之继续抽象,或者不提供任何覆盖和实现。后两者的行为是一样的。

using System;
abstract class Parent
{
    public abstract void F();

    public abstract void G();
}
abstract class Child: Parent
{
    public abstract override void F();
}
abstract class Grandson: Child
{
    public override void F()
    {
        Console.WriteLine("Grandson.F");
    }
    public override void G()
    {
        Console.WriteLine("Grandson.G");
    }
}

 抽象方法可以抽象一个继承来的虚方法,我们看下面的例子:
using System;
class Parent
{
    public virtual void Method()
    {
        Console.WriteLine("Parent.Method");
    }
}
abstract class Child: Parent
{
    public abstract override void Method();
}
abstract class Grandson: Child
{
    public override void Method()
    {
        Console.WriteLine("Grandson.Method");
    }
}

 补充:

同名方法参数的不同会导致方法出现多态现象,这又叫重载(overloading)方法.

2014-02-26 14:55:44 zjx86320 阅读数 2409

        一、抽象类和抽象方法的概念

        在基类中的虚方法有时候不可能被调用到,而只是表达一种抽象的概念,用以为它的派生类提供一个公共的界面。 C#中引入了抽象类(abstract class)的概念,可以将它定义成抽象方法。将该方法所在的类定义成抽象类

         抽象方法:只包含方法定义,但没有具体实现的方法,需要其子类或者子类的子类来具体实现。

         抽象类:抽象类是能够包含抽象成员的类。抽象类只能作为基类使用,不能被实例化。

        二、抽象类和抽象方法的使用原则

        1  抽象类中可以存在非抽象方法,抽象方法必须包含在抽象类中。

        2  实现抽象方法用override关键字。如果子类没有实现抽象基类中所有的抽象方法,则子类也必须定义成一个抽象类。

        3  抽象方法被实现后,不能更改修饰符。

        4  抽象类可以被抽象类所继承,结果仍是抽象类。

        5  所有抽象的方法,在派生类中必须被实现。

         下面就让我们通过一个例子来认识一下抽象类吧:

       

   abstract class shapleclass    //抽象类的声明
    {
      abstract public void area();  //抽象方法,只是声明没有实际的实现,所以只是以分号结束,并且在签名后没有大括号
        public void fun()       //成员函数
        {
            Console.WriteLine("这是一个非抽象方法!");
        }

    }
    
    class shap:shapleclass

    {

        public override void area()   //所有派生于抽象类的方法,必须实现抽象类中的抽象方法
        {
            Console.WriteLine("这是一个抽象方法");
        }
    }

 

 class Program
    {
        static void Main(string[] args)
        {
            shap  circle = new shap();
            circle.fun();
            circle.area();
        }
    }


        运行结果如下:

       

        

 

 

2017-01-23 20:27:00 weixin_33686714 阅读数 14

在覆盖父类的方法时,必须显式说明是在覆盖父类方法,否则相当于没有覆盖。

class Animal {
   public  void run() {
        Console.WriteLine("animal is running");
    }
}
class Dog : Animal {
    public void run() {
        Console.WriteLine("dog is running");
    }
}
class haha {
    static void Main() {
        Animal dog = new Dog();
        dog.run();//animal is running
        Dog d = new Dog();
        d.run();//dog is running
    }
}

上面Dog类中的run函数有警告在编译时会有警告:警告:“Dog.run()隐藏了继承的成员Animal.run()。如果是有意隐藏,请使用关键字 new。即便改成下面这样,结果依然没变。

class Dog : Animal {
    public new void run() {
        Console.WriteLine("dog is running");
    }
}

下面重点来了,直接说结论。
在 C# 中,方法不允许隐式覆盖。
派生类若想覆盖基类方法必须显示声明为override
要想把函数声明为override,必须保证基类的同名方法为abstract或者virtual或者override,否则没法把函数声明为override。
这种设计思想的好处是显而易见的,它督促程序员更明确地表达自己的观点,不允许一些implicit的东西。

然而,“要显式不要隐式”跟“约定大于配置”这两个原则是否冲突呢?

抽象类不一定包含抽象方法,包含抽象方法的类必须是抽象类,也就是说,如果方法用abstract修饰,类必须用abstract修饰。

sealed和new是一对
下面看一个标准样例,这段代码是正确而标准的。

class Animal {
    public virtual void run() {//将来准备override的函数,必须用virtual声明
        Console.WriteLine("animal is running");
    }
}
class Cat : Animal {
    public sealed override void run() {//如果是覆盖基类函数,必须用override;如果不想再被覆盖,必须用sealed
        Console.WriteLine("Cat is running");
    }
}
class Tiger : Cat {
    public new void run() {//sealed的基类函数必须用new声明,并且不允许用override声明。如果不用new声明,编译报错“不够显式,有点含蓄,C#是反对含蓄的”
        Console.WriteLine("tiger is running");
    }
}
class haha {
    static void Main() {
        Animal a = new Tiger();
        a.run();//cat is running
        Cat b = new Tiger();
        b.run();//cat is running
        Tiger c = new Tiger();
        c.run();//tiger is running
    }
}

只有标记为override的函数才允许标记为sealed,否则报错因为“Animal.run()”不是重写,所以无法将其密封
被标记为sealed的函数不允许再次覆盖,派生类中也就是不允许再使用override标记函数
虽然派生类中不允许override基类中的sealed了的函数,但是派生类中可以出现sealed了的同名函数,只是不允许加override,也就是说不允许再进行显示覆盖(C#中的覆盖肯定是显示覆盖,C#不存在隐式覆盖这种东西)。这时,如果不适用new关键字,会报一个警告,就是上面出现过的那个警告:
在编译时会有警告:警告:“Tiger.run()隐藏了继承的成员Cat.run()。如果是有意隐藏,请使用关键字 new。

没有更多推荐了,返回首页