抽象类特点

1　抽象成员必须标记为abstract,并且不能有任何实现

1     public abstract class Animal
2     {
3         // 存在的意义:让子类重写,来实现多态
4         public abstract void Bark();
5         public abstract string Name { get; set; }
6     }

View Code

2　抽象成员必须在抽象类中

1     class Program
2     {
3         // 错误说明
4         // Program.Cry()”是抽象的，但它包含在非抽象类“Program”中
5         public abstract void Cry();
6     }

View Code

3 抽象类不能被实例化

 1 public abstract class Animal
 2     {
 3         public abstract void Bark();
 4     }
 5 
 6 public class Program
 7     {
 8         static void Main(string[] args)
 9         {
10             // 无法创建抽象类或接口"Animal"的实例
11             Animal animal= new Animal();
12         }
13     }

View Code

4　子类继承抽象类后，必须把父类中的所有抽象成员都重写

（除非子类也是一个抽象类，则可以不重写）

 1  public abstract class Animal
 2     {
 3         // 存在的意义:让子类重写,来实现多态
 4 
 5         #region 非抽象成员
 6             private int _age;
 7 
 8             public int Age
 9             {
10                 get
11                 {
12                     return _age;
13                 }
14 
15                 set
16                 {
17                     _age = value;
18                 }
19             }
20 
21             public Animal(int age)
22             {
23                 this.Age = age;
24             }
25 
26             public Animal()
27             {
28 
29             }
30         #endregion
31 
32         #region 抽象成员
33             public abstract void Bark();
34             public abstract string Name { get; set; } 
35         #endregion
36 
37     }
38 
39     public class Dog : Animal
40     {
41         public override string Name
42         {
43             get
44             {
45                 throw new NotImplementedException();
46             }
47 
48             set
49             {
50                 throw new NotImplementedException();
51             }
52         }
53 
54         public override void Bark()
55         {
56             Console.WriteLine("狗狗汪汪叫");
57         }
58     }

View Code

5 　抽象成员的访问修饰符不能是private

6 　在抽象类中可以包含实例成员。并且抽象类中的实例可以不被子类实现

7　抽象类是有构造函数的。虽然不能被实例化。

8 如果父类中的抽象方法中有参数，那么，继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。

如果父类的方法中有返回值，那么子类在重写父类的方法的时候也必须要传入返回值。