C#面向对象基础
类与实例
•对象：一切事物皆对象，对象就是一个 自包含的实体，用一组可识别的特性和行为来标识
•类：具有相同的属性和功能的对象的抽象的集合
1、定义类
1 class cat
2 {
3 public string shout()
4 {
5 return "喵";
6 }
7 }
注：“这里的'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 }
注：“'cat cat=new cat()；'其实做了两件事。”
1 cat cat; //声明一个cat对象，对象名为cat 2 cat=new cat(); //将此cat对象实例化
“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 }
2.2、有参构造函数调用
1 private void button1_click(object sender, eventargs e)
2 {
3 cat cat = new cat("咪咪");
4 messagebox.show(cat.shout());
5 }
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 }
注：方法的重载，两个方法必须要方法名相同，但参数类型或个数必须要有所不同，否则就没有意义了。方法重载可在不改变原方法的基础上，新增功能，算是提供了函数可扩展的能力。
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 }
•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 }
基类：
猫类：
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 }
狗类：
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 }
注：子类从它的父类中继承的成员有方法、域、属性、事件、索引指示器，但对于构造方法，有一种特殊，他不能被继承，只能被调用，对于调用父类的成员，可以使用base关键字。
如果还有动物类的话，按照以前的写法就需要再复制n遍，不用继承的话，如果要修改功能，就必须在所有重复的方法中修改，代码越多，出错的可能就越大，而继承的有点是，继承使得所有子类公共的部分都放在了父类，使得代码得到了共享，这样就避免了重复，另外，继承可使得修改或扩展继承而来的实现都较为容易。
继承是有缺点的，那就是父类变，则子类不得不变，另外继承会破坏包装，父类实现细节暴露给子类，这其实是增大了两个类之间的耦合性。
3.3、多态
•解释：表示不同的对象可以执行相同的动作，但要通过它们自己的实现代码来执行
下面通过过一个小故事，更好的理解多态的定义
我们的国粹‘京剧’以前都是子承父业，代代相传的艺术。假设有这样一对父子，父亲是非常有名的京剧艺术家，儿子长大成人了，模仿父亲的戏也惟妙惟肖。有一天，父亲突然发高烧，上不了台边沿，而票都早就卖出，退票显然会大大影响声誉。怎么办呢？由于京戏都是需要化妆才可以上台的，于是就决定让儿子代父亲上台表演。化妆后谁还认识谁呀，只要长得好久可以混弄过去了。这里面有几点注意：第一、子类以父类的身份出现，儿子代表老子表演，化妆后就是以父亲身份出现了。第二、子类在工作时以自己的方式来实现，儿子模仿得再好，那也是模仿，儿子只能用自己理解的表现方式去模仿父亲的作品。第三、子类以父类的身份出现时，子类特有的属性和方法不可以使用，儿子经过多年学习，其实已经有了自己的创作，自己的绝活，但在此时，代表父亲表演时，绝活是不能表现出来的，当然，如果父亲还有别的儿子会表演，也可以在此时代表父亲上场，道理也是一样。这就是多态。
•虚方法
解释：为了使子类的实例完全接替来自父类的类成员，父类必须将该成员声明为虚拟的。这是通过在该成员的返回类型之前添加virtual关键字来实现。然后，子类可以选择使用override关键字，将父类实现替换为它自己的实现，这就是方法重写override，或者叫做方法覆写。
父类：
1 class animal
2 {
3 .......
4 public virtual string shout() // 注意修饰符中增加了一个virtual，它表示此方法是虚方法，可以被子类重写
5 {
6 return "";
7 }
8 }
子类：
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 }
多态的原理：当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。也就是说，虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。没有学过设计模式，那么对多态、乃至对面向对象的理解多半都是肤浅和片面的。我相信会有那种天才，可以听一知十，刚学的东西就可以灵活自如地应用，甚至要造汽车，他都能再去发明*。但对于绝大多数程序员，还是需要踏踏实实地学习基本的东西，并在不断地实践中成长，最终成为高手。