什么是类？

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

。

什么是对象

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

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。这会将类指定为不可扩展即不能从他派生出其他类。