#头条创作挑战赛#

静态变量：

声明静态变量时，在内存中只有一个副本，所有实例共享该变量。

class MyClass {
    static int staticVariable = 10;
}

System.out.println(MyClass.staticVariable);

静态方法：

声明静态方法时，可以直接通过类名调用，无需实例化对象。

class MyClass {
    static void staticMethod() {
        System.out.println("Static method");
    }
}

MyClass.staticMethod();

静态代码块：

静态代码块在类加载时执行，用于初始化静态变量或执行一些静态操作。

class MyClass {
    static {
        System.out.println("Static block");
    }
}

MyClass instance = new MyClass(); // 输出：Static block

静态内部类：

静态内部类是定义在外部类中的静态类，不依赖外部类的实例。

class OuterClass {
    static class StaticInnerClass {
        void printMessage() {
            System.out.println("Static inner class");
        }
    }
}

OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
staticInner.printMessage();

静态导入：

使用静态导入可以直接使用类的静态成员，无需使用类名前缀。

import static java.lang.Math.PI;

double radius = 3.0;
double area = PI * radius * radius;

静态常量：

声明静态常量时，使用final关键字修饰，值在编译时确定，不可修改。

class MyClass {
    static final int CONSTANT = 100;
}

System.out.println(MyClass.CONSTANT);

静态内部接口：

内部接口可以声明为静态，可以直接通过外部类访问。

class OuterClass {
    static interface InnerInterface {
        void printMessage();
    }
}

OuterClass.InnerInterface inner = new OuterClass.InnerInterface() {
    @Override
    public void printMessage() {
        System.out.println("Inner interface");
    }
};

inner.printMessage();

静态成员类：

静态成员类是定义在外部类中的静态类，可以直接通过外部类访问。

class OuterClass {
    static class StaticMemberClass {
        void printMessage() {
            System.out.println("Static member class");
        }
    }
}

OuterClass.StaticMemberClass staticMember = new OuterClass.StaticMemberClass();
staticMember.printMessage();

静态工厂方法：

静态工厂方法是一种创建对象的方法，可以通过类名直接调用，无需关心具体实现。

class MyClass {
    private MyClass() {
        // 私有构造函数
    }

    static MyClass createInstance() {
        return new MyClass();
    }
}

MyClass instance = MyClass.createInstance();

静态变量初始化块：

静态变量初始化块在类加载时执行，用于初始化静态变量。

class MyClass {
    static int staticVariable;

    static {
        staticVariable = 10;
    }
}

System.out.println(MyClass.staticVariable);

静态内部枚举：

内部枚举可以声明为静态，可以直接通过外部类访问。

class OuterClass {
    static enum InnerEnum {
        VALUE1, VALUE2
    }
}

OuterClass.InnerEnum value = OuterClass.InnerEnum.VALUE1;

静态成员初始化块：

静态成员初始化块在类加载时执行，用于初始化静态成员。

class MyClass {
    static int staticVariable;
    int instanceVariable;

    {
        instanceVariable = 20;
    }

    static {
        staticVariable = 10;
    }
}

System.out.println(MyClass.staticVariable);

静态内部注解：

内部注解可以声明为静态，可以直接通过外部类访问。

class OuterClass {
    static @interface InnerAnnotation {
        String value() default "";
    }
}

OuterClass.InnerAnnotation annotation = new OuterClass.InnerAnnotation() {
    @Override
    public String value() {
        return "Inner annotation";
    }
};

System.out.println(annotation.value());

静态初始化块：

静态初始化块在类加载时执行，用于初始化静态变量或执行一些静态操作。

class MyClass {
    static int staticVariable;

    static {
        staticVariable = 10;
    }
}

System.out.println(MyClass.staticVariable);

静态嵌套类：

静态嵌套类是定义在另一个类中的静态类，与外部类没有直接关联。

class OuterClass {
    static class StaticNestedClass {
        void printMessage() {
            System.out.println("Static nested class");
        }
    }
}

OuterClass.StaticNestedClass staticNested = new OuterClass.StaticNestedClass();
staticNested.printMessage();