第十三章 C# 基础

一.object 

如果类没有明确的继承关系  默认继承object

object 是所有类的基类

调用

 MyClass2 myClass2 = new MyClass2();
            myClass2._id = 1;
            MyClass3 myClass3 = new MyClass3();
            myClass3._id = 2;

            Object ob =new Object();
            //ToString 是Object的方法 所有继承于此类的类的对象都能使用
            ob.ToString();
            int a = 1;
            a.ToString(); 
            char c = 'a';
            c.ToString();
            myClass3.ToString();


            //Object做为参数代表任意类型  
            Test(1);
            Test(myClass3);




           private static void Test(Object ob) {

            Console.WriteLine(ob);
        }

方法

public class MyClass1 :Object{

        public int _id;
    
    }
    public class MyClass2:MyClass1{

        public void MyClass2Mothod() {

            Console.WriteLine("111111111");
        }
    }

    public class MyClass3 : MyClass2
    {
        public void MyClass2Mothod(int a)
        {

            Console.WriteLine("22222222");
        }
    }

二.覆盖

覆盖 在子类中协议歌和基类一样名字（参数名不同也算）的非虚函数

更会让基类中的函数被隐藏 编译后会提示要求使用后new 关键之  使用base

调用

  myClass3.MyClass2Mothod();
            MyClass4 myClass4 = new MyClass4();
            myClass4.Test2();
           

            MyClass5 myClass5 = new MyClass5();

方法

 public class MyClass4: MyClass3
    {
        /*
         *      11.覆盖,在子类中写一个和基类一样名字(参数名不同也算)的非虚函数,
         *      会让基类中的函数被隐藏,编译后会提示要求使用New关键字  使用base 可以调用父类覆盖的方法
         */
        public void Test2()
        {
            //base关键字  代表父类的对象
          //  base.Test2();
            //代表当前类的对象
           // this.Test2();
            Console.WriteLine("Test4");

        }
    
    }
    public class MyClass5 : MyClass3
    {
     
    }

三.多态

含义：

即一个接口多个功能 同-一种操作 作用于不同的对象可以有不同的解释 残生不同地方执行结果体现多态的功能：重写    重载   抽象类   接口

重写  必然发生在基类和派生类中  其类函数用virtual 修饰  派生类用override修饰 

重写的目的  ： 父类的方法功能 不能满足于子类需求是

调用

  MyClass2     myClass2 = new MyClass2();
            myClass2.MyClass1Mothod1();

            MyClass3 myClass3 = new MyClass3();
            myClass3.MyClass1Mothod1();

方法

 public class MyClass1 {

        public void MyClass1Mothod() {

            Console.WriteLine("MyClass1Mothod");
        }

        //父类允许子类覆盖叫重写  virtual允许子类覆盖   这种方法叫虚方法
        public virtual void MyClass1Mothod1() 
        {
            Console.WriteLine("MyClass1Mothod1");
        }


    }
    public class MyClass2: MyClass1
    {

        public void MyClass1Mothod()
        {

            Console.WriteLine("MyClass1Mothod覆盖");
        }

        //子类重写父类的方法 使用override 
        public override void MyClass1Mothod1()
        {  

            base.MyClass1Mothod1 ();
            Console.WriteLine("MyClass1Mothod1重写");
        }
    }

    public class MyClass3 :MyClass1{ 
    
    
    
    }

四.重载

重载 函数名相同  参数类型 或者 顺序不同 和 个数有关  与返回值无关

重载  函数名相同  参数类型或者顺序不同构成重载 与返回类型无关

重写 必然发生在基类和派生类中  其类函数用virtual 修饰 派生类用override修饰

覆盖  在子类中写一个和基类一样名字（参数不同也算）的非虚函数 会让基类中的函数被隐藏 编译后会提示要求使用new关键字

调用 

   MyClass1 myClass1 = new MyClass1();
            myClass1.MyClass1Mothod();
            MyClass2 myClass2 = new MyClass2();
            myClass2.MyClass1Mothod();

方法

 public class MyClass1 {

        public void MyClass1Mothod() {

            Console.WriteLine("MyClass1Mothod");

        }
        public void MyClass1Mothod(int a)
        {

            Console.WriteLine("MyClass1Mothod int a");

        }
        public void MyClass1Mothod(int a,int b)
        {

            Console.WriteLine("MyClass1Mothod int a int b");

        }
        public void MyClass1Mothod(int b, string a)
        {

            Console.WriteLine("MyClass1Mothod string a int b");

        }
        public void MyClass1Mothod(int b, int a,int c)
        {

            Console.WriteLine("MyClass1Mothod int a int b int c");

        }
        public void MyClass1Mothod(int b, int a, int c,string d)
        {

            Console.WriteLine("MyClass1Mothod int a int b int c string d");

        }
        public void MyClass1Mothod(int b, int a,string d, int c)
        {

            Console.WriteLine("MyClass1Mothod int a int b string d, int c");

        }


        public static void MyClass1Mothod(string a)
        {



        }
        public int MyClass1Mothod(string a, int b)
        {

            return 1;
        }
    }


   public class MyClass2 :MyClass1{

        public void MyClass1Mothod(string a, int b, bool c)
        {


        }

    }

五 抽象类

1.关键字  abstract

2.不能被实例化    不能创建对象

3.抽象类可以包括抽象方法，或者普通方法

调用

 MyClass1  myClass1 = new MyClass1();
            myClass1.Age = 10;
            myClass1.Eat();
            myClass1.Drink();
            myClass1.Bge = 30;
            Console.WriteLine(myClass1.Bge);

方法

   public abstract class MyClass {

        //普通方法
        public void Eat() {
            Console.WriteLine("吃饱了");
        }
        //普通的属性
        public int Age { get; set; }

        //抽象方法
        public abstract void Drink();
        //抽象属性
        public abstract int Bge { get; set; }


     
    }

4.抽象方法和属性只能被定义 ，在子类中实现

 public abstract class MyClass {

        //普通方法
        public void Eat() {
            Console.WriteLine("吃饱了");
        }
        //普通的属性
        public int Age { get; set; }

        //抽象方法
        public abstract void Drink();
        //抽象属性
        public abstract int Bge { get; set; }


     
    }

5.继承抽象类的非抽象类,必须包含全部已继承的抽象方法和访问器的实现

 public abstract class People { 
        
        public abstract string Name { get; set; }

        public abstract void Eat();
    
    
    }

    public abstract class Man : People
    {

       
        public abstract void Smoke();


    }

6.通过包含使用  override 修饰符的属性声明，可在派生类中重写抽象类 方法和属性

 public class Boy : Man{


        public override string Name { get; set; }

        public override void Eat() {
            Console.WriteLine("123");

        }
        public override void Smoke() {

            Console.WriteLine("456");

        }
    }