用派生类构造函数去初始化基类

如图所示，Animal是基类，Cow是派生类。

Animal myCow = new Cow();
实例化了一个对象叫做myCow，它的类型是Animal，调用它的EatFood方法，也自然显示的是“Eat Food.”.
搞不懂的地方是：
Animal myCow = new Cow();这一句的意义是什么？
这一句和Animal myCow = new Animal();的区别是什么？




初学者，问的问题太浅薄，看书看到多态性这一块，看得不懂，希望各位给与指点，讲得透彻一点，万分感谢，

14 个解决方案

#1

覆盖和重写，还是有一点带你区别

你试试再定义一个virtual，再Cow中overrride的方法就知道了

不过纠结这些感觉意义不大，特别厌恶有些笔试题，继承，重载，静态，然后问 i = ? j = ?

#2

Animal myCow = new Cow();这一句的意义是什么？
-》如果Animal中增加 新属性或者方法，继承类就可以直接使用，无需自己在定义，比如定义一个Eat方法。

区别在于初始化的对象不一样，这个显而易见，对象不一样，自然包含的属性也可能不一样。

PS:个人观点，欢迎指正。

#3

你应该在  Cow中使用override来重写，而不是new。
这样你会更容易了解 继承的思想。
而Animal cow=new Cow();这是多态

static void Main(string[] args)
        {
            Animal a = new Cow();
            a.Test();       //Cow

            Console.ReadLine();
        }

        public class Animal
        {
            public virtual void Test()
            {
                Console.WriteLine("Animal");
            }
        }

        public class Cow:Animal
        {
            public override void Test()
            {
                Console.WriteLine("Cow");
            }
        }

#4

引用 2 楼 duanzi_peng 的回复:

Animal myCow = new Cow();这一句的意义是什么？
-》如果Animal中增加 新属性或者方法，继承类就可以直接使用，无需自己在定义，比如定义一个Eat方法。

区别在于初始化的对象不一样，这个显而易见，对象不一样，自然包含的属性也可能不一样。

PS:个人观点，欢迎指正。

你好！谢谢你的解答。
Animal myCow = new Cow();这一句该怎么去理解呢？我就是这个地方搞不明白，virtual/override以及new覆盖方法，这个我大致已经明白了。
Animal myCow = new Cow();这一句中，我用myCow.Gettype发现myCow的类型是Cow，所以我就很疑惑，前面的Animal是什么意思呢？
总的来说，就是这一句该如何去理解。
Class A = new Class();这一句，如何去理解呢。包括它是如何在内存中分配空间的。

#5

引用 3 楼 hanjun0612 的回复:

你应该在  Cow中使用override来重写，而不是new。
这样你会更容易了解 继承的思想。
而Animal cow=new Cow();这是多态

static void Main(string[] args)
        {
            Animal a = new Cow();
            a.Test();       //Cow

            Console.ReadLine();
        }

        public class Animal
        {
            public virtual void Test()
            {
                Console.WriteLine("Animal");
            }
        }

        public class Cow:Animal
        {
            public override void Test()
            {
                Console.WriteLine("Cow");
            }
        }

你好！谢谢你的解答。
Animal myCow = new Cow();这一句该怎么去理解呢？我就是这个地方搞不明白，virtual/override以及new覆盖方法，这个我大致已经明白了。
Animal myCow = new Cow();这一句中，我用myCow.Gettype发现myCow的类型是Cow，所以我就很疑惑，前面的Animal是什么意思呢？
总的来说，就是这一句该如何去理解。
Class A = new Class();这一句，如何去理解呢。包括它是如何在内存中分配空间的。 

#6

引用 4 楼 qq_36402950 的回复:

Quote: 引用 2 楼 duanzi_peng 的回复:

Animal myCow = new Cow();这一句的意义是什么？
-》如果Animal中增加 新属性或者方法，继承类就可以直接使用，无需自己在定义，比如定义一个Eat方法。

区别在于初始化的对象不一样，这个显而易见，对象不一样，自然包含的属性也可能不一样。

PS:个人观点，欢迎指正。

你好！谢谢你的解答。
Animal myCow = new Cow();这一句该怎么去理解呢？我就是这个地方搞不明白，virtual/override以及new覆盖方法，这个我大致已经明白了。
Animal myCow = new Cow();这一句中，我用myCow.Gettype发现myCow的类型是Cow，所以我就很疑惑，前面的Animal是什么意思呢？
总的来说，就是这一句该如何去理解。
Class A = new Class();这一句，如何去理解呢。包括它是如何在内存中分配空间的。

就理解为初始化一个子类。
因为你继承了呀，cow继承自Animal，就可以那样的去声明myCow.  new 的那个子类 GetType()自然就返回对应的子类类型。

#7

引用 4 楼 qq_36402950 的回复:

Quote: 引用 2 楼 duanzi_peng 的回复:

