C#中虚函数，抽象，接口的简单说明

抽象类
抽象类主要用来定义一些抽象的属性和方法，留待子类根据自己的情况实现这些属性和方法
抽象类不能生成实例，即不能new一个抽象类的实例
抽象类可以被继承，除非继承该抽象类的子类仍声明为抽象的，否则就必须实现这个抽象类的所有抽象属性和方法
一个类只能继承一个抽象类，如果需要实现多个类的抽象方法，必须使用接口
子类与抽象类是is关系

public abstract class myclass 
{ 
public abstract int myint(); 
} 
public class myclass1:myclass 
{ 
public override int myint() 
{ 
函数体； 
} 
} 

接口
接口主要用来定义一些抽象的属性和方法，留待实现类根据自己的情况实现这些属性和方法
接口不能生成实力，即不能new一个接口的实例
抽象类可以被实现，除非实现该接口的类声明为抽象的，否则就必须实现这个接口的所有抽象属性和方法
一个类可以实现多个接口
实现类与接口是has关系

nterface Imyinterface 
{ 
void myfunction(); 
string name 
{ 
get; 
set; 
} 
} 
class myclass:Imyinterface 
{ 
void myfunction() 
{ 
函数体； 
} 
string name 
{ 
get 
{ 
return name; 
} 
set 
{ 
name=value; 
} 
} 
}

虚函数

由virtual声明，它允许在派生类中被重写，要重写方法，必须先声名为virtual

public class myclass 
{ 
public virtual int myint() 
{ 
函数体； 
} 
} 
class myclass1:myclass 
{ 
public override int myint() 
{ 
函数体1； 
} 
} 

一个比较好的例子：

//1、不同类的对象间的关系：继承关系(父子)、组合关系（类中类）、利用关系（司机开车）、实例关系（BMW是Car）
//2、继承--“:“
/*
 * 1、继承或从其他类获得属性的类被称为：派生类（子类）；属性被派生的类被称为：基类（超类、父类）
 * 2、派生类的每个实例包含基类的属性和方法
 * 3、父类构造函数-->子类构造函数-->子类析构函数-->父类析构函数（构造函数从上到下，析构函数从下往上）
 * 4、base关键字：子类调用父类方法、属性，如可以使用base()来调用父类无参构造函数,也可以使用base(参数)来调用父类含参构造函数,
 *                还可以使用base.Method()来调用父类的Method()方法
 * 5、this关键字：调用本类的方法、属性，如this.Method()方法调用本类的Method()方法
 * 6、子类可以赋予父类，表现为父类的性质（父类不能赋予子类）
 */
