c#重点[封装，继承，多肽]

面向对象的语言三大特点：封装、继承、多态

Ⅰ.封装：是把类的内部隐藏起来，以防止外部世界看见的一个面向对象的概念，通过关键字去控制变量，方法的访问权限。

1).访问修饰符：

Ⅱ.继承：

eg：我们建一个Person作为父类，Chinese作为子类

 1 class Person
 2     {
 3         public string name="zhangsan";
 4         public int age=21;
 5         //类里面有一个默认的构造方法，我们在下面写了一个构造方法，如果想去调用这个无参数的构造方法,那就要加一个无参构造方法
 6         public Person()
 7         {
 8             Console.WriteLine("我是一个人类");
 9         }
10         public void SayHi()
11         {
12             Console.WriteLine("hello,我是人类！");
13         }
14     }

Person

1  class Chinese:Person
2     {
3 
4     }

Chinese

我们在程序入口里面调用父类里面的成员：

class Program
    {
        static void Main(string[] args)
        {
            Chinese c = new Chinese();
            Console.WriteLine(c.name);
            Console.WriteLine(c.age);
            c.SayHi();
        }
    }

Program

得到结果为：

1.为什么子类里面没有成员，还能调用？

如果，我把person里面的 [public string name="zhangsan";]变为私有成员[private string name;]，调用结果显示？

以上的得出结论：

继承：

1.单继承，一个类只能继承一个类[一个儿子只有一个爹]
2.Chinese:Person Chinese 子类/派生类 Person 父类/基类/超类
3.Chinese:Person 那么Chinese继承了Person里面所有的成员(字段、方法)，对于父类的私有成员，子类还是能继承到，只是没有访问权限

2）.所有的类型的基类是System.Object类

3) . 构造函数不能被继承

4）.子类Chinese里面添加一个方法

1     class Chinese:Person
2     {
3         public Chinese()
4         {
5             Console.WriteLine("我是中国人！");
6         }
7     }

Chinese

我们调用program看一下结果：

 class Program
    {
        static void Main(string[] args)
        {
            Chinese c = new Chinese();
            c.SayHi();
        }
    }

Program

结果显示：

4.当实例化子类对象时，首先调用父类的构造方法，然后调用子类的构造方法。

5）.人类属于动物类animal,我们创建一个animal类让rerson类继承。chinese继承person，person继承animal

class Animal
    {
        public Animal()
        {
            Console.WriteLine("我是动物类！");
        }
    }

Animal

 class Person:Animal
    {
        public Person()
        {
            Console.WriteLine("我是人类");
        }
        public  void SayHi()
        {
            Console.WriteLine("hello,我是人类！");
        }

Person:Anima

    class Chinese:Person
    {
        public Chinese()
        {
            Console.WriteLine("我是中国人！");
        }
    }

Chinese:Person

结果显示：

5.如果A：B,B:C，那么A：C;

6）.父类Person里面有一个SayHi()方法，如果在子类里面添加一个sayHi方法

class Chinese:Person
    {
        public Chinese()
        {
            Console.WriteLine("我是中国人！");
        }
        public void SayHi()
        {
            Console.WriteLine("你好，我是中国人");
        }
    }

Chinese里添加一个SayHi方法

结果显示：

我们来谈一下过程：

ⅰ.继承过来之后被隐藏，有意隐藏加一个关键字"new",如果加了关键字"new",就告诉子类，父类里面的sayHi只能被隐藏，不能被覆写

ⅱ.继承过来之后被覆写/重写，覆写需要在父类里面加"virtual",加了"virtual"之后就告诉子类继承之后，子类只能覆写"override"

结果还是一样，结论显示：

6.一个子类和父类有相同的方法时，当运用子类的对象去调用该方法时，调用子类的方法，默认情况下，从父类的方法被隐藏掉，(有意隐藏，需要在子类的方法上加上New(可以加也可以不加))

如果想覆写/重写父类的方法，需要在父类里面设置该方法为虚方法(virtual),然后子类通过override关键字去覆写。

7）.里氏替换原则:一个父类的变量可以接收子类的对象，反之不行。

class Person:Animal
    {
        public Person()
        {
            Console.WriteLine("我是人类");
        }
        public  void SayHi()
        {
            Console.WriteLine("hello,我是人类！");
        }
    }

Person

class Chinese:Person
    {
        public Chinese()
        {
            Console.WriteLine("我是中国人！");
        }
        public  void SayHi()
        {
            Console.WriteLine("你好，我是中国人");
        }
    }

Chinese:Person

 class Program
    {
        static void Main(string[] args)
        {
            //父类的变量可以接收到子类的任何类型
            //如果没有覆写的话，就近原则，p离person近，就调用person的sayHi方法
            Person p = new Chinese();
            p.SayHi();
            Console.ReadKey();
        }
    }

Program

结果：

覆写之后：

class Person:Animal
    {
        public Person()
        {
            Console.WriteLine("我是人类");
        }
        public virtual void SayHi()
        {
            Console.WriteLine("hello,我是人类！");
        }
    }

Person

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

Chinese

结果：