c# 中面向对象的三个特点：封装，继承，多态， 以及c#中隐藏(new)和方法重写(override)和重载(overload)的区别

封装

1）封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问，通常有两种访问方式：set 设置，get 获取。

2）封装结果：存在但是不可见。

3） 访问修饰符

声明的可访问性                                 含义

public                                    访问不受限制。

protected                              访问仅限于本类或者其子类（可以跨程序集）。

private                                  访问仅限于本类。

internal                                 访问仅限于当前程序集。

protected  internal                 本类或者同一个程序集或者子类（可以跨程序集）里面访问

注意：对字段和方法而言  默认是私有的  但是对类而言 默认是internal

4）封装：是把类的内部隐藏起来，以防止外部世界看见的一个面向对象的概念

5） 重构（这里大家多多补充）

class Class1

    {

        private int i = 1;

        public int I

        {

            get { return i; }  //只允许外部类读取属性

            set { i = value; } //只允许外部类写入属性

        }

    }

继承

父子概念的继承：圆继承于图形，圆是子概念（子类型 Sub class）图形是父类型（Super Class也叫超类），继承在语法方面的好处：子类共享了父类的属性和方法的定义，子类复用了父类的属性和方法，节省了代码。

继承是is a ：“是”我中的一种，一种所属关系。

子类型对象可以赋值给父类型变量（多态的一种形式），变量是代词，父类型代词可以引用子类型东西。

（1） 被继承的类称为基类或父类，而继承得到的类称为子类或派生类。子类继承超类的状态和行为，同时也可以具有自己的特征。

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

（3） class A : B

（4） A:B  B:C 则 A:C

（5） 构造函数不能被继承

（6） 一个子类只能继承与一个父类

（7） 使用sealed关键字，其他类无法继承此类

（8） 子类不光继承父类的公有成员，同时继承了父类的私有成员，只是在子类中不被访问。

特点：

 c#中隐藏(new)和方法重写(override)和重载(overload)的区别

重载、重写和隐藏的定义:

重载：同一个作用域内发生（比如一个类里面），定义一系列同名方法，但是方法的参数列表不同。这样才能通过传递不同的参数来决定到底调用哪一个。而返回值类型不同是不能构成重载的。

重写：继承时发生，在子类中重新定义父类中的方法，子类中的方法和父类的方法是一样的 
        例如:基类方法声明为virtual(虚方法)，派生类中使用override申明此方法的重写.

隐藏：基类方法不做申明（默认为非虚方法），在派生类中使用new声明此方法的隐藏。

重载时，根据参数选择调用的方法；
重写时，访问父类子类皆调用子类的重写方法；
隐藏时，访问父类则调用父类的方法，子类子类的方法。

隐藏(new)示例：

 

using    System;  
   class    A  
   {  
         public    void    F()    
         {  
               Console.WriteLine("A.F");    
         }  
   }  
   class    B:    A  
   {  
         new    public    void    F()    
         {    
               Console.WriteLine("B.F");    
         }  
   }  
   class    Test  
   {  
         static void Main(string[] args)
         {  
               B    b    =    new    B();  
               b.F();  
               A    a    =    b;    
               a.F();  
         }  
   }  
   输出为  
   B.F  
   A.F  

 

重写virtual(虚方法)示例  
   using    System;  
   class    A  
   {  
         public    virtual    void    F()    
         {  
               Console.WriteLine("A.F");    
         }  
   }  
   class    B:    A  
   {  
         public    override    void    F()    
         {    
               Console.WriteLine("B.F");    
         }  
   }  
   class    Test  
   {  
         static    void    Main()    
         {  
               B    b    =    new    B();  
               b.F();  
               A    a    =    b;    
               a.F();  
         }  
   }  
   输出为  
   B.F  
   B.F

补充：重写override一般用于接口实现和继承类的方法改写，要注意

   1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
   2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
   3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
   4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

多态

1）继承体现了多态：父类型变量可以引用各种各样的子类型实例，也可接收子类对象。

2）个体的多态：父类型的子类型实例是多种多样的。

行为的多态：父类型定义方法被子类重写为多种多样的，重载也是多态的方法。

千万不能出现将父类对象转成子类类型，会造型异常！

3）多态前提：必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。

4）多态的好处：多态的出现大大的提高程序的扩展性。

多态的弊端：虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5）在多态中成员函数的特点：

①在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

②在运行时期：参阅对象所属的类中是否有调用的方法。

③简单总结就是：成员方法在多态调用时，编译看左边，运行看右边。

6）在多态中，成员变量的特点：无论编译和运行，都参考左边(引用型变量所属的类)。

7）在多态中，静态成员方法和属性的特点：无论编译和运行，都参考做左边。

8）父类引用指向子类对象，当父类想使用子类中特有属性、方法时，要向下转型。