针对 Java 开发人员的 C# 编程语言(16)

C# 中的数组

数组是具有相同数据类型的项的有序集合，通过数组名以及所期望的项相对于数组开始位置的偏移量可以访问数组。与 Java 相比，在 C# 中声明和使用数组的方式有一些重要的不同，我将在这一部分中对此进行介绍。

一维数组

一维数组以线性方式存储了固定数目的项，它仅仅需要一个索引值就可以确定任何一项。

在 C# 中，数组声明中的方括号必须紧跟数据类型，而不可以像在 Java 中一样出现在变量名的后面。因此，可以使用下面的语法来声明整数类型的数组：

int[] MyArray;

而下面的声明在 C# 中是无效的：

int MyArray[];

一旦声明了数组，就可以使用新的关键字来设置它的大小，这与 Java 中是完全一样的：

int[] MyArray;           // declares the array reference
MyArray = new int[5];    // creates a 5 element integer array

然后，我们就可以使用与 Java 完全相同的语法来访问一维数组中的元素，注意 C# 数组的索引也是从零开始的：

MyArray [4]          // accesses the last element in the array

初始化

可以使用与 Java 相同的语法在创建时对数组元素进行初始化：

MyArray = new int[5] {1, 2, 3, 4, 5};

与 Java 不同，初始化器的数目必须与数组大小完全匹配。 我们可以利用这一特性在一行中声明和初始化 C# 数组：

  int[] TaxRates = {0, 20, 23, 40, 50};

此语法创建了一个大小与初始化器的数目相等的数组。

程序循环中的初始化

C# 中初始化数组的另一种方法就是使用 foreach 循环。下面的循环将数组中的每个元素都设置为零：

int[] MyLittleArray = new int[5];
foreach (int i in MyLittleArray) 
{
  MyLittleArray[i] = 0;
}

交错数组

C# 和 Java 都支持创建交错或者说非矩形的数组，其中的每一行都包含不同数目的列。例如，下面的交错数组的第一行有四项，而第二行有三项：

int[][] JaggedArray = new int[2][];
JaggedArray[0] = new int[4];
JaggedArray[1] = new int[3];

多维数组

C# 允许我们创建规则的多维数组，它可以看作是相同类型的值的矩阵。虽然 Java 和 C# 都支持交错的数组，但是 C# 还支持多维数组或数组的数组。我们将马上介绍交错数组。

使用下面的语法，我们可以声明一个多维矩形数组：

int[,] My2DIntArray;
float[,,,] My4DFloatArray;

其中，My2DintArray 是可以借此访问每个元素的名称。

注意， int[][] My2DintArray; 行在 C# 中有不同的含义，我们很快就会明白这一点。

一旦声明了数组，我们就可以这样给它分配内存：

int[,] My2DIntArray;           // declares array reference
My2DIntArray = new int[5,4];   // allocates space for 5x4 integers

然后，可以使用下面的语法来访问数组的元素：

My2DIntArray [4,3] = 906;

因为数组是从零开始的，所以这将第四行第五列中的元素（右下角）设置为 906。

初始化

通过下面的任何一种方法，都可以在一行中创建、设置和初始化多维数组：

int[,] intArray = {   {1,2,3},
                      {4,5,6}    };

int[,] intArray = new int [2,3] {   {1,2,3},
                                    {4,5,6}    };

int[,] intArray = new int [,] {    {1,2,3},
                                   {4,5,6}    };

程序循环中的初始化

数组中所有的元素都可以使用嵌套的循环进行初始化，如下所示：

int[,] intArray = new int[5,4];
foreach (int i in intArray)
{
  foreach (int j in intArray[])
  {
    j = 0;
  }
}

System.Array 类

在 .NET 中，数组是作为 System.Array 类的实例实现的。此类提供了几个有用的方法，例如 Sort() 和 Reverse()。

下面的程序说明了使用这几个方法是多么的容易。首先，我们使用 Array 类的 Reverse() 方法来使数组的元素反向，然后，我们使用 Sort() 方法对它们进行排序：

using System;

public class ArrayMethods
{
  public static void Main()
  {
    // Create string array of size 5
    string[] EmployeeNames = new string[5];
    Console.WriteLine("Enter five employee names:");


    // Read 5 employee names from user
    for(int i=0;i<5;i++)
    {
        EmployeeNames[i]= Console.ReadLine();
    }

    // Print the array in original order
    Console.WriteLine("\n** Original Array **");
    foreach(string EmployeeName in EmployeeNames)
    {
        Console.Write("{0}  ", EmployeeName);
    }

    //print the array in reverse order.
    Console.WriteLine("\n\n** Values in Reverse Order **");
    System.Array.Reverse(EmployeeNames);
    foreach(string EmployeeName in EmployeeNames)
    {
        Console.Write("{0}  ", EmployeeName);
    }
    
    //print the array in sorted order.
    Console.WriteLine("\n\n** Values in Sorted Order **");
    System.Array.Sort(EmployeeNames);
    foreach(string EmployeeName in EmployeeNames)
    {
        Console.Write("{0}  ", EmployeeName);
    }
        
  }
}

下面是此程序的一些典型输出：

Enter five employee names:
Luca
Angie
Brian
Kent
Beatriz

** Original Array **
Luca  Angie  Brian  Kent  Beatriz

** Values in Reverse Order **
Beatriz  Kent  Brian  Angie  Luca

** Values in Sorted Order **
Angie  Beatriz  Brian  Kent  Luca

返回页首

继承和派生类

通过创建一个从现有类派生的新类，我们可以扩展现有类的功能。派生类继承了基类的属性，并且我们可以在需要时添加或重写方法和属性。

在 C# 中，继承和接口实现都通过 : 运算符来定义，这等同于 Java 中的扩展和实现。注意，基类应该一直在类声明的最左边。

同 Java 一样，C# 不支持多重继承，这意味着类不能从多个类中继承。然而，我们可以为此目的而采用与 Java 相同的方式使用接口，正如我们在下一部分中将看到的。

下面的代码定义了一个名为 Point 的类，它有两个私有成员变量 x 和 y，表示点的位置。这些变量可以分别通过名为 X 和 Y 的属性来访问：

public class Point
{
  private int x, y;
  public Point()
  {
    x = 0;
    y = 0;
  }

  public int X
  {
    get
    {
      return x;
    }
    set
    {
      x = value;
    }
  }
  public int Y
  {
    get
    {
      return y;
    }
    set
    {
      y = value;
    }
  }
}

我们将从 Point 类派生一个新类（比如说名为 ColorPoint），如下所示：

public class ColorPoint : Point

于是 ColorPoint 继承了基类的所有字段和方法，我们可以根据需要向派生类中添加新的字段和方法来提供额外的特性。在这个示例中，我们添加了一个私有成员和一些访问器来为点增加颜色：

using System.Drawing;

public class ColorPoint : Point
{
  private Color screenColor;


  public ColorPoint()
  {
    screenColor = Color.Red;
  }

  public Color ScreenColor
  {
    get
    {
      return screenColor;
    }
    set
    {
      screenColor = value;
    }
  }
}

注意，派生类的构造函数隐式调用了基类（或 Java 术语中的超类）的构造函数。在继承中，所有的基类构造函数都是按照这些类出现在类层次中的顺序在派生类的构造函数之前调用的。