Animal myCow = new Cow();这一句的意义是什么？
-》如果Animal中增加 新属性或者方法，继承类就可以直接使用，无需自己在定义，比如定义一个Eat方法。

区别在于初始化的对象不一样，这个显而易见，对象不一样，自然包含的属性也可能不一样。

PS:个人观点，欢迎指正。

你好！谢谢你的解答。
Animal myCow = new Cow();这一句该怎么去理解呢？我就是这个地方搞不明白，virtual/override以及new覆盖方法，这个我大致已经明白了。
Animal myCow = new Cow();这一句中，我用myCow.Gettype发现myCow的类型是Cow，所以我就很疑惑，前面的Animal是什么意思呢？
总的来说，就是这一句该如何去理解。
Class A = new Class();这一句，如何去理解呢。包括它是如何在内存中分配空间的。

Animal myCow = new Cow();这句话时父类指向子类的引用
类似于 Cow c=new Cow();
Animal myCow=c;
你可以认为，对象是子类，只是转换成了父类。
在功能上来说，子类功能一般多余或等于父类功能。
那么当子类转换成父类后，其实变相的就是约束了子类的其他功能，他只显示了父类具有的功能。这是多态。

#8

引用 6 楼 duanzi_peng 的回复:

Quote: 引用 4 楼 qq_36402950 的回复:

Quote: 引用 2 楼 duanzi_peng 的回复:

Animal myCow = new Cow();这一句的意义是什么？
-》如果Animal中增加 新属性或者方法，继承类就可以直接使用，无需自己在定义，比如定义一个Eat方法。

区别在于初始化的对象不一样，这个显而易见，对象不一样，自然包含的属性也可能不一样。

PS:个人观点，欢迎指正。

你好！谢谢你的解答。
Animal myCow = new Cow();这一句该怎么去理解呢？我就是这个地方搞不明白，virtual/override以及new覆盖方法，这个我大致已经明白了。
Animal myCow = new Cow();这一句中，我用myCow.Gettype发现myCow的类型是Cow，所以我就很疑惑，前面的Animal是什么意思呢？
总的来说，就是这一句该如何去理解。
Class A = new Class();这一句，如何去理解呢。包括它是如何在内存中分配空间的。

就理解为初始化一个子类。
因为你继承了呀，cow继承自Animal，就可以那样的去声明myCow.  new 的那个子类 GetType()自然就返回对应的子类类型。

请问这个在内存当中是怎么实现和运行的呀？

#9

A a = new B();
等价于
 B b = new B();
            A a1 = b;
并且由于转换为父类A，所以Test1就被约束没了。

static void Main(string[] args)
        {
            A a = new B();
            a.Test();       //I am B

            B b = new B();
            A a1 = b;
            a1.Test();      //I am B

            Console.ReadLine();
        }

        public class A
        {
            public virtual void Test()
            {
                Console.WriteLine("I am A");
            }
        }

        public class B:A
        {
            public override void Test()
            {
                Console.WriteLine("I am B");
            }
            public void Test1()
            {
                Console.WriteLine("hello");
            }
        }

#10

引用 8 楼 qq_36402950 的回复:

Quote: 引用 6 楼 duanzi_peng 的回复:

Quote: 引用 4 楼 qq_36402950 的回复:

Quote: 引用 2 楼 duanzi_peng 的回复:

Animal myCow = new Cow();这一句的意义是什么？
-》如果Animal中增加 新属性或者方法，继承类就可以直接使用，无需自己在定义，比如定义一个Eat方法。

区别在于初始化的对象不一样，这个显而易见，对象不一样，自然包含的属性也可能不一样。

PS:个人观点，欢迎指正。

你好！谢谢你的解答。
Animal myCow = new Cow();这一句该怎么去理解呢？我就是这个地方搞不明白，virtual/override以及new覆盖方法，这个我大致已经明白了。
Animal myCow = new Cow();这一句中，我用myCow.Gettype发现myCow的类型是Cow，所以我就很疑惑，前面的Animal是什么意思呢？
总的来说，就是这一句该如何去理解。
Class A = new Class();这一句，如何去理解呢。包括它是如何在内存中分配空间的。

就理解为初始化一个子类。
因为你继承了呀，cow继承自Animal，就可以那样的去声明myCow.  new 的那个子类 GetType()自然就返回对应的子类类型。

请问这个在内存当中是怎么实现和运行的呀？

没有“运行”这个说法，你能说类再内存上运行么，只能说是类再内存在分配，被回收，被销毁等等。
这就是一个初始化类的简单代码，生成的时候C#编译器会编译代码，之后JIT编译器会编译代码生成IL中间语言并确定它所需的大小。分配内存发生在应用程序启动的时候，也就是windows为应用程序分配相应的进程虚拟地址空间的时候，CLR会将所有的对象分配到这个地址空间，根据自身大小来在内存上划分自己的区域。

#11

引用 9 楼 hanjun0612 的回复:

