C#控制台framework

什么是类？

实际上是对某种类型的对象定义变量和方法的原型。它表示对现实生活中一类具有共同特征的事物的抽象，是面向对象编程的基础。
简单地说，类是一种抽象的数据类型，是对一类对象的统一描述。在生活中，常常把一组具有相同特性的事物归为一类，当然根据分类的标准不同，划分的类也是不相同的。汽车和人都是独立的类，它们都有各自的特点。汽车这个大类还可以分为卡车，公共汽车，和小轿车等各种小类。人可以分为男人和女人。将这些思想反映在编程技术中就产生了类的概念。
类是对某个对象的定义。它包含有关对象动作方式的信息，包括它的名称、方法、属性和事件。实际上它本身并不是对象，因为它不存在于内存中。当引用类的代码运行时，类的一个新的实例，即对象，就在内存中创建了。虽然只有一个类，但能从这个类在内存中创建多个相同类型的对象。

。

什么是对象

类的实例（占有实际的空间）

1）类相当于盖楼房的图纸一样，虽然定义了有哪些成员，但并没有实际的空间
2）类可以实例化出多个对象，实例化出的对象占有实际空间（用来存储成员变量）
跟对象的关系

类跟对象的关系

类是一个抽象的概念；
而对象是类抽象概念的实物表达；
打个比方：
比如水果摊进了一批水果（就好比是类）；
然后就去问卖家有哪些新鲜的水果；
店家说有苹果、梨、桃等等（这里的苹果、梨、桃就是对象）；
也就是说对象是类的具体表达；
而类则是对象的抽象表达。

面向对象和面向过程 ©有区别?

面向过程: 注重的是实现程序的这个过程(细节)
面向对象: 注重的是对象本身.
例如洗衣服
1, 收拾脏衣服
2, 打开洗衣机;
3, 放进洗衣机
4, 放水
5, 放洗衣粉
6, 设定时间
7, 拿出洗好的衣服
8, 晾晒
面向过程实现洗衣服这个功能;
找一个女朋友买一个洗衣机
每一个细节都必须亲力亲为
面向对象实现洗衣服这个功能
以上面向对象实现洗衣服这个功能对于我们本身而言只要关注对象就可以, 而不需要关注实现这个功能的过程
对象: 万事万物都是对象
对象的构成: 属性, 方法, 事件

封装

封装的含义：封装将复杂模块或系统的逻辑实现细节隐藏，让使用者只需要关心这个模块或系统怎么使用，而不用关心这个模块或系统是怎么实现的。

封装的作用：在面向对象的的编程中，我们一般通过接口来描述某个系统或模块具体什么功能，然后再通过继承或者其它方式实现这个接口（隐藏实现细节）
封装的方法：将一段代码拿出来放在一个方法里并给这个方法起个名，需要这段代码时只需要叫这个方法的名就行，不必关心它的处理过程。在这里这个处理过程就被封装到了方法里。
在怎么样的情况下封装：封装的概念就比较强拉!我以我自己的理解来讲解下,虽然你没有分.呵呵
封装其实就是把数据或者是函数等集合在一个类里面,别人调用你的类的时候是New对象,然后通过这个对象来访问里面的方法以及属性,而用户是不知道你底层的这个类的代码是怎么实现的,这个应该蛮通俗的,深点就要属于接口了,接口也是用来管理这些方法和属性的,如果方法和属性是一大仓库的物品,那接口就是管理这些物品的管理员了.接口很利于程序的扩展

get跟set的方法及应用，优点等

C#中get、set用法中，类的set和get成员是外部程序访问类内部属性的唯一方法，就像你去银行取钱，你不能直接从银行的保险柜里拿钱，而是银行营业人员把钱取出来给你的。
　　属性在调用者看来就像一个普通的变量，但作为类的设计者，你可以利用属性来隐藏你类中的一些字段，使外界只能通过属性来访问你的字段，你可以通过属性来限制外界对你的字段的存取，就利用get、set。如果想让用户随意存取你的字段，那么就实现get、set；如果只想让用户读取字段，就只实现get；若只想让用户写字段就只实现set。同时还可以在set和get中对用户传递的值进行一些验证工作，以确保你的字段将含有正确的值。
一则是隐藏组件或类内部的真是成员；
二是用来建立约束的，比如，实现“有我没你”这种约束；
三是用来响应属性变化事件，当属性变化是做某事，只要写在set方法里就行。

