20151028c#4

继承(inheritance)

增加代码的复用性，可维护性,很多信息都是公共的。继承是一个程序内部类的相互交叉。 接口是程序对外提供的交互服务。

例如：100个类  50个类有公共的东西 把公共的东西提取出来放到父类里

插座-先做模型-提交给实施方

抽象类 接口 定义了方法的名称 返回类型 没有具体实施

直接 让其它的类去继承实现

架构师做整体规则 写接口

主要特点：

1、A:B A叫子类（派生类Derived class），B叫父类（超类、基类Base class），B里面的所有成员(字段、方法)都会被A继承

B里面的私有成员，A也是继承下来了的，只是没有访问权限。

2、A:B,B:C===》A:C

    class  Animal
    {
        public int z = 10;
        public Animal()
        {
            Console.WriteLine("我出生了，我是动物");
        }
    }

    class Person:Animal
    {
        public int age;
        public string name;
        public void SayHi()
        {
            Console.WriteLine("大家好，我是人类");
        }  
    }      

    class Chinese:Person
    {
    }

            Chinese c1 = new Chinese();
            c1.age = 10;
            c1.name = "lxx";
            c1.SayHi();
            c1.z = 30;

3、任何类型的基类是Object

4、当一个类是密封类(sealed),它是不能被继承的

　　sealed class Animal

5、A:B,B里面有SayHi方法，用A的对象调用SayHi的时候，首先调用的是B里面的构造方法，然后是A的构造方法，最后才是SayHi方法，如果B上面

还有继承的类，则先调用该类的构造方法。

   class Person
   {    //1   
         public Person()
        {
            Console.WriteLine("我出生了，我是人类");
        }    
    }    

    class Chinese:Person
    {   //2
　　     public Chinese()
        {
            Console.WriteLine("我是中国人，我出生了");
        } 
　　　　　//3
　　　　　public void SayHi()
        {
            Console.WriteLine("大家好，我是中国人");
        }
      }

      Chinese c1 = new Chinese();
      c1.SayHi();

6、A：B，A和B里都有一个方法SayHi，默认情况下，运用A的对象调用SayHi的时候，调用的是子类的SayHi方法，父类的被隐藏了，规范化要在子类加new关键字。

    class Person
    {
　　　　　//隐藏
         public void SayHi()
        {
            Console.WriteLine("大家好，我是人类");
        }
     }

    class Chinese:Person
    {    
　　　　//1
      public new void SayHi()
        {
            Console.WriteLine("大家好，我是中国人");
        }
     }

      Chinese c1 = new Chinese();
      c1.SayHi();

7、A:B,A和B都有一个方法SayHi,当B里面的SayHi方法是一个虚方法(virtual)的时候，A里面的SayHi才能被重写，通过关键字override覆写

    class Person
    {
　　　　　 //隐藏         
　　　　　　public virtual void SayHi()
        {
            Console.WriteLine("大家好，我是人类");
        }
     }

    class Chinese:Person
    {    
　　　　  //1       
　　　　　public override void SayHi()
        {
            Console.WriteLine("大家好，我是中国人");
        }
     }

      Chinese c1 = new Chinese();
      c1.SayHi();

8、里氏替换原则：子类对象可以赋值给父类变量，反之不成立。

A:B,A和B里面都有一个方法SayHi,当B b=new A(),b.SayHi()默认情况下，（没被覆写）就近原则调用的是父类的方法

如果SayHi被覆写，调用的是子类的方法。

多态

同一种方法名不同的表现形式，例如 叫声

重载 方法名相同，方法里的参数的个数、顺序不同。只跟参数有关

        /// <summary>
        /// 第一种重载方式
        /// </summary>
        public void A()
        {

        }
        /// <summary>
        /// 第二种重载方式
        /// </summary>
        /// <param name="a">名字</param>
        /// <param name="i">年龄</param>
        public void A(string a, int i)
        {

        }
　　　　　public string A(int a)//string A()和void A（）是同一种重载
        {
            return "aa";
        }

覆写:虚方法 virtual override

父类

        public virtual void SayHi()//加入virtual改为虚方法,子类就可重写
        {
            Console.WriteLine("大家好，我是人类");
        }

子类

        public override void SayHi()//重写父类的方法
        {
            Console.WriteLine("大家好，我是中国人");
        }

构造方法是不能重写的.静态方法不能被覆写，但可以被隐藏

静态类里面只能有静态成员

静态成员不能带override virtual abstract

字段

public int age;字段

没办法灵活的控制它的读和写

属性

可以灵活的控制它的读和写 比如判断获取的ID

        string s = "";
        private int age;

        public int Age
        {
            get {
                try
                {
                    age = s == null ? 0 : Convert.ToInt32(s);
                }
                catch
                {
                    age = 0;
                }
                return age;
            }
            set { age = value; }
        }
        

抽象类abstract

定义方法名 返回类型 不具体实现

一个类里只要有一个方法是抽象的，那这个类就是抽象类，即可有抽象的方法，也可以有非抽象的方法，

子类继承后，重载实现所有的方法，如果不实现编译报错。

    abstract class Class1
    {
        public abstract void A();
        public abstract void B();
        public void C()
        {
            Console.WriteLine("aa");
        }
    }

    class Class2:Class1
    {
        public override void A()
        {
           
        }

        public override void B()
        {

        }
    }

接口

1、接口是用来实现多继承，一个类只能有一个父类，但可以继承于多个接口

2、更加严格意义上的抽象类，里面的方法只能为抽象方法

3、定义接口：interface+类名

4、接口里面的所有成员都是公共的

5、一个类继承一个接口，就必须完成该接口中所有方法的实现

6、接口中不能包含字段、构造函数、静态变量

    interface Interface1
    {
        //默认public static
        void A();
        void B();
    }

    class Class3:Interface1
    {
        public void A()
        {

        }
        public void B()
        {

        }
    }

new 关键字的使用情况

1、实例化一个对象new Person();

2、隐藏一个父类的方法 new void SayHi();