.NET技术汇总(C#)面向对象(OOP)(转载)

什么是面向对象(OOP),面向对象有什么作用,有什么好处,面向对象是如何实现的.

语言分两种:一种是面向对象一种是面向过程,C#,VB,JAVA等是属于面向语言.C,C++等属于面向过程的语言

面向对象:面向对象语言的产生不是为了取代面向过程,想对于来说面向对象的语言弥补了面向过程中的一些不足.面向对象,对象就是人们要进行研究的任何事物,世上的任何东西对于我们来说都可以叫做对象,面向对象思想比较抽象,所以怎么来理解看个人的想法是什么了

做为开发过程中,怎么来体会面向对象呢,如果之前做过C语言开发的话,就会知道C的编程方式是笼统的从上到下一直到这个功能的实现都是一行一行的向下写,属于一种过程,C#开发的话可以将一个块的功能进行封装,也可以实现类与类之间的相互继承,为了方便程序可扩展性可以使用接口的方式,

这就是面向对象思想核心部分:封装,继承,多态  (接口是属于多态的一种实现,多态是一种抽象的概念,凡是抽象的东西就是不复存在的东西,对吧! 多态就是一种实现方式,什么样的实现方式呢?通过接口,抽象类,虚方法来实现,这就是多态)多态具有一种开发封闭的原则,就是对修改封闭,对扩展开放

================================OK...下面我就来说说面向对象的三大支柱,为了方便理解,另附加代码=======================================

支柱一:   封装:封装就是将事物的状态和行为放在一个类里(类就是一个模子,好比来说狗,猫,猪,马这些都是对象,他们都属于是动物中的一个对象,所以动物就是一个类,一个类具有一些特征(属性)和行为(方法),类是一种数据类型,可以自定义类,所有的类都继承自Object类,object是所有类的父类),Ok.上代码..............

 1  //属性存值写入,读值
 2             public string Name
 3             {
 4                 get { return _name; }//只读
 5                 set { _name = value; }//只写
 6             }
 7             //方法-----用于实现结果
 8             public void GetAnimal(string name)
 9             {
10                 Console.WriteLine("这个动物的名字叫:" + name);
11             }

支柱二:   继承:继承就是子类实现父类的属性和方法,使子类更简单,实现了代码的重用(多态),代码重用又归为两类,一是经典继承("Is-a" 关系)和 包含/委托模型("has-a")一般我们用的都是经典继承的模式,那么什么是经典继承呢??经典继承的思想就是新的类可以利用既有类的功能,允许我们构建新的类的定义,扩展既有类的功能

代码:

 1  public class Animal     
 2         {
 3             private string _name;
 4 
 5             public string Name
 6             {
 7                 get { return _name; }
 8                 set { _name = value; }
 9             }
10 
11             private string _Type;
12 
13             public string Type
14             {
15                 get { return _Type; }
16                 set { _Type = value; }
17             }
18         }
19 
20         class Dog : Animal    //Dog为派生类(子类) Animal基类(父类)
21         {
22             public void name()
23             {
24                 Console.WriteLine("小狗的名字叫:" + this.Name);
25             }
26             public void type()
27             {
28                 Console.WriteLine("小狗的品种是:" + this.Type);
29             }
30 
31         }

其中Animal为基类也叫父类,Gog是派生类也叫子类,子类继承了父类,可以直接使用父类中的属性,另外继承具有单根性,传递性.子类只能继承一个父类,不能继承多个父类,

关于类的访问修饰符:

sealed关键字:如果类的访问修饰符为sealed(密封的),则这个类不能被继承,

private关键字:类中成员的默认访问修饰符

internal关键字:类的默认访问修饰符

pubic关键字:说明这个类是公开的公共的.

protected关键字:说明只能在该类或子类的访问

(静态类不能被继承,也不能实例化.只能通过类型点出来类中的成员)

下面说一下另一个继承模式(has-a)包含/委托模式..从字面上我们也可以看出来这个模式是如何实现的了,在一个类中包含另一个类的对象,实现另一个类的东西....说多就蒙圈了,上代码实在

 1  public class Animal
 2         {
 3             private string _name;
 4 
 5             public string Name
 6             {
 7                 get { return _name; }
 8                 set { _name = value; }
 9             }
10 
11             private string _Type;
12 
13             public string Type
14             {
15                 get { return _Type; }
16                 set { _Type = value; }
17             }
18 
19             //包含一个cut对象
20             protected Cut cut = new Cut();
21             //公开对象的行为
22             public string str()
23             {
24                 return cut.GetCutName();
25             }
26             //通过自定义属性公开属性
27             public Cut cutname
28             {
29                 get { return cutname; }
30                 set { cutname = value; }
31             }
32         }

this和base 关键字:  

this:作为当前类的对象可以调用当前类的成员,使用语法:this.成员(调用成员自己);

                                  调用本类的其他构造函数:this()(调用构造函数,自己);

base:调用父类中的成员在子类重写父类成员或者子类使用new关键字隐藏了父类成员时,base是点不出子类独有成员你的.

        调用父类中的构造函数

        在调用从父类中继承过来的成员的时候,如果子类没有重写则this.成员,与base成员,没有区别,如果子类重写了父类成员,则this.成员,调用的是子类重写以后的.base.成员;调用的依然是父类的成员.

C# as和is关键字:as和is 都是属于类型之间的一种转换.as判断返回的结果是null来检测兼容性,is判断返回的结果是true或false

支柱三:  多态,多态是整个面向对象的核心部分,在以后的开发中,多态往往用的是最多的也是最难理解的,希望下面的解释可以有助于读者,同时也是为了自己更好的深入的理解它....搜噶...

多态性的含义：使得能够利用基类的指针来引用不同子类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作。

多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。（多态）

多态的实现方式主要有三种:接口,抽象类,虚方法.在开发过程中接口是多态的首选,其次是抽象类,最后选择是虚方法.至于是为什么呢?? 主要是接口的扩展型比抽象类和虚方法要好.当软件封装之后就无法再改动内部的代码,包括类.这样使用接口的话,更好的实现了开放封闭的原则,方便扩展.下面来一一介绍

    抽象类: 抽象类定义的关键字是abstract,如果父类是抽象类的话,那么子类在继承父类之后,如果父类的成员也是抽象的,那么子类必须实现(重写)父类中的成员,除非子类也是抽象类,抽象类不能被实例化,只能被继承,抽象类的存在就是为了多态.

抽象类的声明是abstract,在子类中如果重写父类中的抽象成员要用override.在父类中抽象方法不能有实现.抽象方法必须在抽象类中.

代码上:

 1   public abstract class Animal
 2         {
 3             public abstract void name()
 4             {
 5  
 6             }
 7         }
 8        
 9         class Dog : Animal
10         {
11 
12             public override void name()
13             {
14                 Console.WriteLine("这是在重写父类(抽象类)中的抽象成员");
15             }
16         }

虚方法:虚方法在父类中必须有实现,虚方法可以定义在普通类中也可以定义在抽象类中,在子类中可以重写父类中的虚方法也可以不重写.根据实际的需求.(多个子类继承同一个父类时,为了实现不同的需求,可以重写父类中的方法.不过最好还是使用抽象方法的方式在子类中实现,这样便于使用).

上代码:

 1   //父类可以是普通类也可以是抽象类,在父类中虚方法必须有实现
 2         public  class Animal
 3         {
 4             public virtual void name()
 5             {
 6                 Console.WriteLine("这是一个虚方法");
 7             }
 8         }
 9        
10         class Dog : Animal
11         {
12 
13             public override void name()
14             {
15                 Console.WriteLine("重写父类中的虚方法");
16             }
17         }

接口:接口的存在就是为了多态.

接口是为了多态而存在的.接口就是一种协议.接口的定义为Interface,接口里可以有属性,方法,索引器,但是接口中不能有字段,因为接口是一种协议,所以在接口不能有实现,在子类继承接口是,必须要重写接口中的成员.

判断一个指定类型是否支持一个接口可以使用as 和is 来判断.如果判断非空或者为true说明调用的是一个正确的接口引用.

接口可以多继承.