类的访问修饰符

C#共有五种访问修饰符：public、private、protected、internal、protected internal。作用范围如下：
访问修饰符说明
public 公有访问。不受任何限制。
private 私有访问。只限于本类成员访问，子类，实例都不能访问。
protected 保护访问。只限于本类和子类访问，实例不能访问。
internal 内部访问。只限于本项目内访问，其他不能访问。
protected internal 内部保护访问。只限于本项目或是子类访问，其他不能访问
C#成员类型的可修饰及默认修饰符如下：

成员类型默认修饰符可被修饰符
enum public none
class private public、protected、internal、private、
protected internal
interface public none
struct private public、internal、private
下面我就结合实例，讲一下public、private、protected、internal和protected internal的作用范围。

如下代码：

1:  using System;

2: using System.Collections.Generic;
3: using System.Text;
4:
5: namespace AccessModifier
6: {
7: public class AccessModifierClass
8: {
9: public string GetPublicString()
10: {
11: return “Public String”;
12: }
13:
14: protected string GetProtectedString()
15: {
16: return “Protected String”;
17: }
18:
19: private string GetPrivateString()
20: {
21: return “Private String”;
22: }
23:
24: internal string GetInternalString()
25: {
26: return “Internal String”;
27: }
28:
29: protected internal string GetProtectedInternalString()
30: {
31: return “Protected Internal String”;
32: }
33:
34: void AvailableAccessModifier()
35: {
36: this.GetPublicString();
37: this.GetPrivateString();
38: this.GetInternalString();
39: this.GetProtectedInternalString();
40: this.GetProtectedString();
41: }
42: }
43:
44: public class TestAccessModifierClass1
45: {
46: void AvailableAccessModifier()
47: {
48: AccessModifierClass item = new AccessModifierClass();
49: item.GetPublicString();
50: item.GetInternalString();
51: item.GetProtectedInternalString();
52: }
53: }
54:
55: public class TestAccessModifierClass2 : AccessModifierClass
56: {
57: void AvailableAccessModifier()
58: {
59: AccessModifierClass item = new AccessModifierClass();
60: item.GetPublicString();
61: item.GetInternalString();
62: item.GetProtectedInternalString();
63: base.GetProtectedString();
64: }
65: }
66: }
AccessModifierClass是我们的访问修饰符类，里面有五种访问修饰符方法，可见在AccessModifierClass类里面的AvailableAccessModifier()方法可以访问所有的方法。

在TestAccessModifierClass1类中的AvailableAccessModifier()方法只能访问public、Internal和Protected Internal方法。

TestAccessModifierClass2类继承自AccessModifierClass类，所以它的AvailableAccessModifier()方法可以访问public，internal,protected和protected internal方法。

在新建一个工程，且引用AccessModifierClass类的dll，代码如下：

1: using System;
2: using System.Collections.Generic;
3: using System.Text;
4: using AccessModifier;
5:
6: namespace AccessModifierApp
7: {
8: public class AccessModifierAppClass1
9: {
10: void AvailableAccessModifier()
11: {
12: AccessModifierClass item = new AccessModifierClass();
13: item.GetPublicString();
14: }
15: }
16:
17: public class AccessModifierAppClass2 : AccessModifierClass
18: {
19: void AvailableAccessModifier()
20: {
21: AccessModifierClass item = new AccessModifierClass();
22: item.GetPublicString();
23: base.GetProtectedString();
24: base.GetProtectedInternalString();
25: }
26: }
27: }

构造函数的定义及其作用