A a = new B();
等价于
 B b = new B();
            A a1 = b;
并且由于转换为父类A，所以Test1就被约束没了。

static void Main(string[] args)
        {
            A a = new B();
            a.Test();       //I am B

            B b = new B();
            A a1 = b;
            a1.Test();      //I am B

            Console.ReadLine();
        }

        public class A
        {
            public virtual void Test()
            {
                Console.WriteLine("I am A");
            }
        }

        public class B:A
        {
            public override void Test()
            {
                Console.WriteLine("I am B");
            }
            public void Test1()
            {
                Console.WriteLine("hello");
            }
        }

你好！！！我感觉那个语句我理解一些了！万分感谢。
还有问题就是，Class A  =  new Class()；，这一句，我的理解是，在栈内存中创建一个引用变量A，这个A指向堆内存中的一块区域，堆内存中存放的是一个Class类型的对象。不知我这个理解有没有错误呢？

接下来换到这一句，Animal myCowA  = new Cow()；我的理解是这样的，在栈内存中创建一个引用变量myCowA，这个myCowA指向堆内存中的一块区域，堆内存中存放的是一个Cow类型的对象。
如果是Cow myCowB = new Cow();那就是这么理解，在栈内存中创建一个引用变量myCowB，这个myCowB指向堆内存中的一块区域，堆内存中存放的是一个Cow类型的对象。
那么问题来了，这两个引用变量myCowA以及myCowB，它在栈内存中是如何生成并分配空间的呢？根据的是前面的Animal和Cow吗？这两个引用变量有什么区别呢？

#12

引用 10 楼 duanzi_peng 的回复:

Quote: 引用 8 楼 qq_36402950 的回复:

Quote: 引用 6 楼 duanzi_peng 的回复:

Quote: 引用 4 楼 qq_36402950 的回复:

Quote: 引用 2 楼 duanzi_peng 的回复:

Animal myCow = new Cow();这一句的意义是什么？
-》如果Animal中增加 新属性或者方法，继承类就可以直接使用，无需自己在定义，比如定义一个Eat方法。

区别在于初始化的对象不一样，这个显而易见，对象不一样，自然包含的属性也可能不一样。

PS:个人观点，欢迎指正。

你好！谢谢你的解答。
Animal myCow = new Cow();这一句该怎么去理解呢？我就是这个地方搞不明白，virtual/override以及new覆盖方法，这个我大致已经明白了。
Animal myCow = new Cow();这一句中，我用myCow.Gettype发现myCow的类型是Cow，所以我就很疑惑，前面的Animal是什么意思呢？
总的来说，就是这一句该如何去理解。
Class A = new Class();这一句，如何去理解呢。包括它是如何在内存中分配空间的。

就理解为初始化一个子类。
因为你继承了呀，cow继承自Animal，就可以那样的去声明myCow.  new 的那个子类 GetType()自然就返回对应的子类类型。

请问这个在内存当中是怎么实现和运行的呀？

没有“运行”这个说法，你能说类再内存上运行么，只能说是类再内存在分配，被回收，被销毁等等。
这就是一个初始化类的简单代码，生成的时候C#编译器会编译代码，之后JIT编译器会编译代码生成IL中间语言并确定它所需的大小。分配内存发生在应用程序启动的时候，也就是windows为应用程序分配相应的进程虚拟地址空间的时候，CLR会将所有的对象分配到这个地址空间，根据自身大小来在内存上划分自己的区域。

Class A  =  new Class()；，这一句，我的理解是，在栈内存中创建一个引用变量A，这个A指向堆内存中的一块区域，堆内存中存放的是一个Class类型的对象。不知我这个理解有没有错误呢？

接下来换到这一句，Animal myCowA  = new Cow()；我的理解是这样的，在栈内存中创建一个引用变量myCowA，这个myCowA指向堆内存中的一块区域，堆内存中存放的是一个Cow类型的对象。
如果是Cow myCowB = new Cow();那就是这么理解，在栈内存中创建一个引用变量myCowB，这个myCowB指向堆内存中的一块区域，堆内存中存放的是一个Cow类型的对象。
那么问题来了，这两个引用变量myCowA以及myCowB，它在栈内存中是如何生成并分配空间的呢？根据的是前面的Animal和Cow吗？这两个引用变量有什么区别呢？

#13

1 Class A  =  new Class()；，这一句，我的理解是，在栈内存中创建一个引用变量A，这个A指向堆内存中的一块区域，堆内存中存放的是一个Class类型的对象
没什么问题

2 myCowA以及myCowB分配的是2块内存
区别在于，myCowA  是被约束为只有父类行为的子类。
就像我前面说的 B继承A后，使用Animal myCowA  = new Cow()；这种方式，B类的Test1()方法就不能被调用了。

#14

这个是new覆盖和override重写的区别，注意你子类EatFood方法前面的关键字new，父类EatFood方法前面也没有关键字viruXX