主函数里声明派生类对象，然后直接 .字段名 就能得到价格了，

比如Cat cat = new Cat();

Console.Write(cat.Price);

结果也不一样，，，在子类中用了new，如果调用的是基类，得到的结果是基类的结果；如果是用了虚方法，那么即使调用基类，得到的也是派生类的结果。

字段相当于赋值，建立一个等效关系，而方法相当于是一个执行语句，如果不声明的话，直接用输出指令时会提示错误，因为它不能按照字段的等效关系去运行。

是的，父类需要public，想要继承使用的父类成员时，父类成员也需要public或者protected

这句话是建立了一个宠物类的数组，{new Dog("Jack"),new Cat("Tom")}就是表示这个数组中间的成员。

就相当于：

动物 a = new 鸟();//我要一个动物就行（动物 a）,给了一只鸟（new 鸟()）

a.吃();//我们知道a是动物，动物都能吃，所以a.吃()没有问题。

a.飞();//这句话就有问题了，因为不是所有的动物a都能飞();所以，动物a是不能访问鸟的飞()的。

你是陈世美吗？要那么多对象干嘛？

题主所指的new是子类里隐藏父类方法的关键字，不是新建实例关键字。

virtual是虚函数关键字，修饰父类里的函数，子类可以用override重写该函数。

virtual一般用在父类里，new一般用在子类里，其是成员修饰符。public是访问修饰符，用来限制访问权限。

在c#里还有一种修饰符是类修饰符，例如：abstract。

书写顺序习惯上一般是：访问修饰符 + 类修饰符，或者：成员修饰符 + 类修饰符

但是不按照上面的顺序书写，编译器也不会报错，只是不太常用而已。

狗是猫吗？猫是狗吗？

都不是对吧，所以他们是个不同类型的类，但他们都是pet，宠物，可以在pet当中创建构造方法

在子类中，使用base关键字

问题1：用基类引用指向派生类时，只能使用基类中的方法。但是，若基类里面有虚方法或抽象方法，且派生类里面也重写了该虚方法或抽象方法，则程序运行时会调用派生类里面重写的方法。

问题2：若基类里面有虚方法，派生里面没有用override重写虚方法的话，则会调用基类里面的虚方法，但是意义不大，虚方法的主要作用是体现功能多态性。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    //public class Pet {
    //    public Pet(string name) {
    //        _name = name;
        
    //    }
    //    protected string _name;
    //    public void PrintName() {

    //        Console.WriteLine("Pet`s name is"+_name);  
    //    }
    //   //虚方法
    //    virtual public void speak() {

    //        Console.WriteLine(_name+"is speaking");
    //    }
    //}
    //结构
    struct fish {
        int weight;
        int price;
    
    }
    //接口
    interface ICatchMice {

        void catchMice();
    }
    interface IClimbTree {

        void climbTree();
    }
   abstract public class Pet
    {
        public Pet(string name)
        {
            _name = name;

        }
        protected string _name;
        public void PrintName()
        {

            Console.WriteLine("Pet`s name is" + _name);
        }
        //抽象类，没有函数体，无法实例化
        abstract public void speak();
        //{

            //Console.WriteLine(_name + "is speaking");
        //}
    }
    //狗类
    public class Dog : Pet {
        //静态
        static int num;
        static Dog() {
            num = 0;
        
        }
        //构造函数
        public Dog(string name):base(name) {
            //_name = name;
            ++num;
        
        }
        new public void PrintName() {
            Console.WriteLine("我的宠物是"+_name);
        }
        public override void speak()//重写
        {
            Console.WriteLine(_name + " is speaking"+" wow");
        }
        static public void ShowNum() {

            Console.WriteLine("有"+num+"条狗");
        }
    }
    //猫类
    public class Cat : Pet,ICatchMice,IClimbTree {
        //构造函数
        public Cat(string name):base(name) {
            //_name = name;
        
        }
        new public void PrintName() {
            Console.WriteLine("我的宠物是"+_name);
        }
        public override void speak()
        {
            Console.WriteLine(_name + "is speaking"+" meow");
        }
        public void catchMice() {

            Console.WriteLine("catchmice");
        }
        public void climbTree() {
            Console.WriteLine("climbtree");
        }
    
    }
    //静态类，方法扩展
    static class PetGuide{

        static public void HowToFeed(this Dog dog) {
            Console.WriteLine("Play a vedio how to feed dog");
        }
    
    }
    class Program
    {
        static void Main(string[] args)
        {

            //Dog Dog = new Dog();
            //Dog.Name = "Jack";
            //Dog.PrintName();
            //Dog.speak();
            //Pet Cat = new Cat();
            //Cat.Name = "Tom";
            //Cat.PrintName();
            //Cat.speak();
            Pet[] pets = new Pet[]{new Dog("Jack"),new Cat("Tom")};
            for (int i = 0; i < pets.Length;i++ ) {
                pets[i].speak();
             
            }
            Cat c = new Cat("Tom2");
            IClimbTree climb = (IClimbTree)c;
            c.catchMice();
            climb.climbTree();
            Dog a = new Dog("Jack1");
            Dog.ShowNum();

            Dog dog = new Dog("Tommy");
            dog.HowToFeed();



        }
    }
}

class Program{
    static void Main(string[] args){
    Pet dog = new Dog();                            //这里使用了多态，引用是基类
    dog.Name = "Jack";                              //赋值，是给基类的Name赋值
    dog.PrintName();                                //这里需要引用派生类、相同签名、新的方法，要使用
                                                    虚方法，就需要在基类--方法--声明virtual
                                                    //然后再在派生类--方法--声明override，派生写基类的方法，
                                                    这个可称为复写、重写等等
                                                    //但是，Name属性给了基类，如果派生也有同名属性，
                                                    就会没有给派生类（一般不大会有这情况）
    dog.Speak();
    Pet cat = new Cat();
    cat.Name = "Tom";
    cat.PrintName();
    cat.Speak();
    }
}

++i 和i++是不一样的，++i是先加再给，i++是先给 i再加

new 用来隐藏基类中的方法，只有通过派生类本身类的引用才能调用出。

override 用来重写基类中的方法，通过基类调用出的是派生类重写后的方法。可以实现多态。

override重写的方法可以进行方法多态，new隐藏的就不行了，我也不是很懂为啥要这样搞

能够实现多态。

可以  你说的很好啊

如果是new，那你用基类声明一个子类的变量时，他不会调用子类new的方法，而是调用基类的方法，”E：Pet cat1=new Cat("Tom"); “   cat1.Speaking仍是调用基类的Speaking; 如果是用虚方法，“E：Pet cat2=new Cat("Tom"); ” ，cat2.Speaking调用的就是派生类的Speaking；不知道我讲的你能懂不，我也是刚学的。

Pet[] pets = new Pet[]{new Dog("旺财"),new Cat("汤姆")};

呵呵

new是隐藏父类方法，override是重载父类方法，区别就在调用的时候。如果父类类引用到派生类对象，通过父类引用去调用隐藏方法（new的），则调用基类方法；如果调用override同名方法，则调用的是派生类方法。