abstract 不能有函数体

抽象类

抽象方法没有函数体，必须重写；

虚方法有函数体，可以重写。

抽象方法：abstract----.override重写抽象类方法

虚方法：virtual

虚方法和抽象方法重写都用override

抽象成员：

1、必须是方法、属性、事件、索引

2、必须用abstract修饰符标记

3、不能有实现代码块

抽象类的存在只有一个目的，就是被继承

抽象类不能被实例化，用abstract修饰

抽象类可以包含抽象成员和普通成员，以及他们的任意组合

抽象类的抽象成员在派生类中需要用override关键字实现

抽象方法：

abstract public void Func();抽象方法没有函数体

virtual public void Func();虚方法可以有函数体

抽象

abstract标记函数是，不能有方法体，只能在子类中重写。

抽象成员;必须是方法，索引，事件，索引。必须用abstract修饰符标记。不能有实现代码块。

抽象类存在就是被继承的，抽象类的实例无法被创建，

abstract标记函数是，不能有方法体，只能在子类中重写。

抽象成员;必须是方法，索引，事件，索引。必须用abstract修饰符标记。不能有实现代码块。

抽象类存在就是被继承的，抽象类的实例无法被创建，

抽象方法在方法前加  abstract  关键字 

父类方法无函数体，必须重写

派生类中使用override关键字实现

虚方法，派生类对象引用方法，派生类中对虚方法没有重写，引用父类虚方法；重写了，引用派生类虚方法

虚方法，父类方法有函数体；派生类可以不重写 

抽象类不能被实例化，用abstract修饰

抽象类注意点

抽象类Abstract

如果使用Virtual基类中可以有函数体 如果使用Abstract 基类型中不能有函数体

抽象类：

1、抽象类的存在只有一个目的，就是继承；

2、抽象类不能实例化，用abstract修饰；

3、抽象类可以包含抽象成员和普通成员，以及他们的任何组合；

4、抽象类的抽象成员在派生类中需要用override关键字实现；

抽象类定义

抽象方法：

抽象成员：必须是方法、属性、事件、索引

必须用abstract修饰符号标记

不能有实现代码块

仍然用override来进行继承

抽象类里面是不能有函数体的，只有声明 ，只有在子类中重写才可以使用

抽象类的存在的目的只有一个，就是被继承

抽象类不能实例化，用abstract修饰。

抽象类可以包含抽象成员和普通成员，以及他们的任意组合

抽象类的抽象成员在派生类中需要用override关键字实现

抽象类

    1、抽象类的存在只有一个目的，就是被继承

    2、抽象类不能实例化，用abstract修饰

    3、抽象类可以包含抽象成员和普通成员，以及他们的任意组合

    4、抽象类的抽象成员在派生类中需要（必须）用override关键字实现

抽象成员：

    1、必须是方法、属性、事件、索引

    2、必须用abstract修饰符标记

    3、不能有实现代码块

抽象类的存在目的，就是被继承

1. 虚方法 (virtual)  可以不重写 (override) ，抽象(abstract )必须 重写 (override) ,因为抽象方法没有函数体；

2. 有抽象方法，类必须是抽象类；

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ConsoleApp2

{

    abstract class Pet

    {

        protected string _Name;

        public Pet(string name)

        {

            _Name = name;

        }

        public void a()

        {

            Console.WriteLine("size:");

        }

        virtual public void b()

        {

            Console.WriteLine("fb:");

        }

         public void c()

        {

            Console.WriteLine(_Name);

        }

        abstract public void d();

    }

    class Cat:Pet

    {

        public Cat(string name) :base( name)

        {

        }

        new public void a()

        {

            Console.WriteLine("13:");

        }

        override public void b()

        {

            base.b();

        }

        override public  void d()

        {

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            //Console.Write("input：");

            //string a = Console.ReadLine();

            //Console.WriteLine("：" + a);

            ////得到字节长度

            //Console.WriteLine("size:" + sizeof(int));

            int[,] bb = new int[0,1];

            Cat b = new Cat("66");

            b.a();

            b.b();

            b.c();

            Console.ReadKey();

        }

    }

}

抽象成员：

1、必须是方法、属性、时间、索引；

2、必须用abstract修饰符标记；

3、不能有实现代码块。

抽象类：

抽象类的存在只有一个目的，就是被继承；不能实例化，用abstract修饰；可以包含抽象成员和普通成员，以及他们的任意组合；抽象成员在派生类中需要用override关键字实现。

抽象类

    1、抽象类的存在只有一个目的，就是被继承

    2、抽象类不能实例化，用abstract修饰

    3、抽象类可以包含抽象成员和普通成员，以及他们的任意组合

    4、抽象类的抽象成员在派生类中需要（必须）用override关键字实现

抽象成员：

    1、必须是方法、属性、事件、索引

    2、必须用abstract修饰符标记

    3、不能有实现代码块

抽象类无法实例化对象，仅仅是指不能直接实例化一个抽象类对象；但是使用父类指针指向子类这一行为实际上是实例化了一个子类对象，而子类对象并不是抽象类对象。就比如一个抽象类CanEat，它有一个Human这一子类继承。我们可以使用CanEat *p=new Human这一方式实例化一个Human对象，但不能使用CanEat *p=new CanEat这一方法