【静态成员】

作用：将被雷达所有实例共享，所有实例都访问同一个内存地址

用法：用static声明

静态成员与实例成员分开保存

静态成员可以用整个类去访问 Dog.Num += 1;

【静态函数成员】

静态函数也是独立的，没有实例也可以调用。

静态函数不能访问实例成员，只能访问其他静态成员，实例函数可以访问静态

【接口】

用interface去声明，只能用来被实现（和抽象类类似，只能被类继承，语法与继承类似）

作用：指定一组函数成员，而不实现他们的引用类型

函数默认是public的声明，但是不能加任何声明

和继承不同的是：一类可以多接口

密闭类与密闭方法

使用sealed声明，

声明后，后续继承后不能修改

如果是基类，不想被修改，用virtual声明即可，如果是字类且用override去修改的，那么就需要同时加上sealed，来声明不可被其派生类修改

【抽象方法】

用abstract去定义，必须没有实际函数体，且必须去在派生类中用override去重写

【抽象类】

目的就是为了被继承

有抽象方法的必须用抽象类去标识

【构造函数】

作用：派生类对象中，包含基类的信息，在执行派生类的构造函数的时候，会先去隐式或显式的，调用基类构造函数。因为是有了基类才有派生类

调用顺序：引用类的 实例成员初始化>基类>引用类

【在派生类中直接调用基类构造函数】

实例：基类   

          基类私有属性 protected string _Name;

          基类定义构造函数public Pet(string name){_Name = name;}

          派生类引用基类构造函数(通过base直接去引用基类构造函数)

          派生类定义构造函数public Dog(string name):base(name){}

可以使用基类去引用指向派生类【如：Pet Dog = new Dog()，可以用宠物类去产生狗类，需要注意的是，调用的方法是引用的方法，即Pet】

共性：通过统一的容器，我们可以方便去管理。(如：当需要修改货品金额时，可以在容器中进行修改)

子类差异性：统一的行为中有所区别，也就是个性

【虚方法】是方法定义

作用：虚方法，可以使得类既有共性的属性和方法，也可以在运用时，体现出派生类的个性

用法：声明为“virtual”的。基类的虚方法，可以在派生类中使用override重写

【多态】是一种过程

作用：可以通过基类引用，调用虚函数，会指向派生类，调用派生类里面的同名函数，就叫多态

【数组定义】引用名[] 数组名 = new 类名[]{new 类名(),new 类名()};

                    Pet[] pets = new Pet[]{new Dog(),new Cat()};

【虚方法的知识点】

*重写虚方法，必须有相同的可访问性，且基类方法不能是私有的(private)

*不能重写静态(static)方法或者非虚方法

*方法、属性、索引器、事件，都可以用虚方法定义（既用virtual或override声明）

【隐藏方法】

作用：基类内容不可删除，但是可以在派生类中定义同名内容

用法：可以在派生类屏蔽基类时，在定义时添加【new关键字】（给编译器声明，同时给编程人员提示）

示例：基   类 public void PrintName();

          派生类 new public void PrintName();

【继承】

作用：当不想去重复写代码，可以去继承基类，减少代码编写量，派生类拥有基类的所有属性和方法

用法：public class 基类名

          public class 派生类名：基类名

特殊：Object是所有类的默认基类，是唯一的非派生类

虚方法：声明为 virtual 的方法就是虚方法，基类（父类）的虚方法可以在派生类（子类）中使用override进行重写

在使用时，如果已经在派生类中改成了override，那么调用的时候就是用override的了

public class 父类

{

}

继承：public class 子类：父类

{

}

使用时：子类 定义名字=new 子类

定义名字.   后面的就有父类的属性了

密闭类：sealed

抽象类：abstract，有抽象方法必须是抽象类

抽象方法：abstract，不能有方法体

虚方法：virtual

重写类：override

1.所有子类都有相同的一个使用字段时，可以将该字段的的赋值交给父类的构造函数，由子类传入即可（因为实例化是是先调用父类构造函数再子类的构造函数）。

public A(string name){ this.name=name;}  //父类构造函数

public B(string name):base(name){}  //子类构造函数

2.不想如1的话，在子类的构造函数后加this就可以使用本子类的构造函数，这样实例化时使用的就是子类构造函数

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();



        }
    }
}