附加修饰符：

static

类成员： 类成员由static关键字修饰

特点：可以在未创建类的对象前就用类名直接调用类成员

类变量：由static关键字修饰的字段

特点：

隶属于类模板（共用）

直接使用类名.访问

注意：无法使用对象引用.

类方法：

由static关键字修饰的方法

特点：

隶属于类模板

直接使用类名.访问

注意：

无法使用对象引用.

方法中不能使用this、base

静态构造函数：（必须无参数）

static 类名（）{}

用处：初始化static变量

特点：

每个类中都有此方法

不可被直接调用

使用类时自动执行（new 对象时，访问类方法）

运行期间只执行一次

知识点：

一个类中包含什么内容？

答：字段    // Class c1 = new Class()  c1.字段

    成员方法  // public void Method()

    构造    new

    析构    ~ 垃圾回收前自动调起

    静态方法  public static void Test

    静态字段  public static int data2

    静态构造  使用类立即使用

    成员属性  new 对象

    成员变量 标记对象的状态

    类属性    public static int Data2{} 类名.

静态类:

由static修饰的类

特点：

不能实例化（没有对象）

共享,

使用方式：类名.访问内容

原则：

静态类中的所有成员必须是静态的

\b:退格

示例：

public static class StaticTestClass

{

      public static int n = 0;

      public static void Add()

      {

          n++;

      }

}

类的加载次序

如图所示：

一.多类的加载次序

1.优先加载Main所在的类

2.执行Main方法

3.执行过程中使用到哪个类 加载哪个类

二.单个类的加载次序

1.加载类中的静态变量 静态方法

2.执行静态构造为静态变量进行初期化

3.当产生对象new对象时 分配成员变量和成员方法到对象中

注意：

非静态的可以调用静态和非静态

静态的只能调用静态的

抽象（abstract）

抽象的意义：

描述抽象的概念,规定必须实现的方法的统一接口

抽象类：

用abstract关键字来修饰的类

abstract class AbstractClass

{

}

特点：

必须被继承才可使用

不能被直接实例化

和密封类（sealed类）正好相反

抽象方法：

用abstract来修饰的方法

abstract returnType AbstractMethod ( [paramlist] );

特点：

必须被重写(override)

只有方法头，没有方法体.

抽象方法必须在抽象类中.

规定：

1.抽象类中不一定包含抽象方法.

2.有抽象方法的类必定是抽象类.

3.抽象方法只是声明，没有方法的实现.

4.构造方法、类方法不能声明为抽象方法.

5.子类必须实现抽象方法，除非子类也是抽象类.

6.抽象类中不一定全是抽象方法 可以有一部分具体实现.

密封（sealed） 被sealed修饰的类被称为密封类

sealed class SealedClass { }

特性：密封类不能被继承 被sealed修饰的方法被称为密封方法

sealed override returnType SealedMethod([paramList]) { }

特性： 密封方法会重写基类中的方法 密封方法无法被重写

注意：必须始终与override一起使用

被sealed修饰的属性被称为密封属性

sealed override returnType Property { set  { } get { } }

特性： 密封属性会覆盖基类中的属性 密封属性无法被覆盖

注意：必须始终与override一起使用

const&readonly

const ：

定义的是静态常量

声明的同时赋值

运行期间不能改变它的值

属于编译时常量

不能用new初始化

const一般修饰值类型和String

readonly ：

是只读变量

属于运行时变量

可以在类constructor里改变它的值

不能作用于局部变量

初始化时机：

1.声明的同时赋值

2.静态变量的话 在静态构造中初始化

3.非静态变量的话 在非静态构造中初始化

接口和索引器

什么是接口：

在构建类的过程中，经常会遇到一种特殊的情况，在描述某个类的各个方法时，

对每个方法我们只能给出其功能实现的要求（原形声明）但不能给出具体的功能实现（函数定义体）。

因为我们所处理的问题只是一个泛泛的功能说明，并没有针对某一具体类型的问题来说明。

例：

动物吃：什么动物吃？怎么吃？吃什么？只是个概念而已

