C#面向对象1 类 以及 类的继承（new、ovverride）

类 的典型代码==============================
包括 属性及其判断赋值  方法  构造函数及其重载
namespace 类的属性和方法
{
    public class Car
    {       
        private int _speed;    
        private string _name;       

        public int Speed             //属性的封装，判断
        {        
            set {
                if (value == 20)
                {
                    this._speed = value;
                }
                else
                {
                    this._speed = 50;
                }
            }        
            get{return this._speed;}     
        }    

        public string Name    
        {        
            set { this._name=value;}        
            get{return this._name;}     
        }    

        //显式定义默认构造函数    
        public Car(){}    

        //重载的带有参数的构造函数
        public Car(string name,int speed)    
        {        
            this._name=name;        
            this._speed=speed;    
        }    

        public void ShowState()     
        {
            Console.WriteLine("Car {0} is going {1} MPH", this._name,this. _speed);
        }
    }

 

    class Program
    {
        static void Main(string[] args)
        {
            Car car1= new Car("胡章诚",19);
            car1.Speed = 19;
            Console.WriteLine("车名是{0},时速{1}", car1.Name, car1.Speed);
            car1.ShowState();
            Console.ReadKey();
        }
    }
}

 

 
一般类的继承=============================
1、类的继承——子类构造函数

概述：子类默认情况下会调用父类的的无参数构造函数
      如果父类写了有参数的构造函数，子类未调用父类的有参数的构造函数，则需要显示的写出父类的无参数构造函

namespace 类的继承_子类构造函数
{
    class Program
    {
        //3、 定义父亲类Father(姓firstName,财产wealth,血型blood),儿子Son类(玩游戏PlayGame),女儿Daughter类(跳舞Dance)，
        //    调用父类构造函数给子类字段赋值。
        static void Main(string[] args)
        {
            Son son = new Son("Green", 20000, "O", "Good");                 //实例化一个儿子的对象
            Console.WriteLine(son.firstName);
            son.PlayGame("lol");               //调用儿子的方法
            Console.ReadKey();
        }
    }

    class Father
    {
        public string firstName;
        public int wealth;
        public string blood;

        public Father() { }     //如果子类写了一个造函数，此造函数没有调用父类带参数的构造函数，此时就要显示的写出父类的无参数构造函数
        public Father(string f, int w, string b)      //定于父类带参数的构造函数
        {
            this.firstName = f;
            this.wealth = w;
            this.blood = b;
        }
    }

    class Son : Father
    {
        public string health;         //自己写的一个字段
        public void PlayGame(string Game)           //将儿子玩游戏写成一个方法
        {
            Console.WriteLine("我玩{0}，哈哈哈哈哈;", Game);
        }

        public Son(string f, int w, string b, string h)
            : base(f, w, b)                //利用base调用父类的构造函数
        {
            this.firstName = f;
            this.wealth = w;
            this.blood = b;
            this.health = h;
        }
    }

    class Daughter : Father
    {
        public int age;              //自己写的一个字段
        public void Dance()          //将女儿跳舞写成一个方法
        {
            Console.WriteLine("我跳拉丁，呵呵");
        }

        public Daughter(string f, int w, string b, int a)
            : base(f, w, b)             //利用base调用父类的构造函数
        {
            this.firstName = f;
            this.wealth = w;
            this.blood = b;
            this.age = a;
        }
    }
}

。。。。。。。。。。。。。。。。。。。。。。。。。

2、类的继承——用new关键字覆盖产生新方法

namespace 类的继承
{
    class Program
    {
        static void Main(string[] args)
        {
            OtherClass oc = new OtherClass();
            oc.Method1(oc.Field1);
            
            Console.ReadKey();
        }

 

        class SomeClass
        {
            public string Field1 = "base class field1";
            public void Method1(string value) 
            {
                Console.WriteLine("Base class -- Method1:{0}",value);
            }
        }

        class OtherClass:SomeClass
        {
            new public string Field1 = "OtherClass Field1";     //掩盖旧成员
            new public void Method1(string value)               //掩盖旧成员
            {
                Console.WriteLine("OtherClass.Method:{0}",value);
                Console.WriteLine(base.Field1);                 //访问基类成员
            }
        }
    }
}

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

3、类的继承——虚方法、抽象方法的重写产生新方法

namespace 虚方法和复写方法
{
    class Program
    {
        static void Main(string[] args)
        {
            MyDrivedClass drived = new MyDrivedClass();
            MyBaseClass mybs = (MyBaseClass)drived;
            drived.Print();
            mybs.Print();
            Console.ReadKey();
        }
    }

    class MyBaseClass
    {
        virtual public void Print()
        {
            Console.WriteLine("this is base class");
        }
    }

    class MyDrivedClass:MyBaseClass
    {
        override public void Print()
        {
            Console.WriteLine("this is drived class");
        }
    }
}