JAVA中static关键字的作用及用法

static关键字在Java中有很多用法，以下是一些常见的用法及其示例代码：

1. 静态变量（Static Variables）
静态变量是类的所有实例共享的变量。它们不属于任何特定的实例，而是属于类本身。静态变量可以在没有创建类的实例的情况下访问。

public class MyClass {
    // 静态变量
    static int staticVar = 10;

    public static void main(String[] args) {
        // 访问静态变量
        System.out.println("静态变量的值： " + MyClass.staticVar);
    }
}

 

2. 静态方法（Static Methods）
静态方法是不依赖于对象的方法，可以直接通过类名调用。静态方法不能访问类的非静态成员变量和非静态成员方法，因为它们需要依赖具体的对象实例。

public class MyClass {
    // 静态方法
    public static void staticMethod() {
        System.out.println("这是一个静态方法");
    }

    public static void main(String[] args) {
        // 调用静态方法
        MyClass.staticMethod();
    }
}

 

3. 静态块（Static Blocks）
静态块是在类加载时执行的一段代码块，通常用于初始化静态变量。静态块只能访问静态成员。

public class MyClass {
    // 静态变量
    static int staticVar;

    // 静态块
    static {
        staticVar = 10;
        System.out.println("静态块执行");
    }

    public static void main(String[] args) {
        System.out.println("静态变量的值： " + staticVar);
    }
}

 

4. 静态内部类（Static Nested Classes）
静态内部类是定义在另一个类内部的静态类。它可以访问外部类的静态成员，但不能访问非静态成员。

public class OuterClass {
    // 静态变量
    static int outerVar = 10;

    // 静态内部类
    static class InnerClass {
        void display() {
            System.out.println("外部类的静态变量值： " + outerVar);
        }
    }

    public static void main(String[] args) {
        // 创建静态内部类的实例并调用方法
        InnerClass inner = new InnerClass();
        inner.display();
    }
}

 

5. 静态导入（Static Imports）
静态导入允许我们直接使用静态成员，而无需通过类名或对象引用。这可以减少代码冗余。

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

public class MyClass {
    public static void main(String[] args) {
        // 直接使用静态导入的成员
        double area = PI * sqrt(100);
        System.out.println("圆的面积： " + area);
    }
}

 

6. 静态工厂方法（Static Factory Methods）
静态工厂方法是一种创建对象的设计模式，它提供了一种更简洁的方式来创建对象。静态工厂方法通常返回一个接口类型的实例，而不是具体的实现类。

public interface Animal {
    void speak();
}

public class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("Woof!");
    }
}

public class Cat implements Animal {
    @Override
    public void speak() {
        System.out.println("Meow!");
    }
}

public class AnimalFactory {
    public static Animal createAnimal(String type) {
        if (type.equalsIgnoreCase("dog")) {
            return new Dog();
        } else if (type.equalsIgnoreCase("cat")) {
            return new Cat();
        } else {
            throw new IllegalArgumentException("Invalid animal type");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = AnimalFactory.createAnimal("dog");
        dog.speak(); // 输出： Woof!
        
        Animal cat = AnimalFactory.createAnimal("cat");
        cat.speak(); // 输出： Meow!
    }
}