讲解C#面相对象编程中的类与对象的特性与概念

类
“类”是一种构造，通过使用该构造，您可以将其他类型的变量、方法和事件组合在一起，从而创建自己的自定义类型。类就像一个蓝图，它定义类型的数据和行为。如果类没有声明为静态类，客户端代码就可以创建赋给变量的“对象”或“实例”，从而使用该类。在对变量的所有引用都超出范围之前，该变量始终保持在内存中。所有引用都超出范围时，clr 将标记该变量以供垃圾回收。如果类声明为静态类，则内存中只存在一个副本，并且客户端代码只能通过该类自身而不是“实例变量”访问该类。
声明类
类使用 class 关键字进行声明，如下面的示例所示：

public class customer
{
  //fields, properties, methods and events go here...
}

class 关键字前面是访问级别。由于在该例中使用 public，因此任何人都可以基于该类创建对象。类的名称位于 class 关键字的后面。定义的其余部分是类的主体，用于定义行为和数据。类的字段、属性、方法和事件统称为“类成员”。
创建对象
尽管有时类和对象可互换，但它们是不同的概念。类定义对象的类型，但它不是对象本身。对象是基于类的具体实体，有时称为类的实例。
通过使用 new 关键字（后跟对象将基于的类的名称）可以创建对象，如下所示：

customer object1 = new customer();

创建类的实例后，将向程序员传递回对该对象的引用。在前面的示例中，object1 是对基于 customer 的对象的引用。此引用引用新对象，但不包含对象数据本身。实际上，可以在根本不创建对象的情况下创建对象引用：

customer object2;

建议不要创建像这样的不引用对象的对象引用，因为在运行时通过这样的引用来访问对象的尝试将会失败。但是，可以创建这样的引用来引用对象，方法是创建新对象，或者将它分配给现有的对象，如下所示：

customer object3 = new customer();
customer object4 = object3;

此代码创建了两个对象引用，它们引用同一个对象。因此，通过 object3 对对象所做的任何更改都将反映在随后使用的 object4 中。由于基于类的对象是按引用来引用的，因此类称为引用类型。
类继承
继承是通过使用“派生”来实现的，而派生意味着类是使用“基类”声明的，它的数据和行为从基类继承。通过在派生的类名后面追加冒号和基类名称，可以指定基类，如下所示：

public class manager : employee
{
  // employee fields, properties, methods and events are inherited
  // new manager fields, properties, methods and events go here...
}

当类声明基类时，它继承基类除构造函数以外的所有成员。
与 c++ 不同，c# 中的类只能直接从一个基类继承。但是，因为基类自身也可能继承自另一个类，所以类可以间接继承多个基类。而且，一个类可以直接实现一个以上的接口。
类可以声明为抽象类。抽象类包含具有签名定义但没有实现的抽象方法。抽象类不能进行实例化。只能通过实现抽象方法的派生类使用抽象类。相比之下，密封类不允许其他类从其派生。
类定义可在不同的源文件之间进行拆分。
描述
下面的示例中定义了一个公共类，其中包含一个字段、一个方法和一个称为构造函数的特殊方法。有关更多信息，请参见构造函数（c# 编程指南）。然后使用 new 关键字将该类实例化。

public class person
{
  // field
  public string name;

  // constructor that takes no arguments.
  public person()
  {
    name = "unknown";
  }

  // constructor that takes one argument.
  public person(string nm)
  {
    name = nm;
  }

  // method
  public void setname(string newname)
  {
    name = newname;
  }
}
class testperson
{
  static void main()
  {
    // call the constructor that has no parameters.
    person person1 = new person();
    console.writeline(person1.name);

    person1.setname("john smith");
    console.writeline(person1.name);

    // call the constructor that has one parameter.
    person person2 = new person("sarah jones");
    console.writeline(person2.name);

    // keep the console window open in debug mode.
    console.writeline("press any key to exit.");
    console.readkey();
  }
}

输出:

unknown
john smith
sarah jones

对象
类或结构定义的作用类似于蓝图，指定该类型可以进行哪些操作。从本质上说，对象是按照此蓝图分配和配置的内存块。程序可以创建同一个类的多个对象。对象也称为实例，可以存储在命名变量中，也可以存储在数组或集合中。使用这些变量来调用对象方法及访问对象公共属性的代码称为客户端代码。在 c# 等面向对象的语言中，典型的程序由动态交互的多个对象组成。

