新手菜鸟学习C#的笔记总结 之多态

本人是初学菜鸟，有错误的地方欢迎大家指正。

多态的定义：同一操作作用于不同的类的实例，不同的类将进行不同的解释，最后产生不同的结果。有两种形式：

  1，编译时的多态，体现在重载上，根据传递的参数，返回值，来决定实现的操作。

  2，运行时的多态，体现在虚方法上，运行时，根据实际情况来决定实现何种操作。

具体多态的情况：

1，虚方法：通过virtual来实现。可以有方法体，可以被继承类重写。

class Phone
{
public virtual void displayInfo()
{
Console.WriteLine("Phone");
}
}
class HuaweiPhone : Phone
{
public override void displayInfo()
{
Console.WriteLine("HuaweiPhone");
}
}

class Program
{
static void Main(string[] args)
{
Phone p1 = new Phone();
HuaweiPhone p2 = new HuaweiPhone();
p1.displayInfo();
p2.displayInfo();
p1 = p2;
p1.displayInfo();
}
}

输出结果
Phone
HuaweiPhone
HuaweiPhone

2，抽象方法：通过关键字abstract 来实现，可以看做没有方法体的虚方法。

abstract class  Phone
{
public abstract void displayInfo();//抽象方法

}
class HuaweiPhone : Phone
{
public override void displayInfo()
{
Console.WriteLine("HuaweiPhone");
}
}

static void Main(string[] args)
{
Phone p1;
HuaweiPhone p2 = new HuaweiPhone();
p2.displayInfo();
p1 = p2;
p1.displayInfo();
}

输出结果
HuaweiPhone
HuaweiPhone

3，密封方法：通过关键词sealed来实现,密封方法可以防止该方法被重载。

class  Phone
{
public virtual void displayInfo()
{
Console.WriteLine("Phone");
}
public virtual void call()
{
Console.WriteLine("Calling frome Phone");
}

}
class HuaweiPhone:Phone
{
sealed public override void displayInfo()        //密封方法
{
Console.WriteLine("HuaweiPhone");
}
public override void call()//非密封的方法
{
Console.WriteLine("Calling frome HuaweiPhoe");
}
}
class U8800pro : HuaweiPhone
{
/*  public  void override displayInfo()                //此段会报错，因为密封类不能重写
{
Console.WriteLine("U8800pro");
}*/

public override void call()//重写没有被密封的方法
{
Console.WriteLine("Calling frome U8800pro");
}
}
class Program
{
static void Main(string[] args)
{
Phone p1=new Phone();
HuaweiPhone p2 = new HuaweiPhone();
U8800pro p3 = new U8800pro();
p1.displayInfo();
p2.displayInfo();
p3.displayInfo();
p1 = p3;
p1.displayInfo();
p1.call();
}
}

输出结果：
Phone
HuaweiPhone
HuaweiPhone
HuaweiPhone
Calling frome U8800pro

4，方法的隐藏：通过关键词new来实现，继承类，可以改变继承自基类的方法。但被转换为基类时，会调用基类的方法。

    class Phone
    {
        public void displayInfo()
        {
            Console.WriteLine("Phone");
        }
        public virtual void call()
        {
            Console.WriteLine("Call Frome Phone");
        }

    }
    class HuaweiPhone : Phone
    {
        public new void displayInfo()       //隐藏方法，当转换为基类时，该方法不会被调用
        {
            Console.WriteLine("HuaweiPhone");
        }
        public override void call()
        {
            Console.WriteLine("Call Frome HuaweiPhone");
        }
    }
 class Program
    {
        static void Main(string[] args)
        {
            Phone p1 = new Phone();
            HuaweiPhone p2 = new HuaweiPhone();
            p1.displayInfo();
            p1.call();
            p2.displayInfo();
            p2.call();

            p1 = p2;
            p1.displayInfo();   //将不会输出HuaweiPhone，实现了将方法隐藏
            p1.call();
        }
    }
输出结果
Phone
Call Frome Phone
HuaweiPhone
Call Frome HuaweiPhone
Phone
Call Frome HuaweiPhone

5，抽象类：通过关键字abstract来实现，可以作为基类，但不能直接实例化。不能是密封类。

abstract class  Phone
{
public abstract void displayInfo();
public void call()
{
Console.WriteLine("Call From Phone");
}
}
class HuaweiPhone:Phone
{
public override void displayInfo()
{
Console.WriteLine("HuaweiPhone");
}
public new void call()
{
Console.WriteLine("Call From HuaweiPhone");
}
}
static void Main(string[] args)
{
HuaweiPhone p2 = new HuaweiPhone();
p2.displayInfo();
p2.call();
Phone p1 = p2;
p1.displayInfo();
p1.call();
}

输出结果：
HuaweiPhone
Call From HuaweiPhone
HuaweiPhone
Call From Phone

6，密封类：通过关键词sealed来实现，目的是防止类被继承。

sealed class  Phone
{
public void displayInfo();
public void call()
{
Console.WriteLine("Call From Phone");
}
}
class HuaweiPhone:Phone			//此处编译出错，Phone不能被继承
{
public override void displayInfo()
{
Console.WriteLine("HuaweiPhone");
}
public new void call()
{
Console.WriteLine("Call From HuaweiPhone");
}
}

总结：