C#面向对象基础

来源：cnblogs　　作者：陈彦斌　　时间：2018/12/29 10:01:21　　对本文有异议

类与实例

　　?对象：一切事物皆对象，对象就是一个自包含的实体，用一组可识别的特性和行为来标识

　　?类：具有相同的属性和功能的对象的抽象的集合

1、定义类

1 class Cat
2 {
3       public string Shout()
4     {
5          return "喵";   
6     }  
7 }

View Code

注：“这里的'class'是表示定义类的关键字，'Cat'就是类的名称，'Shout'就是类的方法。”

注意事项：第一，类名称首字母要大写。多个单词则各个首字母大写；第二，对外公开的方法需要使用'public'修饰符

　　 ?实例：就是一个真实的对象,比如我们都是'人',而你和我其实就是‘人’类的实例了，而实例化就是创建对象的过程，使用new关键字来创建

1 private void button1_click(object sender,EventArgs e)
2 {
3      Cat cat=new Cat(); //将Cat类实例化
4      MessageBox.Show(cat.Shout());   
5 }

View Code

注：“'Cat cat=new Cat()；'其实做了两件事。”

1 Cat cat; //声明一个Cat对象，对象名为cat
2 cat=new Cat(); //将此cat对象实例化

View Code

“Cat实例化后，等同于出生了一只小猫cat，此时就可以让小猫cat.Shout()了，在任何需要小猫叫的地方都可以实例化它。”

2、构造函数

　　?构造函数又叫‘构造方法’，其实就是对类进行初始化。构造方法与类名同名，无返回值，也不需要void，在new时候调用

2.1、有参构造函数

 1  class Cat
 2     {
 3         private string name = "";//声明Cat类的私有字符串变量name
 4         public Cat(string name) //定义Cat类的构造方法，参数是输入一个字符串
 5         {
 6             this.name = name; //将参数赋值给私有变量name
 7         }
 8         public string Shout()
 9         {
10             return "我的名字叫:" + name + " 喵";
11         }
12     }

View Code

2.2、有参构造函数调用

1  private void button1_Click(object sender, EventArgs e)
2         {
3             Cat cat = new Cat("咪咪");
4             MessageBox.Show(cat.Shout());
5         }

View Code

2.3、方法的重载

　　?方法重载提供了创建同名的对个方法的能力，单这些方法需要使用不同的参数类型

 1  class Cat
 2     {
 3         private string name = "";//声明Cat类的私有字符串变量name
 4         public Cat(string name) //定义Cat类的构造方法，参数是输入一个字符串
 5         {
 6             this.name = name; //将参数赋值给私有变量name
 7         }
 8         public Cat() //将构造方法重载
 9         {
10             this.name = "无名";
11         }
12         public string Shout()
13         {
14             return "我的名字叫:" + name + " 喵";
15         }
16     }

View Code

注：方法的重载，两个方法必须要方法名相同，但参数类型或个数必须要有所不同，否则就没有意义了。方法重载可在不改变原方法的基础上，新增功能，算是提供了函数可扩展的能力。

2.4、属性与修饰符

　　?属性：是一个方法或一对方法，但在调用他的代码来看，他是一个字段，即属性适合于字段的方法使用方法调用的场合。字段是存储类要满足其设计所需要的数据，字段是与类相关的变量

 1  private int shoutNum = 3; //声明一个内部字段，注意是private，默认叫的次数为3
 2         public int ShoutNum //ShoutNum属性，注意是public
 3         {       
 4             get
 5             {
 6                 return shoutNum; //当中有两个方法get表示外界调用时可以得到shoutNum的值
 7             }
 8 
 9             set
10             {
11                 shoutNum = value; //set表示外界可以给内部的shoutNum赋值
12             }
13         }

View Code

　　?public：表示它所修饰的类成员可以允许其他任何类来访问，俗称公有的

　　?private：表示只允许同一个类中的成员访问，其他类包括它的子类无法访问，俗称私有的

　　注：如果在类的成员没有加修饰符，则被认为是private的。

　　属性的两个方法：

　　　　get：访问器返回与声明的属性相同的数据类型，表示的意思是调用时可以得到内部字段的值或引用

　　　　set：访问器没有显示设置参数，但它有一个隐式参数，用关键字value表示，他的作用是调用属性时可以给内部的字段或引用赋值

3、面向对象

　　3.1、封装

　　?解释：每个对象都包含它能进行操作所需要的所有信息

　　?优点：

　　　　1、良好的封装能够减少耦合，至少我们让Cat和Form1的耦合分离。

　　　　2、类内部的实现可以自由地修改。

　　　　3、类具有清晰的对外接口

　　3.2、继承

　　　?解释：对象的继承代表了一种‘is-a’的关系，如果两个对象A和B，可以描述为‘B’是‘A’，则表明B可以继承A，继承者还可以理解为对被继承者的特殊化，因为他除了具备被继承者的特性外，还具备自己独有的个性。继承定义了类如何相互关联，共享特性。继承的工作方式是，定义父类和子类，或叫做基类和派生类，其中子类继承父类的所有特性。子类不但继承了父类的所有特性，还可以定的定义新的特性。

　　　?三句便于更好地理解继承概念

　　　　　　1、子类拥有父类非private的属性和功能

　　　　　　2、子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能

