跳到主要内容

C# static关键字

提示
  1. 静态成员的共享特性：在C#中，使用 static 关键字声明的类成员（如变量或方法）只有一个副本，被该类的所有对象共享。
  2. 静态变量和方法的访问方式：静态变量和方法可以通过类名直接访问，无需创建类的实例，与实例变量和方法形成对比。
  3. 静态类的特点：静态类不能被实例化，其所有成员也必须是静态的，且静态类不能被继承。在静态类内部，可以直接访问其静态成员，无需使用类名。

在 C# 中，如果我们在类成员上使用 static 关键字，那么这个类型成员将只有一个副本。

所有该类的对象共享一个副本，而不是创建各自的副本。

C# 静态变量​

如果一个变量被声明为 static，我们可以使用类名来访问这个变量。例如，

using System;

namespace StaticKeyword {

  class Student {

    // 静态变量
    public static string department = "Computer Science";
  }

  class Program {
    static void Main(string[] argos) {

      // 访问静态变量
      Console.WriteLine("Department: " + Student.department);

      Console.ReadLine();
    }
  }
}

输出

Department: Computer Science

在上面的例子中，我们创建了一个名为 department 的静态变量。由于该变量是静态的，我们使用了类名 Student 来访问这个变量。

静态变量与实例变量​

在 C# 中，一个类的每个对象都将拥有自己的实例变量副本。例如，

class Student {

  // 实例变量
  public string studentName;
 }

class Program {
  static void Main(string[] args) {

    Student s1 = new Student();
    Student s2 = new Student();
  }
}

在这里，对象 s1 和 s2 将拥有变量 studentName 的独立副本。它们彼此不同。

然而，如果我们声明一个变量为静态的，那么类的所有对象将共享同一个静态变量。我们不需要创建类的对象就可以访问静态变量。

示例：C# 静态变量与实例变量​

using System;

namespace StaticKeyword {

  class Student {
    static public string schoolName = "Programiz School";
    public string studentName;

  }

    class Program {
    static void Main(string[] args) {

      Student s1 = new Student();
      s1.studentName = "Ram";

      // 调用实例变量
      Console.WriteLine("Name: " + s1.studentName);
      // 调用静态变量
      Console.WriteLine("School: " + Student.schoolName);

      Student s2 = new Student();
      s2.studentName = "Shyam";

       // 调用实例变量
      Console.WriteLine("Name: " + s2.studentName);
      // 调用静态变量
      Console.WriteLine("School: " + Student.schoolName);

      Console.ReadLine();
    }
  }
}

输出

Name: Ram
School: Programiz School
Name: Shyam
School: Programiz School

在上述程序中，Student 类有一个非静态变量 studentName 和一个静态变量 schoolName。

在 Program 类中，

  • s1.studentName / s2.studentName - 分别使用对象 s1 和 s2 调用非静态变量
  • Student.schoolName - 使用类名调用静态变量

由于所有学生的 schoolName 都是相同的，将 schoolName 设为静态是合理的。这样可以节省内存并使程序更高效。

C# 静态方法​

就像静态变量一样，我们可以使用类名来调用静态方法。

class Test {

  public static void display() {....}

}

class Program {
  static void Main(string[] args) {

    Test.display();
  }
}

在这里，我们直接使用类名 Program 访问了静态方法。

当我们将一个方法声明为静态时，类的所有对象共享同一个静态方法。

示例：C# 静态和非静态方法​

using System;

namespace StaticKeyword {

  class Test {

    public void display1() {

      Console.WriteLine("非静态方法");
    }
    public static void display2() {

      Console.WriteLine("静态方法");
    }
  }

  class Program {
    static void Main(string[] args) {

      Test t1 = new Test();
      t1.display1();
      Test.display2();
      Console.ReadLine();
    }
  }
}

输出

非静态方法
静态方法

在上述程序中，我们在 Test 类内声明了一个名为 display1() 的非静态方法和一个名为 display2() 的静态方法。

在 Program 类内，

  • t1.display1() - 使用 s1 对象访问非静态方法
  • Test.display2() - 使用类名 Test 访问静态方法

注意：在 C# 中，Main 方法是静态的。所以，我们可以在不创建对象的情况下调用它。

C# 静态类​

在 C# 中，当我们将一个类声明为静态时，我们不能创建该类的对象。例如，

using System;

namespace StaticKeyword {

  static class Test {
    static int a = 5;
    static void display() {

      Console.WriteLine("静态方法");
    }

    static void Main(string[] args) {

      // 创建 Test 的对象
      Test t1 = new Test();
      Console.WriteLine(a);
      display();
    }
  }
}

在上面的示例中，我们有一个静态类 Test。我们创建了类 Test 的对象 t1。

由于我们不能创建静态类的对象，我们得到以下错误：

error CS0723: Cannot declare a variable of static type 'Test'
error CS0712: Cannot create an instance of the static class

注意静态类的字段和方法也是静态的，因为我们只能在静态类内拥有静态成员。

注意：我们不能在 C# 中继承静态类。例如，

static class A {
  ...
}

// 错误代码
class B : A {
  ...
}

在类内访问静态成员​

如果我们在同一个类内访问静态变量和方法，我们可以直接访问它们，而不需要使用类名。例如，

using System;

namespace StaticKeyword {

  class Test {

    static int age = 25;
    public static void display() {

      Console.WriteLine("静态方法");
    }

    static void Main(string[] args) {

      Console.WriteLine(age);
      display();
      Console.ReadLine();
    }
  }
}

输出

25
静态方法

这里，我们在不使用类名的情况下访问了静态字段 age 和静态方法 display()。

最后于 更新