动物睡觉：站？躺？坐？睁眼？闭眼？只是个概念而已

接口：

一组只有成员方法声明没有方法体的方法集。

接口中可写的内容：

方法、属性、索引器、事件

接口的作用：

提供了完全的抽象

规定类应具有的形式

接口中的方法在多个实现接口的类中表现出多态性

便于设计、管理、协作项目

接口的定义：

要点：类似于类的定义格式，只是以 interface作为定义符。

格式：

[访问修饰符] interface 接口名

{

    返回值类型 方法名([参数列表]);（只有声明而无方法体）

}

或：

// 多继承模式：

[访问修饰符] interface 派生的接口名 : 父接口名列表

{

    返回值类型 方法名([参数列表]);（只有声明而无方法体）

}

注意事项：

接口中声明的方法都是默认public的 不能自定义访问级别

示例：

public interface Dispaly

{

? void ViewImage();

}

//实现接口

语法：

// 一个类可以实现多个接口

class 类名 : 接口1，接口2，接口3，......(,分割)

{

???? // 所有接口定义方法的实现

}

// 一个接口可以被多个类实现：

class 类1 : 接口1

{

�  // 接口定义方法的实现

}

class 类2 : 接口1

{

  // 接口定义方法的实现

}

class 类3 : 接口1

{

// 接口定义方法的实现

}

class 类4 : 接口1

{

  // 接口定义方法的实现

}

虚函数：由Virtual修饰的函数.

实现原则：

实现的方法必须与接口中的原型定义保持一致

必须实现接口中的所有成员方法

实现方式：隐式实现、显式实现

隐式实现：

interface Animal

{

  void Eat();

}

class Cat : Animal

{

    // 隐式实现在类中无法辨识该方法是那个接口的

    public void Eat()

    {

    }

}

显式实现：

interface Animal

{

void Sleep();

}

class Dog : Animal

{

// 显式实现在类中明确方法是那个接口的，所有方法都是私有的

void Animal.Eat()

{

}

}

显式\隐式的选择：

若实现的所有方法均无重名，使用隐式

若实现的所有方法中出现重名，使用显式

接口中的方法在实现类中呈现多态性：

接口回调:接口引用=实现类对象

含义：

接口也是引用数据类型，可以指向任意实现了该接口的类实例

作用：

统一管理实现类对象

访问显式实现的方法

注意：

显式实现的方法只能用接口回调来调用到

无法用实现类引用调用到

示例：

public interface IHello

{

void Bellow();

}

// 显式接口实现

public class Speak : IHello

{

void IHello.Bellow()

{

Console.WriteLine("Hello");

}

}

class MainClass

{

public static void Main (string[] args)

{

Speak speak = new Speak();

//speak.Bellow() error

(speak as IHello).Bellow();// 不安全

      //原因：有可能出现空指针异常

IHello ih = speak as IHello;

if (ih != null)

{

ih.Bellow();//安全

}

}

}

抽象类和接口的区别：

1.接口用interface来定义，而不是class

2.接口不能创建实例，抽象类可以间接实例化（通过子类）

3.抽象的程度：接口完全抽象 抽象类部分抽象

4.接口采用多重继承机制，类采用单一的继承机制

索引器：

[访问修饰符] 返回值类型 this[任意数据类型 index]{set{} get{}}

实质：方法的变异品种

作用：访问方法从对象.方法名(参数)=>对象[参数]

自定义索引器 VS 数组索引器：

(1)索引器的索引值(Index)类型不受限制

(2)索引器允许重载

(3)索引器不是一个变量

索引器 VS 属性

(1)属性以名称来标识，索引器以函数形式标识

(2)索引器可以被重载，属性不可以

(3)索引器不能声明为static，属性可以

要声明类或结构上的索引器，请使用 this 关键字：

// Indexer declaration

// 最少有一个参数

public 数据类型 this[形参1，形参2......]

{

  // get and set accessors

get

{

}

set

{

// 使用隐参value接收实际参数

}

}

接口中声明索引器的方法：

数据类型 this [【参数列表】最少有一个参数]{set;get;}