分享

C# 抽象类

 细想生活 2015-01-19

1.解释什么是抽象类?
抽象类是包含抽象方法的类。那么什么又是抽象方法呢?抽象方法是没有方法内容的,只有一个方法名和参数列表的方法。并以;结尾。为了标注他的与众不同,在他的返回类型前加abstract。并在class前加abstract。
简言之,由abstract修饰的方法和类就是抽象的方法和类。


2. 抽象类的特点
①  抽象类只能做父类
②  抽象类不能实例化,既不能用new来产生属于抽象类的对象
③  抽象类中除了抽象方法与普通方法不一样以外,其他的部分和普通类一样。即抽象类是普通类的特例,他特殊只是有抽象方法。所以它里面可以有字段,属性,普通方法。


3.抽象方法的特点
①  抽象方法是没有方法内容的,只有一个方法名和参数列表的方法。并以;结尾。
②  在方法的返回类型前加abstract

③  抽象方法的内容由他的继承类根据继承类自身情况去写。重写这个方法时把abstract替换成override
注意:②③也是抽象属性的定义和实现的方法
 

 

例如:
     abstract   class  Class1  //定义抽象类
    { 

          protected string name;

          protected abstract string Name {  //定义抽象属性 get;  }

          protected int age;

          protected Class1()

         {

            name = "a";

            age = 4; 

         }

         protected  abstract void A();  //定义抽象方法
    }
   class Class2:Class1 {

      protected override string Nam

     { 

         //实现抽象属性get { return name; }

      }

 

      //实现方法时他的修饰符只能是范围比父类大,或是相同
      protected  override void A()

      { 

         //实现抽象方法
         Console.WriteLine("aaaaaaaaaaaa"); }

         static void Main()

        {

            Class2 c = new Class2(); //正确,继承类可以定义自己的对象
            Class1 c1=new Class1(); //错误,抽象类不能定义自己的对象
            Console.WriteLine(c.Name + "/n" + c.age);

            c.A();

         }

}

 

4.抽象类里的普通方法如果也想在子类中重写,有两种方法:
①在父类普通方法的返回类型前写virtual,这就告诉系统父类这个方法是虚的方法,在子类中重写该方法时,在方法的返回类型前可以什么也不写,可以写new,也可以写override,然后子类对象调用的方法就是在子类中重写的方法。 

②在父类普通方法的返回类型前什么都不写,在子类中重写该方法时,在方法的返回类型前可以什么也不写,可以写new 。然后子类对象调用的方法就是在子类中重写的方法。 

例如:
Abstract Class C

{

      Protected abstract void A();

      Protected void B(){

           Console.WriteLine("bbbbb");

}

}

Class Class1:C

{

      Protected void A() {

      Console.WriteLine("aaaaaaa");  }

      //Protected new void B(){ //正确}

      //Protected override void B(){//正确}

      Protected void B(){ //正确
 

      Console.WriteLine("cccccccccccccc");

}

Static void Main() {

      Class1 c1=new Class();

      c.A();                         结果是:aaaaaaa

                                        cccccccccccccc

      c.B();

}

}


本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/wochuailimin/archive/2010/05/27/5629044.aspx

                 抽象类和接口

抽象类

类中定义一些不含方法体的方法,它的方法体实现交给该类的子类根据自己的情况去实现,这样的方法就是抽象方法,包含抽象方法的类就是抽象类。包含的抽象方法一个或多个。。

 

定义规则:

A.      抽象类abstract修饰符来修饰,抽象方法用abstract来修饰

B.      抽象类不能实例化(就是不能用new 去生成对象)

C.      抽象方法只需声明,不需实现,

D.      抽象方法的类必须声明是抽象类,抽象类的子类必须覆盖所有抽象方法后,才能被实例化,否则还是个抽象类

 

 

abstract int aaint a{} // 错,有花括号,有实现部分,只不过为空、、、

正确的形式是:abstract int aaint a);

抽象类中抽象的方法,必须有关键字abstract

 

Vehicle v = new Car(); 正确

// 多态的体现,虽然抽象类不可以创建对象,但是可以声明一个变量,引用可以实现了抽象方法的的子类对象

 

子类可以继承抽象类的属性和方法(和普通类继承一样),父类抽象类定义非private的成员变量,子类可以继承

 

 

接口(interface

如果一个抽象类的所有方法都是抽象的,就可以将这个类用另外一种方式定义,用接口定义。

接口是抽象方法和常量值的集合,从本质上讲,接口是一种特殊的抽象类,其中没有变量和方法实现。

定义:

 

public interface Runner{

   int ID=1;

   void run( );//// 不用abstract修饰!!这点和抽象类不同。。abstract也可以。

}

接口的特点

u       在接口里只能声明抽象方法。

u       接口只能声明常量(final)

u       接口里只能声明public的访问权限

  int ID = 1; 相当于public static final int ID = 1;

接口定义中成员默认都是public访问类型的,

变量默认都是public static final标识的,所以接口中定义的变量都是全局静态常量

 

用法:

u       定义一个新接口,用extends继承一个已有接口

u       定义一个类,用implements去实现一个接口中所有方法

u       定义一个抽象类,用implements去实现已有接口中的部分方法

u       可以实现多态,例子如下

  Fly[] flys = new Fly[2];

    //可以实现多态,只要实现了接口Fly的类的对象都可以用flys中元素指向

    flys[0] = new Plane();

    flys[1] = new Bird();

但是只能直接访问该接口中的定义的方法,如果要调用另外一个接口中定义的方法,要进行格式转换

Sing s = new Plane();

       s.sing();

       if (s instanceof Fly){ // 飞机实现了Fly,和Sing两个接口

           ((Fly)s).fly();

       }  

u       多个接口,用逗号分隔。例如:class A implements Fly, Sing{};

 

  

接口和抽象类的区别?


1.
从使用目的来看:
  
接口只是一个类间的协议,它并没有规定怎么去实现;
  
抽象类可以重用你代码使你的代码更加简洁;
2.
从行为来看:
  
接口可以多继承,multi-implement
  
抽象类不能实例化,必须子类化才能实例化;

3.
从属性来看:
  
接口的属性必须是常量;即public static final;
  
抽象类的属性没有要求;
4.
从方法来看:
  
接口的每个方法只是声明不包括内容;
  
抽象类的方法即可以是抽象的也可以不是抽象的;一般至少有一个是抽象的;

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。
    转藏 分享 献花(0

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多