20141214--C#父类，子类

首要：

子类 包含父类的所有的属性方法
所有子类都可以直接转化成父类类型
当父类类型变量里面存的是某个子类的对象的时候，才能转化成那个子类类型。

父类与子类的装换：

Ren r = new Ren();
r = (Ren)m;//Man子类转换为Ren父类
Ren m1 = new Ren();
m1 = (Man)r;//转换成父类后再转换为子类时，只能转换成原先的子类， 不能转换成其他子类

需要使用强制装换。

private与protected:

private 只可在当前类中作为成员变量使用 。

protected 只可在当前类中或子类中作为成员变量 使用。

当初始化子类的时候，都会先初始化一下父类，并且，执行父类中的构造函数。

在父类中写入：

       private int hello;//private  只能在自己类里作为成员变量使用
        protected int world;//protected 只能在自己的类 以及子类里 作为成员变量使用
        public Ren()//构造函数（先执行）
        {
            world += 10;
            hello = 0;
       }
       public void ren1()
       {
            Console.WriteLine(world);
       }

在一个子类中：

class Man : Ren//加上“:Ren” 子类，表示Man是Ren的子类。
    {
         public Man()
        {
            world += 5; //在子类中可以使用protected的 变量。不可使用 private的变量。
        }
        public void man1()
        {
            Console.WriteLine(world);
        }
    }

在另一个子类中：

class women : Ren//加上“:Ren” 子类，表示women是Ren的子类。
    {
        public women()
        {
            world += 7;
        }
        public void women1()
        {
            Console.WriteLine(world);
        }
    }

主函数

static void Main(string[] args)
        {//子类 包含父类的所有的属性方法
            //所有子类都可以直接转化成父类类型
            //当父类类型变量里面存的是某个子类的对象的时候，才能转化成那个子类类型。
              Ren rr = new Ren();
            rr.ren1();//打印结果是10

            Man m=new Man();
            m.man1();//打印结果是15

            women w = new women();
            w.women1();//打印结果是17

            Console.ReadLine();
        }

当在父类中加入 static时

      private int hello;//private  只能在自己类里作为成员变量使用
       protected static int world;//protected 只能在自己的类 以及子类里 作为成员变量使用
       //注意此处，与上文不同，添加了一个static 静态变量（受保护）
       public Ren()//构造函数（先执行）
       {
            world += 10;
            hello = 0;
      }
      public void ren1()
      {
            Console.WriteLine(world);
      }

输出结果：

            Ren rr = new Ren();
            rr.ren1();//打印结果是10

            Man m=new Man();
            m.man1();//打印结果是25

            women w = new women();
            w.women1();//打印结果是42

其原理：

每次初始化（new）的时候被保护的变量都不会改变。

10+15=25；（第一个10是初始化Ren时的改变）

25+17=42；（25是初始化Man时的改变）

父类与子类的方法调用：

当子类父类中各有一个同名的方法时，new的是谁就调用谁的方法。

父类：

public void shuohua()
        {
            Console.WriteLine("说话：");
        }

Man子类：

public void shuohua()
        {
            Console.WriteLine("会英语");
        }

注意两个是同名的方法。

主函数中：

           m.shuohua();//调用的是Man中的方法    打印结果： 会英语
            rr.shuohua();//调用的是Ren中的方法   打印结果： 说话：

            rr = (Ren)m;//把Man类的m强制转换成Ren类。
            rr.shuohua();//调用的是Ren中的方法   打印结果： 说话：

            m = (Man)rr;//把Ren类rr强制转换成Man类。
            m.shuohua();//调用的是Man中的方法   打印结果： 会英语