C#继承和多态

继承与多态


base关键字
1.用于从派生类中访问基类成员
2.指定创建派生类实例时应调用的基类构造函数


new  覆写


virtual 定义虚方法，在子类中可以去改变这个方法


override 重写，将父类中的方法重写为子类中的方法，不能修改访问修饰符


多态：一个方法在不同子类中所实现不同，这个特征叫多态


抽象类：对一系列类的抽象


1.抽象类不能直接实例化
2.抽象方法不能有方法体
3.抽象方法只能写在抽象类里
4.非抽象类继承抽象类时，抽象类中的所有抽象方法必须实现
5.属性也可以定义为抽象的，属性本身也是方法




接口:是对功能约束的一种类型
类是接口的实现者
1.类的继承只能是单继承，接口的继承可以是多继承
2.不允许有字段定义与具体方法的实现
3.定义方法时，访问修饰符默认就是public，也值能是public，所以public不需要写


sealed 密封的，不允许被继承
sealed class密封类，不允许再被继承的类
sealed override 来修饰方法，说明这个方法不允许在这个类的子类中被重写


一般的方法都是在编译是决定：早绑定

多态的方法在运行时绑定：晚绑定

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


namespace ConsoleApplication1
{
    
 
    /// <summary>
    /// 动物
    /// </summary>
    class Animal
    {
        private double height = 0;


        protected double Height
        {
            get { return height; }
            set { height = value; }
        }
        protected double weigth = 0;


        protected double Weigth
        {
            get { return weigth; }
            set { weigth = value; }
        }


        //***************构造函数***************************
        public Animal()
        { 
        Console.WriteLine("父类");
        }


        public Animal(double height, double weight)
        {
            
            this.height = height; ;
            this.weigth = weight;
        }


        //操作
        public void Sleep()
        {
            Console.WriteLine("animal sleep...");
        }
        //吃
        public void Eat()
        {
            Console.WriteLine("animal eat...");
        }
    }
    //在动物的基础上多了新的特点
    //猪
    class Pig:Animal
    {
        int legs = 4;


        public int Legs
        {
            get { return legs; }
            set { legs = value; }
        }
 
        //操作
        public void Run()
        {
            Console.WriteLine("pig running...80km/h");
        }


        public void Show()
        {
            //this.Run();//当前
            //base.Sleep();//base是个类的父类
            Console.WriteLine("身高{0}\t体重{1}\t腿{2}",Height,Weigth,Legs);
        }




        //****************构造函数**********************




        public Pig()
        { 
        Console.WriteLine("子类");
        }
        
        //写子类的构造函数时可以调用父类的构造函数
        //:base(实参)
        public Pig(double height,double weight,int legs):base(height,weight)
        {
            //this.Height = height;
            //this.weigth = weight;
            
            this.legs = legs;
        }
    }


    //鸟
    class Bird:Animal
    {
        public int wings=2;
        public void Fly()
        {


            Console.WriteLine("bird fly...");
        }


        public Bird()
        {
            Console.WriteLine("奥特曼不坑爹");
        }


        public Bird(double height, double weight, int wings) : base(height, weight)
        {
            this.wings = wings;
        }
    }


    class Human
    {
        string name;


        public string Name
        {
            get { return name; }
            set { name = value; }
        }


        public Human()
        { 
        
        }


        public Human(string name)
        {
            this.name = name;
        }


        public void Speak()
        {
            Console.WriteLine("my name is {0}",name);
        }




        //virtual 定义虚方法，在子类中可以去改变这个方法
        public virtual void Walk()
        {
            Console.WriteLine("坑爹啊");
        }
    }


    class Student : Human
    {
        string stuNum;
        public Student()
        {
        
        }


        public Student(string stuNum,string name):base(name)
        {
            this.stuNum = stuNum;
        }


        //在子类中写了一个新的Speak()方法（new可省），遗弃了基类中的Speak方法
        //new 覆写
        public new void Speak()
        {
            Console.WriteLine("姓名{0}\t学号{1}",Name,stuNum);
        }




        // override 重写，将父类中的方法重写为子类中的方法
        //多态：一个方法在不同子类中所实现不同，这个特征叫多态
        public override void Walk()
        {
            Console.WriteLine("pig run！");
        }
    }


    class Teacher : Human
    {
        public override void Walk()
        {
            //base.Walk();


            Console.WriteLine("teacher walk");
        }
    }
    class Program
    { 
        /// <summary>
        /// 继承的好处：继承为类与类之间指定关系，更大的提高了代码的重用率
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            //Pig p = new Pig(10, 120, 7);
            //p.Eat();//父类的
            //p.Run();//子类的
            //p.Show();
            //Pig pp = new Pig();


            //Bird b = new Bird();
            //b.Sleep();


            //Student stu = new Student("2012.12.21", "我不是奥特曼");
            //stu.Speak();


            //Human h = stu;
            //h.Speak();
            //h.Walk();


            //Teacher th = new Teacher();
            //h = th;
            //h.Walk();
            //****************************
            Human h2 = new Student();
            h2.Walk();
            h2 = new Teacher();
            h2.Walk();


            //多态的实现：虚方法，抽象类，接口
        }
    }
}