using System;
//public class Car1
//{
//    public string color;
//    public void Drive()
//    {
//        Console.WriteLine("the Car is driving");
//    }
//}
//public class BMW1:Car1//继承
//{
//}
//public class Test1
//{
//    public static void Main()
//    {
//        BMW1 bmw1 = new BMW1();
//        bmw1.color = "red";//子类拥有父类的属性
//        bmw1.Drive();//子类拥有父类的方法
//    }
//}
//public class Car2
//{
//    public string color;
//    public Car2()
//    {
//        Console.WriteLine("父类无参构造器");
//    }
//    public Car2(string color)
//    {
//        this.color = color;
//        Console.WriteLine("父类含参构造器");
//    }
//    ~Car2()
//    {
//        Console.WriteLine("父类析构器");
//    }
//}
//public class BMW2 : Car2
//{
//    public BMW2()
//        : base("yellow")
//    {
//        Console.WriteLine("子类无参构造器");
//    }
//    public BMW2(string color): base("blue")
//    {
//        this.color = color;
//        Console.WriteLine("子类含参构造器");
//    }
//    ~BMW2()
//    {
//        Console.WriteLine("子类析构器");
//    }
//}
//public class Test2
//{
//    public static void Main()
//    {
//        //BMW2 bmw1 = new BMW2("red");//父类无参构造函数-->子类含参构造函数-->子类析构函数-->父类析构函数
//        //BMW2 bmw2 = new BMW2();//父类无参构造函数-->子类无参构造函数-->子类析构函数-->父类析构函数
//        //BMW2 bmw3 = new BMW2("red");//父类含参构造函数-->子类含参构造函数-->子类析构函数-->父类析构函数
//        //Console.WriteLine(bmw3.color);
//        //BMW2 bmw4 = new BMW2();//父类含参构造函数-->子类无参构造函数-->子类析构函数-->父类析构函数
//        //Console.WriteLine(bmw4.color);
//    }
//}
//public class Plane
//{
//    public int wheel;
//    public Plane()
//    {
//        Console.WriteLine("父类无参构造器");
//        this.Fly();//this.Fly()调用本类的方法
//    }
//    public Plane(int wheel)
//    {
//        this.wheel = wheel;
//        Console.WriteLine("父类含参构造器");
//    }
//    public void Fly()
//    {
//        Console.WriteLine("the plane is flying");
//    }
//}
//public class Helicopter : Plane
//{
//    public Helicopter()
//    {
//        Console.WriteLine("子类无参构造器");
//        base.Fly();//base.Fly()调用父类的方法
//    }
//}
//public class Test
//{
//    public static void Main()
//    {
//        Helicopter h = new Helicopter();
//    }
//}
//public class Fruit
//{
//    public string shape;
//    public void Grow()
//    {
//        Console.WriteLine("the fruit is growing");
//    }
//}
//public class Apple : Fruit
//{
//    public void Grow()
//    {
//        Console.WriteLine("the apple is growing");
//    }
//}
//public class Test
//{
//    public static void Main()
//    {
//        //Fruit f = new Fruit();
//        //f.Grow();//父类对象只能调用父类的方法
//        //Apple a = new Apple();
//        //a.Grow();//子类对象调用子类重写后的方法，若子类没有重写该方法，则会调用父类的方法
//        Fruit f1 = new Apple();//子类可以赋予父类,表现为父类的性质(苹果是水果)
//        f1.Grow();
//        //Apple a1 = new Fruit();//父类不能赋予子类(水果不是苹果)
//    }
//}
//3、抽象类、虚函数
/*
 * 1、不能创建抽象类的实例
 * 2、不能声明为封装
 * 3、抽象类可以包含抽象方法，也可以不包含抽象方法；若包含抽象方法，则必须被派生类实现
 * 4、抽象方法：没有方法体的方法（[访问修饰符] abstract 返回类型 方法名（参数列表）；）
 * 5、派生类通过override关键字来实现抽象方法
 * 6、虚函数：通过virtual关键字来定义虚函数，在继承类中可以通过override关键字以自己的方式重写该函数，也可以不重写
 * 7、子类可以赋给父类，如果方法被重写(override)了,则调用子类重写后的方法；反之方法没有重写的话，则调用父类的方法
 * 8、动态多态的2种实现方式：抽象方法和虚函数区别：1、有没有方法体 2、是否必须被重写
 */
//public abstract class Fish//抽象类
//{
//    public abstract void Swim();//抽象方法
//    public void Eat()//抽象类中可以含有除了抽象方法外的别的方法和属性
//    {
//        Console.WriteLine("鱼吃东西");
//    }
//}
//public class Shark : Fish
//{
//    public override void Swim()//通过override关键字来重写父类的抽象方法
//    {
//        Console.WriteLine("鲨鱼自游泳");
//    }
//}
//public class Test
//{
//    public static void Main()
//    {
//        //Fish f = new Fish();//不能创建抽象类的实例
//        Shark s = new Shark();//子类对象
//        s.Swim();
//        Fish f = new Shark();//子类对象赋给父类
//        f.Swim();
//    }
//}
//public class Bird
//{
//    public virtual void Jiao()//通过virtual关键字定义虚函数
//    {
//        Console.WriteLine("鸟叫");
//    }
//}
//public class XiQue : Bird
//{
//    public override void Jiao()//通过override关键字来实现重写，可以不重写
//    {
//        Console.WriteLine("喜鹊叫");
//    }
//}
//public class Test
//{
//    public static void Main()
//    {
//        XiQue x = new XiQue();//子类对象
//        x.Jiao();
//        Bird b = new XiQue();//子类对象赋给父类
//        b.Jiao();
//    }
//}
//4、封装类--sealed
/*
 * 1、使用sealed关键字封装类，使该类不能被继承
 * 2、使用sealed关键字封装方法，使该方法不能被重构
 */
public sealed class FinalClass//封装类
{ 
    public sealed void Do()//封装方法
    {
        Console.WriteLine("我吃东西");
    }
}
public class A:FinalClass
{
    //public void Do()
    //{
        
    //}
}
public class Test
{
    public static void Main()
    { 
    
    }
}