C#封装 继承 多态

usingSystem;

usingSystem.Collections.Generic;

usingSystem.Linq;

usingSystem.Text;

usingSystem.Threading.Tasks;

namespacelesson10

{

   enum Sex

    {

        men,women

    }

   class Person

    {

       public string name;//字段骆驼命名

       public Sex sex;

       public double Money;

       public Person() { Console.WriteLine("默认构造方法调用"); }//默认访问修饰符是私有的

       public Person(stringname, Sex sex)

        {

           this.name = name;//如果类没建对象，this等于类，如果创建对象了，this就指对象

           this.sex = sex;

        }

    }

   class Teacher: Person

    {

       public string name;//字段骆驼命名

       public Sex sex;

       public string teach;

       //public Teacher()

       //{

       //    Console.WriteLine("teachr");

       //}

       public Teacher(stringname, Sex sex, string teach):base(name,sex)//base继承父类的字段  

           //base()有参数  父类里面也必须要有有参数的构造函数

        {

           //this.name = name;

           //this.sex = sex;

           

           this.teach = teach;

        }

       public void WolkDog(Dogsl) {

           Console.WriteLine("遛狗");

        }

    }

   class Dog

    {

       public void Bark() { Console.WriteLine( "dog,bark"); }

    }

   class SmallDog: Dog

    {

       public void SmallDogBark() { Console.WriteLine( "sl,baek"); }

    }

   class BigDog: Dog

    {

       public void BigDogBark() { Console.WriteLine( "big,bark"); }

    }

   class Student : Person

{

       public Student()

        {

         

        }

       //public string name;

       //public Sex sex;

       public Teacher teacher;

       public Student( Sexsex, Teacher teacher) : base()//base()无参数  父类里面也必须要有无参数的构造函数

        {

         

           this.sex = sex;

           this.teacher = teacher;

        }

    }

   //面向对象  先找对象 

   //class Elephant

   //{

   //}

   //class IceBox

   //{

   //    public void Open() { Console.WriteLine("冰箱门打开了"); }

   //    public void Zhuang(string thing)

   //    {

   //        Console.WriteLine("把" + thing + "装进冰箱");

   //    }

   //    public void Off() { Console.WriteLine("冰箱门关上了"); }

   //}

   //class House //封装

   //{

   //    double price;//私有的

   //        string add;

   //    public string Add

   //    {

   //        get

   //        {

   //            return Add;

   //        }

   //        set

   //        {

   //            Add = value;

   //        }

   //    }

   //    public House(double price,string add) {

   //        this.price = price;

   //        this.add = add;

   //    }

   //}

   class Master

    {

       public void Exam() { Console.WriteLine( "师傅考试" ); }

    }

   class Disciple: Master

    {

       public virtual   void Exam() { Console.WriteLine("徒弟考试"); }

    }

   class Disciple5552: Disciple

    {

       public override voidExam() { Console.WriteLine("徒孙考试"); }

    }

   class Program

    {

       static void Main(string[] args)

        {

           //构造方法是与类名相同，并且无返回值，不加void；

           //作用  主要是创建对象，并给对象赋初始值

           //不带参数的构造方法称为默认构造

           //构造方法可以带有参数，可以重载

           //person 点不出来构造方法。 构造方法 只能在new对象中用       

           //如果给对象赋初始值可以在类里面写出带有参数的构造方法并使用；

           //Person person = new Person("张三",Sex.men  );

           Person s = new Person();

             优先调用无参数的构造方法，，如果在类里面没有任何对象，系统会默认一个构造 供我们使用，如果有带参数的构造的方法，

           调用默认构造时 必须显示的把默认构造写出来

           //Console.WriteLine(person.name );

           //Console.WriteLine(person .sex );

           //Teacher teacher = new Teacher("李",Sex.men ,"语文");

           //Student student = new Student("王",Sex.women ,teacher );

           //Console.WriteLine(teacher .teach );

           //Console.WriteLine(student .name );

           //IceBox a = new IceBox();

           //Elephant b = new Elephant();

           //a.Open();

           //a.Zhuang("大象");

           //a.Off();

           //a.Open();

           //a.Zhuang("白菜");

           //a.Off();

           //面向对象的三大特性

           //封装  继承 多态

           //封装  我们在创建对象时不需要外部人为的破幻对象所包含的值，此时就需要把字段给封装起来

           //具体的做法是把成员的字段用Private 来修饰，这样外部就无法拿到字段并修改所储存的数据，同时把私有的字段改成属性

           //通过属性修改字段的值，创建对象并初始化对象时，可以用带有参数的构造方法给字段赋值，

           //把字段写成私有，在外部拿不到，但是在类内部可以调用字段

           //继承  

           //被继承的称为父类，或者基类   继承的称为子类

           //当一个子类继承父类时 ，会把父类里面的成员继承过来

           //父类里面的成员用public修饰，共有的 会被继承过来，如果是private修饰，是私有的 继承过来不能用

           //共有继承过来的成员在任何地方都可以使用，私有继承过来的成员只能在父类内部使用，在类的外面不能使用，

           //protected继承过来的成员只能父类和子类里面使用类的外面不能用

           //里氏转换

           //为了在处理数据时，为了使所处理的数据类型达到统一，此时会把数据的类型统一写成父类类型

           //这样就可以把子类的对象赋值给父类；

           //里氏转换的第一个原则，把子类的对象赋值给父类,但是调用类里面的成员时只能调用父类里面的，子类里面的调不到

           //里氏转换的第二个原则，把父类的对象转换成子类,用as  在第一原则上建立的  转换不成功就是null

           //Person person = new Person();

           //Console.WriteLine(person.name );

           //Teacher teacher = new Teacher("li56+", Sex.men, "yu");

           //Student student = new Student("lilkl", Sex.women, teacher);

           Console.WriteLine(teacher.teach);

           Console.WriteLine(teacher.sex);

           Console.WriteLine(teacher.name );

           Console.WriteLine(student.name);

           Console.WriteLine(student.sex);

           Console.WriteLine(student.teacher);

           SmallDog sldog = newSmallDog();

           BigDog bigdog = newBigDog();

           //teacher.WolkDog(bigdog);

           Dog kl = new Dog();

           SmallDog klll = kl asSmallDog;

            klll.SmallDogBark();

            klll.Bark();

           //Dog dog = sldog;

           SmallDog sllll=(SmallDog )dog;//不能用强制转换

           //SmallDog sllll = dog as SmallDog;

           //sllll.Bark();

           //sllll.SmallDogBark();

           //BigDog slll = dog as BigDog;

           //bool issllll = sllll is BigDog;//判断它是不是大狗类

           //Console.WriteLine(issllll);

           //if (slll != null)//转换不成功

           //{

           //    slll.BigDogBark();

           //}

           把值类型转换为引用类型的过程称为装箱  开辟双倍空间

           把引用类型转换成值类型称为拆箱        开辟双倍空间

           //int a = 10;

           //object obj = a;//所有的类都是object的子类 

           //Console.WriteLine(obj );

           //int b=(int )obj ;

           //Disciple sasa = new Disciple();

           //Disciple5552 sa = new Disciple5552();

           //子类里面有何父类同名的方法需要在子类的方法前加new表示  用子类的方法替换父类的方法，称为方法替换

           //使用new有意隐藏继承过来的同名的方法 new void  Exam

           //sasa.Exam();//各调个的方法

           //sa.Exam();

           //Disciple sasasa = sa;

           //多态

           //1.把父类里面的方法前面加virtual

           //2.在子类同名的方法前加 override 进行重写

           //当我们把一个子类的对象赋值给对象后，该对象在调用父类里面的虚方法时，如果子类重写了该虚方法，则调用的是子类

           //里面重写后的方法，否则就调用父类的虚方法

           //sasasa.Exam();

        }

    }

}