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();
//        lor = "red";//⼦类拥有⽗类的属性
//        bmw1.Drive();//⼦类拥有⽗类的⽅法
//    }
//}
//public class Car2
//{
//    public string color;
//    public Car2()
/
/    {
//        Console.WriteLine("⽗类⽆参构造器");
//    }
//    public Car2(string color)
//    {
//        lor = color;
//        Console.WriteLine("⽗类含参构造器");
//    }
//    ~Car2()
//    {
//        Console.WriteLine("⽗类析构器");
/
/    }
//}
//public class BMW2 : Car2
//{
//    public BMW2()
//        : base("yellow")
//    {
//        Console.WriteLine("⼦类⽆参构造器");
//    }
//    public BMW2(string color): base("blue")
//    {
/
/        lor = 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.lor);
//        //BMW2 bmw4 = new BMW2();//⽗类含参构造函数-->⼦类⽆参构造函数-->⼦类析构函数-->⽗类析构函数
//        //Console.lor);
//    }
//}
//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();//⽗类对象只能调⽤⽗类的⽅法writeline函数
//        //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()
{
}
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。