结构实例。. 选件类实例
由于类是引用类型，因此类对象的变量引用该对象在托管堆上的地址。如果将同一类型的第二个对象分配给第一个对象，则两个变量都引用该地址的对象。这一点将在本主题后面部分进行更详细的讨论。
类的实例是使用 new 运算符创建的。在下面的示例中，person 为类型，person1 和 person 2 为该类型的实例（即对象）。

public class person
{
  public string name { get; set; }
  public int age { get; set; }
  public person(string name, int age)
  {
    name = name;
    age = age;
  }
  //other properties, methods, events...
}

class program
{
  static void main()
  {
    person person1 = new person("leopold", 6);
    console.writeline("person1 name = {0} age = {1}", person1.name, person1.age);

    // declare new person, assign person1 to it.
    person person2 = person1;

    //change the name of person2, and person1 also changes.
    person2.name = "molly";
    person2.age = 16;

    console.writeline("person2 name = {0} age = {1}", person2.name, person2.age);
    console.writeline("person1 name = {0} age = {1}", person1.name, person1.age);

    // keep the console open in debug mode.
    console.writeline("press any key to exit.");
    console.readkey();

  }
}

输出：

  person1 name = leopold age = 6
  person2 name = molly age = 16
  person1 name = molly age = 16

由于结构是值类型，因此结构对象的变量具有整个对象的副本。结构的实例也可以使用 new 运算符来创建，但这不是必需的，如下面的示例所示：

public struct person
{
  public string name;
  public int age;
  public person(string name, int age)
  {
    name = name;
    age = age;
  }
}

public class application
{
  static void main()
  {
    // create struct instance and initialize by using "new".
    // memory is allocated on thread stack.
    person p1 = new person("alex", 9);
    console.writeline("p1 name = {0} age = {1}", p1.name, p1.age);

    // create new struct object. note that struct can be initialized
    // without using "new".
    person p2 = p1;

    // assign values to p2 members.
    p2.name = "spencer";
    p2.age = 7;
    console.writeline("p2 name = {0} age = {1}", p2.name, p2.age);

    // p1 values remain unchanged because p2 is copy.
    console.writeline("p1 name = {0} age = {1}", p1.name, p1.age);

    // keep the console open in debug mode.
    console.writeline("press any key to exit.");
    console.readkey();
  }
}

输出：

  p1 name = alex age = 9
  p2 name = spencer age = 7
  p1 name = alex age = 9

p1 和 p2 的内存在线程堆栈上进行分配。该内存随声明它的类型或方法一起回收。这就是在赋值时复制结构的一个原因。相比之下，当对类实例对象的所有引用都超出范围时，为该类实例分配的内存将由公共语言运行时自动回收（垃圾回收）。无法像在 c++ 中那样明确地销毁类对象。

对象标识与. 值相等性
在比较两个对象是否相等时，首先必须明确您是想知道两个变量是否表示内存中的同一对象，还是想知道这两个对象的一个或多个字段的值是否相等。如果您要对值进行比较，则必须考虑这两个对象是值类型（结构）的实例，还是引用类型（类、委托、数组）的实例。
若要确定两个类实例是否引用内存中的同一位置（意味着它们具有相同的标识），可使用静态 equals 方法。（system.object 是所有值类型和引用类型的隐式基类，其中包括用户定义的结构和类。）
若要确定两个结构实例中的实例字段是否具有相同的值，可使用 valuetype.equals 方法。由于所有结构都隐式继承自 system.valuetype，因此可以直接在对象上调用该方法，如下面的示例所示：

// person is defined in the previous example.

//public struct person
//{
//  public string name;
//  public int age;
//  public person(string name, int age)
//  {
//    name = name;
//    age = age;
//  }
//}

person p1 = new person("wallace", 75);
person p2;
p2.name = "wallace";
p2.age = 75;

if (p2.equals(p1))
  console.writeline("p2 and p1 have the same values.");

输出：

 p2 and p1 have the same values.

equals 的 system.valuetype 实现使用反射，因为它必须能够确定任何结构中有哪些字段。在创建您自己的结构时，重写 equals 方法可以提供针对您的类型的高效求等算法。