c# 抽象类（abstract）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//抽象类（abstract）
//abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。在类声明中使用abstract修饰符
//以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。
//抽象类的特性
//1、抽象类不能实例化。
//2、抽象类可以包含抽象方法和抽象访问器。
//3、不能用 sealed 修饰符修改抽象类，这意味着抽象类不能被继承。
//4、从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实现。
//抽象方法
//1、抽象方法是隐式的虚方法。
//2、只允许在抽象类使用抽象方法声明。
//3、因为抽象方法声明不提供实际的实现，所有没有方法体；方法声明只是以一个分号结束，
//并且在签名后没有大括号，实现由一个重写方法提供，此重写方法是非抽象类的成员。
//4、在抽象方法声明中使用static或virtual修饰符是错误的。
//5、除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样。
//6、在静态属性上使用abstract修饰符是错误的。
//7、在派生类中，通过包括使用override修饰符的属性声明，可以重写抽象的继承属性。
namespace 抽象类
{
    //定义一个抽象类
    abstract class A
    {
        protected int _x;
        //private abstract void F(); //报错！虚拟成员或抽象成员不能是私有的。
        public abstract void F();  //声明一个抽象方法，抽象方法必须定义在抽象类中，并且方法中不能包含主体。
        public abstract int X { get; set; }  //声明一个抽象属性
    }
    class B : A
    {
        public override void F()  //继承抽象类，必须重写抽象类中的抽象方法。
        {
            throw new NotImplementedException();
        }
        public override int X
        {
            get
            {
                return _x;
            }
            set
            {
                _x = value;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //A a = new A(); //报错！1、抽象类不能实例化。
            B b = new B(); //可以实例化
            b.X = 10;
            Console.WriteLine(b.X);
            Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 抽象类1
{
    //员工类
    abstract class Employee
    {
        protected string _name;
        protected Employee()
        {

        }
        protected Employee(string name)
        {
            _name = name;
        }
        //抽象方法
        public abstract void StartWork();  //如果实现共同操作使用虚方法，如果不知道实现操作使用抽象方法。
    }
    //经理类
    class Manager : Employee
    {
        //构造函数
        public Manager(string name)
            : base(name) //赋值给基类(Employee)构造函数name
        {

        }
        //重写虚方法
        public override void StartWork()  //使用虚方法实现面向对象的多态
        {
            Console.WriteLine(_name + "给员工下达任务");
        }
    }
    //秘书类
    class Secretary : Employee
    {
        public Secretary(string name) : base(name) { }
        public override void StartWork()
        {
            Console.WriteLine(_name + "协助经理");
        }
    }
    //销售类
    class Seller : Employee
    {
        public Seller(string name) : base(name) { }
        public override void StartWork()
        {
            Console.WriteLine(_name + "销售产品");
        }
    }
    //财务类
    class Accountant : Employee
    {
        public Accountant(string name) : base(name) { }
        public override void StartWork()
        {
            Console.WriteLine(_name + "管理公司财政");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Employee[] emp = new Employee[5];
            emp[0] = new Manager("张三");
            emp[1] = new Secretary("李四");
            emp[2] = new Seller("王五");
            emp[3] = new Seller("马六");
            emp[4] = new Accountant("钱七");
            Console.WriteLine("早上8点，开始工作");
            foreach (Employee e in emp)
            {
                e.StartWork();
            }
            Console.ReadKey();
        }
    }
}