用具体代码演示static关键字
时间: 2024-05-02 11:03:53 浏览: 52
好的,下面是一个示例:
```
#include <iostream>
using namespace std;
class MyClass {
public:
static int count; // 静态成员变量
MyClass() {
count++;
}
static void showCount() { // 静态成员函数
cout << "Object count: " << count << endl;
}
};
int MyClass::count = 0; // 静态成员变量初始化
int main() {
MyClass obj1;
MyClass obj2;
MyClass::showCount();
return 0;
}
```
在上面的代码中,我们定义了一个`MyClass`类,包含一个静态成员变量`count`和一个静态成员函数`showCount`。在`main`函数中,我们创建了两个`MyClass`对象,调用了静态成员函数`showCount`,输出了对象的数量。
需要注意的是,静态成员变量必须在类外进行初始化,这里我们通过`MyClass::count = 0`来初始化。而静态成员函数只能访问静态成员变量,不能访问非静态成员变量。
相关问题
C#static关键字
C#中的static关键字可以用于修饰类、字段、方法、属性、构造函数等。它的作用是将其修饰的成员变为静态成员,即该成员不再与类的实例对象绑定,而是与类本身绑定。这意味着,无论创建多少个类的实例对象,静态成员只有一份,且可以通过类名直接访问。
在引用中,Student类被定义为静态类,其中的字段和方法也被定义为静态的。这意味着我们可以直接通过类名Student来访问其中的静态方法Print(),而不需要创建Student类的实例对象。
在引用中,Person类中的字段和方法被定义为静态的,但是Person类本身并没有被定义为静态类。这意味着我们需要先创建Person类的实例对象,然后通过该实例对象来访问其中的静态方法Print()。
下面是一个示例代码,演示了如何使用static关键字定义静态成员:
```csharp
using System;
class MyClass
{
public static int myStaticVar = 42; // 静态字段
public int myInstanceVar = 0; // 实例字段
public static void myStaticMethod() // 静态方法
{
Console.WriteLine("This is a static method.");
}
public void myInstanceMethod() // 实例方法
{
Console.WriteLine("This is an instance method.");
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine(MyClass.myStaticVar); // 直接访问静态字段
MyClass.myStaticMethod(); // 直接调用静态方法
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass();
obj1.myInstanceVar = 1;
obj2.myInstanceVar = 2;
Console.WriteLine(obj1.myInstanceVar); // 访问实例字段
Console.WriteLine(obj2.myInstanceVar);
obj1.myInstanceMethod(); // 调用实例方法
obj2.myInstanceMethod();
}
}
```
线程的同步和互斥用java代码简单演示一下
好的,下面是一个简单的Java代码演示线程同步和互斥:
```java
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized void decrement() {
count--;
}
public synchronized int getCount() {
return count;
}
}
public class SynchronizationDemo {
public static void main(String[] args) {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 100000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 100000; i++) {
counter.decrement();
}
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final count: " + counter.getCount());
}
}
```
在这个例子中,我们创建了一个名为`Counter`的类,其中包含了三个同步方法:`increment()`、`decrement()`和`getCount()`。这些同步方法使用`synchronized`关键字来确保在任何时候只有一个线程能够访问它们。
在`SynchronizationDemo`类中,我们创建了两个线程`t1`和`t2`,它们分别调用`increment()`和`decrement()`方法,对`Counter`对象进行操作。我们使用`start()`方法启动这两个线程,并使用`join()`方法等待它们执行完毕。
最后,我们使用`getCount()`方法获取`Counter`对象的计数器值,并将其输出到控制台上。
通过这个例子,我们可以看到如何使用`synchronized`关键字来实现线程同步和互斥。