构造函数是在创建给定类型的对象时执行的类方法。构造函数具有与类相同的名称，它通常初始化新对象的数据成员。
在下面的示例中，定义了一个具有一个简单的构造函数，名为 Taxi 的类。然后使用 new 运算符来实例化该类。在为新对象分配内存之后，new 运算符立即调用 Taxi 构造函数。

public class Taxi
{
public bool isInitialized;
public Taxi() //构造函数与类同名，可重载
{
//在类被实例化的时候自动调用一般用于初始化类的一些属性
isInitialized = true;
}
}

class TestTaxi
{
static void Main()
{
Taxi t = new Taxi(); //这时会自动运行Taxi类的构造函数Taxi（）
System.Console.WriteLine(t.isInitialized);
}
}

不带参数的构造函数称为“默认构造函数”。无论何时，只要使用 new 运算符实例化对象，并且不为 new 提供任何参数，就会调用默认构造函数。

为什么要创建对象（实例化）

通过已有的类（class）创建出该类的一个对象（duobject），这一过程就叫做类的实例化。
打个比方：
你设计了一个飞机模型zhi，交给工人师dao傅去加工制作，生产出一个（一批）飞机。飞机模型就相当于程序中的类，生产出来的飞机就是回对象，生产飞机这一过程就叫做类的答实例化。
MyPlane plane1= new MyPlane(); //类的实例化

类成员变量和方法的访问方式有哪些

非静态的,创建类的实例,然后用实例名.成员变量访问
静态的,用类名.成员变量访问
如果是私有的,除了类本身可以用,不能从外部调用

继承

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

继承的思想实现了属于（IS-A）关系。例如，哺乳动物属于（IS-A）动物，狗属于（IS-A）哺乳动物，因此狗属于（IS-A）动物。

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为\”一个接口，多个功能\”。

多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态就是同一个接口，使用不同的实例而执行不同操作。

静态成员

一、静态字段

@1、与实例字段一样，可以在声明的同时进行初始化。

@2、与实例字段不同，如果没有对静态字段进行初始化，静态字段将自动获取默认值（0，null，false等）。所以，一个静态字段即使没有被显示地赋值，也可以被访问。

二、静态属性

三、静态方法

@1、this关键字在静态方法中是无效的。因为静态方法不是通过一个特定的实例来引用的。

@2、一般静态方法不能访问类中的实例字段和实例方法，除非事先获得对字段和方法所从属于的那个特定的实例的引用（通过传递参数）。

四、静态构造器

静态构造器用来对类而不是类实例进行初始化。静态构造器并不是显示调用的。”运行时“会在首次访问类（可能是调用一个普通构造器，可能是访问类的一个静态方法或静态字段）时自动调用静态构造器。我们使用静态构造器将类中的静态数据初始化成一个特定的值，尤其是在无法通过在声明时的一次简单地赋值来获得初始值的时候。

例如： class Employee

{ static Employee()

{    Random randomGenerator=new Randow();NextId=randomGenerator.Next(101,999);//生成一个100到1000的一个随机整数}public static int NextId=42;

}

说明：由于初始值涉及一个方法调用，无法通过在声明时的一次简单地赋值来完成。所以NextId的初始化代码被放到一个静态构造器中，而没有作为声明的一部分。

注意：@1、假如对NextId的赋值既在静态构造器中进行，又在声明时进行，那么当初始化结束的时候，最终获得的是什么值？观察C#编译器生成的CIL代码，发现声明时的赋值被移动了位置，成为静态构造器中的一个语句。因此，在静态构造器中进行的赋值将优先于声明字段时进行的赋值，这会实例字段的情况是一样的。

@2、没有静态终结器的说法。

@3、最好是在声明的同时完成静态初始化，而不要使用静态构造器。

五、静态类

@1、静态类不包含任何实例字段，实例方法。当创建一个能实例化的类没有意义是，就可以声明为静态类。

@2、c#编译器会自动在CIL代码中把静态类标记为abstract何sealed。这会将类指定为不可扩展即不能从他派生出其他类。