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)父类引用指向子类对象,当父类想使用子类中特有属性、方法时,要向下转型。

展开阅读全文

没有更多推荐了,返回首页