　　　　　　3、子类还可以以自己的方式实现父类的功能（方法的重写）

　　　我们来看一下猫和狗有那些共同特性，他们都属于动物，并且都有属于自己的名字，都会叫等等。

　　　父类：

 1 class Animal
 2     {
 3         protected string Name = ""; //注意访问修饰符为protected：表示继承时子类可以对基类有完全访问权
 4         public Animal(string name)
 5         {
 6             this.Name = name;
 7         }
 8         public Animal()
 9         {
10             this.Name = "无名";
11         }
12         protected int shoutNum = 3; //注意访问修饰符为protected
13 
14         protected int ShoutNum
15         {
16             get
17             {
18                 return shoutNum;
19             }
20 
21             set
22             {
23                 shoutNum = value;
24             }
25         }
26     }

View Code

　　　基类：

猫类：

 1     class Cat:Animal //继承格式---> 子类：父类
 2     {
 3         public Cat() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
 4         {
 5         }
 6         public Cat(string name) : base(name)
 7         {
 8         }
 9         public string Shout()
10         {
11             string result = "";
12             for (int i=0;i<shoutNum;i++)
13             {
14                 result += "喵，";
15             }
16             return "我的名字叫"+Name+" "+result;
17         }
18     }

View Code

狗类：

 1 class Dog:Animal //继承格式---> 子类：父类
 2     {
 3         public Dog() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
 4         {
 5         }
 6         public Dog(string name) : base(name)
 7         {
 8         }
 9         public string Shout()
10         {
11             string result = "";
12             for (int i=0;i<shoutNum;i++)
13             {
14                 result += "汪，";
15             }
16             return "我的名字叫"+Name+" "+result;
17         }
18     }

View Code

注：子类从它的父类中继承的成员有方法、域、属性、事件、索引指示器，但对于构造方法，有一种特殊，他不能被继承，只能被调用，对于调用父类的成员，可以使用base关键字。

　　如果还有动物类的话，按照以前的写法就需要再复制N遍，不用继承的话，如果要修改功能，就必须在所有重复的方法中修改，代码越多，出错的可能就越大，而继承的有点是，继承使得所有子类公共的部分都放在了父类，使得代码得到了共享，这样就避免了重复，另外，继承可使得修改或扩展继承而来的实现都较为容易。

　　继承是有缺点的，那就是父类变，则子类不得不变，另外继承会破坏包装，父类实现细节暴露给子类，这其实是增大了两个类之间的耦合性。

　　3.3、多态

　　?解释：表示不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行

　　下面通过过一个小故事，更好的理解多态的定义

　　　　我们的国粹‘京剧’以前都是子承父业，代代相传的艺术。假设有这样一对父子，父亲是非常有名的京剧艺术家，儿子长大成人了，模仿父亲的戏也惟妙惟肖。有一天，父亲突然发高烧，上不了台边沿，而票都早就卖出，退票显然会大大影响声誉。怎么办呢？由于京戏都是需要化妆才可以上台的，于是就决定让儿子代父亲上台表演。化妆后谁还认识谁呀，只要长得好久可以混弄过去了。这里面有几点注意：第一、子类以父类的身份出现，儿子代表老子表演，化妆后就是以父亲身份出现了。第二、子类在工作时以自己的方式来实现，儿子模仿得再好，那也是模仿，儿子只能用自己理解的表现方式去模仿父亲的作品。第三、子类以父类的身份出现时，子类特有的属性和方法不可以使用，儿子经过多年学习，其实已经有了自己的创作，自己的绝活，但在此时，代表父亲表演时，绝活是不能表现出来的，当然，如果父亲还有别的儿子会表演，也可以在此时代表父亲上场，道理也是一样。这就是多态。

　　?虚方法

　　解释：为了使子类的实例完全接替来自父类的类成员，父类必须将该成员声明为虚拟的。这是通过在该成员的返回类型之前添加virtual关键字来实现。然后，子类可以选择使用override关键字，将父类实现替换为它自己的实现，这就是方法重写override，或者叫做方法覆写。

父类：

1     class Animal
2     {
3          .......
4         public virtual string Shout() // 注意修饰符中增加了一个virtual，它表示此方法是虚方法，可以被子类重写
5         {
6             return "";
7         }
8     }

View Code

子类：

 1  class Dog:Animal //继承格式---> 子类：父类
 2     {
 3         public Dog() : base() //子类构造方法需要调用父类同样参数类型的构造函数，用base关键字代表父类
 4         {
 5         }
 6         public Dog(string name) : base(name)
 7         {
 8         }
 9         public override string Shout() //注意增加了override，表示方法重写
10         {
11             string result = "";
12             for (int i=0;i<shoutNum;i++)
13             {
14                 result += "汪，";
15             }
16             return "我的名字叫"+Name+" "+result;
17         }
18     }

View Code

多态的原理：当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就是说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。没有学过设计模式，那么对多态、乃至对面向对象的理解多半都是肤浅和片面的。我相信会有那种天才，可以听一知十，刚学的东西就可以灵活自如地应用，甚至要造汽车，他都能再去发明轮子。但对于绝大多数程序员，还是需要踏踏实实地学习基本的东西，并在不断地实践中成长，最终成为高手。

友情链接：直通硅谷　点职佳　北美留学生论坛