C#中A a=new B()的意义

 

A a=new B()的意义
前提：A是B的父类。
A a = new B();
或
A a;
B b=new B();
a=b;

这一句的过程是这样的，
1)建立一个类A的引用a
2)建立一个类B的实例
3)把类B的引用赋值给a

由于A是B的父类，因此，赋值成功。

过程：

当消息发送到子类并要求以肯定的参数调用其中一个方法时：

消息的处理以下沿着类链自下而上逐级查找，直到找到符合消息所要求的方法为止。

子类检查是否有同名且参数彻底对应（参数的个数、类型、排列顺序均要相同）的方法，

如有，

就调用它，

若没有，

它的父类就响应这个消息的处理，

查找同名及同参数个数、类型、顺序的方法，

如有，

就调用这个方法。

若是查找到最上层仍未找到就会产生"编译出错"。

子类中如有与其祖先类同名的并具备相同参数表的方法时，

则具备屏蔽或隐藏其祖先类同名方法的功能。

B继承A A a=new B();B a=new B()区别

public abstract class A

    {

        public A()

        {Console.WriteLine('A');}

        public virtual void Fun()

        {Console.WriteLine("A.Fun()");}

     }

    public class B : A

    {

        public B()

        {Console.WriteLine('B');}

     public new void Fun()

        {Console.WriteLine("B.Fun()");}

     public static void Main()

        {

          A a = new B();

          a.Fun();

            }
}

他的输出时 A B A.Fun()

A a=new B();

这里a编译时类型是A,运行类型是B". 因此构造函数的调用就清晰明了吧

然而仍是有点奇怪,若是a运行时类型是B的话,那么在调用方法F()时,为何不调用B的方法F()(而是调用 A 的方法F())呢?

这是由于父类引用指向子类的对象(实例)

这时候 会调用子类重写的方法 可是不能调用父类没有的可是子类有的方法

再有就是override与new得区别

如过程序里面的new换成override输出时是什么样子呢？

将会是 A B B.Fun();这是为何呢

override的“覆盖”也就是次数重写是指子类覆盖了父类思路方法子类对象没法再访问父类中该思路方法

new是指“隐藏”是指子类隐藏了父类思路方法固然经过定转换能够在子类对象中访问父类思路方法
new 修饰符
使用 new 修饰符显式隐藏从基类继承的成员。若要隐藏继承的成员，请使用相同名称在派生类中声明该成员，并用 new 修饰符修饰它

1.B继承A，请问a是A的实例仍是B的实例啊？
答：B的实例

2.对象a能够调用A类中的方法吗？能够调用B的方法吗？
答：不必定，若是是虚拟方法，而且在B类重载了A的虚拟方法，a将会调用B的同名方法，普通方法会调用A的方法，

举例：
class A
{
public void MethodA(){...}
public virtual void MethodB(){...}
}

class B:A
{
public new void MethodA(){...}
public override void MethodB(){...}
}

其中，B类重写了A类的普通方法MethodA，也重写了A类的虚拟方法MethodB，则：
A a = new B();
a.MethodA();// 将会调用A类的MethodA方法
a.MethodB();// 将会调用B类的MethodB方

Ｂ是Ａ的子类，用A a=new B()，这样定义一个"a", 只能使用B中继承Ａ中的方法或变量，而在Ｂ中新增的方法或者变量，"a"不能引用。（也就是　a只能使用Ｂ复写Ａ中的方法或

者变量）

专业一点说是：a是A的引用，并建立了B的对象。
简单一点说：a是A的类型，但却拥有了B的功能。

你错在这句话 "而在Ｂ中新增的方法或者变量，"a"不能引用"

C#多态性的体现：重载，覆盖，隐藏2009-04-07 14:401.多态的理解

多态性的含义：使得可以利用基类的指针来引用不一样子类的对象,以及根据所引用对象的不一样,以不一样的方式执行相同的操做。

多态的做用：把不一样的子类对象都看成父类来看，能够屏蔽不一样子类对象之间的差别，写出通用的代码，作出通用的编程，以适应需求的不断变化。

多态分为编译期绑定和运行期绑定。

2.重载，覆盖，隐藏

using System;

using System.Collections.Generic;

using System.Text;

namespace VirtualAPP

{

    class Program

    {

        static void Main(string[] args)

        {

            //通常状况，没有体现多态

            A a = new A();

            a.F();//A.F

            a.G();//A.G

            B b = new B();

            b.F();//B.F

            b.G();//B.G

            b.F(" is overload");

            //体现多态特征

            A a1 = new B();

            a1.F();//A.F,隐藏

            a1.G();//B.G

            Console.ReadLine();

        }

        class A

        {

            public void F()

            { Console.WriteLine("A.F"); }

            public virtual void G()

            { Console.WriteLine("A.G"); }

        }

        class B : A

        {

            //隐藏

            public new void F()

            { Console.WriteLine("B.F"); }

            //重载

            public void F(string str)

            { Console.WriteLine("B.F2"+str); }

            //覆盖

            public override void G()

            { Console.WriteLine("B.G"); }

        }

    }

}
     重载(overload)用于同一类中的成员函数,其特征为:
     * 1)在同一类中
     * 2)相同的函数名
     * 3)参数不一样(包括参数类型不一样,或参数个数不一样,或二者都不一样,注意:和返回值不要紧)
     * 4)和是否虚函数无关

     覆盖(override)是指派生类函数覆盖基类函数,其特征为:
     * 1)不一样的范围(分别位于派生类与基类)
     * 2)相同的函数名称
     * 3)参数相同
     * 4)基类函数必须是虚函数

用法：基类中用virtual修饰符，子类中用override修饰符，重写后，子类对象和基类对象访问该方法时，结果都是在访问子类中从新定义的方法。

    隐藏(hide)是指派生类的函数屏蔽了与其同名的基类函数,其特征为:
     * 1)不一样的范围(分别位于派生类与基类)
     * 2)相同的函数名
     * 3)若参数不一样，无论基类函数有无virtual关键字，基类函数将会被隐藏。

         若参数相同，基类函数无virtual关键字。基类函数将会被隐藏。 注意： 用法：基类函数virtual修饰符无关紧要，子类函数可用new标识隐藏该方法，最后经过基类的引用访问该方法时，访问的还是基类的函数，子类对象访问的是子类的函数。