C#三大特性

三大特性：

• 封装：将变量和对变量的操作封装到一个集合中
• 继承：子类直接使用父类定义好的字段和方法，从而实现代码的复用

基类（父类）：被继承的类
派生类（子类）：继承的类
基类的私有成员：
1.继承自基类的公有成员方法（或属性）
2.将基类的私有成员改为保护（protected）成员
        public static void testAnimal()
        {
            Cow c = new Cow();
            c.Name = "撒阿飞";
            c.print();
            c.Age = 12;
            c.peint();
            Sheep s = new Sheep();
            s.Name = "爱看";
            s.Age = 37;
            s.peint();
            
        }
    class Animal
    {
        private string name;
        protected int age=100;//被保护，赋值
        //private Animal(string a,int b) { name = a;age = b; }基类中添加构造函数不能被子类继承
        public string Name{get{ return name; }set { name = value; } }
        public int Age { get { return age; } set { age=value; } }
        public void peint()
        {
            Console.WriteLine("{0},{1}",name,age);
        }
    class Cow : Animal
    {
        public void print()
        {
            Console.WriteLine(Name);
            Console.WriteLine(age);//需要赋值
        }
    } 
    class Sheep : Animal { }    
派生类构造函数：
派生类构造函数名（总参数表）：base(参数表){ 派生类新增加的数据成员初始化语句   }
        public static void testAB()
        {
            B b = new B(1, 2);
            b.print();
        }
        
    class A
    {
        protected int a;
        public A(int _a) { a = _a; }

    }
    class B : A
    {
            protected int b;
            public B(int _a, int _b) : base(_a) { b = _b; }
            public void print()
            {
                Console.WriteLine("{0},{1}", a, b);
//Circle 类是从通用类 Shape 派生的，Cylinder 类是从 Circle 类派生的。每个派生类的构造函数都使用其基类的初始值设定项。    

• 多态：使用父类对象统一操作子类对象，从而使父类对象有多种表现形态
• 重写：子类根据需要重复去定义父类某个方法的不同实现

1. 子类重写：override
2. 父类：virtual

• 虚方法:被重写的方法
• 隐藏基类成员：如果希望派生类具有与基类中的成员相同的名称，但是又不希望派生类成员参与虚调用，就可以使用new关键字，将基类成员隐藏起来。可以理解为new是子类使用

        public static void testanilam()
        {
            //Cat c = new Cat();
            //c.eatfood();
            //an实际指向的是两个子类对象的空间，当an 调用eatfood()方法时，将根据an实际指向的对象类型来确定调用的哪个方法
            //父类对象就会表现出子类的对象内容
            animal an = new Cat();
            an.eatfood();//猫吃鱼
            //Dog d = new Dog();
            an = new Dog();
            an.eatfood();//狗吃肉
            
    class animal
    {
        public virtual void eatfood() { Console.WriteLine("动物吃东西"); }//虚方法
    }
    class Cat : animal
    {
        public override void eatfood() { Console.WriteLine("猫吃鱼"); }
    }//将override改为new达到隐藏基类成员
    class Dog : animal
    {
        public override void eatfood() { Console.WriteLine("狗吃肉"); }
    }

密封类：如果不希望自己的类被继承，可以使用关键字sealed来达到该类不能派生其他类的目的

    class C { }
    sealed  class D : C { }
    //class E : D { }不能继承D

密封方法：指派生类可以通过将其重写的方法声明为sealed来停止后面的派生类实现虚拟继承

    class F { public virtual void Dowork() { } }
    class G : F { public sealed override void Dowork() { } }//停止后面的虚拟继承
    //class H : G {public override void Dowork() { } }

抽象方法：只能声明不能实现

• 当用abstract关键字创建不完整且必须在派生类中实现的类和方法
• 注意：

1. 抽象类只能被继承，不能实例化
2. 抽象方法不能实现，只能在子类中实现

    abstract class Shape
    {
        public abstract void draw();
    }
    class Circle : Shape
    {
        public override void draw()
        {
            Console.WriteLine("我是一个圆");
        }
    }

Tostring()方法：它是用于返回对象的字符串表示，直接用输出语句输出该类的对象

            Person p = new Person("agfae", 37);
            Console.WriteLine(p);
            
    class Person
    {
        private string name;
        private int age;
        public Person(string n,int a)
        {
            name = n;
            age = a;
        }
        public override string ToString()
        {
            return string.Format("{0},{1}",name,age);
        }
    }