Java中 static 关键字相关的用法

goTsHgo

已于 2024-08-21 14:09:13 修改

阅读量895

点赞数 9

分类专栏： Java basic 文章标签： java 开发语言

于 2024-08-21 09:32:04 首次发布

本文链接：https://blog.csdn.net/goTsHgo/article/details/141364113

版权

Java basic 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

在Java中，static关键字用于声明类的静态成员（包括属性、方法、代码块和嵌套类）。它们与类本身相关，而不是与类的实例相关。下面详细解释static关键字在不同上下文中的使用方法及其相关概念。

1. 静态属性

1.1 定义与概念

静态属性（也称为类属性）是属于类本身的变量，而不是类的某个实例的变量。这意味着，无论创建多少个类的实例，静态属性都只有一个副本，所有实例共享这一副本。

1.2 使用方式

定义:

public class MyClass { 
    public static int counter = 0; 
}

访问:
- 通过类名访问：MyClass.counter
- 通过实例访问：instance.counter（不推荐，容易引发混淆）

1.3 初始化时机

静态属性在类加载时初始化。类加载发生在以下情况之一：

创建类的第一个实例时
调用类的第一个静态方法时
访问类的第一个静态属性时
使用反射机制访问类时

1.4 特殊注意事项

线程安全问题: 由于静态属性是全局共享的，因此在多线程环境中，如果多个线程同时修改静态属性，可能会产生线程安全问题。可以使用 synchronized关键字或其他同步机制来保护静态属性。
内存管理: 静态属性在JVM的**方法区（或元空间）**中存储，并在类卸载时才会被垃圾回收。因此，滥用静态属性可能会导致内存泄漏。

2. 静态方法

2.1 定义与概念

静态方法是属于类而不是类实例的方法。它们只能访问静态属性和静态方法，不能访问实例属性或实例方法。

2.2 使用方式

定义:

public class MyClass {
    public static void printMethod() { 
        System.out.println("我是一个静态方法！"); 
    } 
}

调用:
- 通过类名调用：MyClass.printMethod()
- 通过实例调用：instance.printMethod()（不推荐，容易引发混淆）

2.3 特殊注意事项

不能访问实例成员: 静态方法无法访问实例属性或实例方法，因为它们不依赖于类的任何实例。
静态方法中的this关键字: 在静态方法中，不能使用this关键字，因为this代表的是类的当前实例，而静态方法与实例无关。

3. 静态代码块

3.1 定义与概念

静态代码块是类中的一段代码，它会在类加载时自动执行。它通常用于类的初始化工作，如静态属性的初始化。

3.2 使用方式

定义:

public class MyClass {
    static { // 静态代码块 
        counter = 10; 
        System.out.println("Static block executed."); 
    } 
}

3.3 初始化时机

静态代码块在类加载时按顺序执行。如果一个类有多个静态代码块，它们会按照在代码中出现的顺序依次执行。

3.4 特殊注意事项

执行顺序: 静态代码块的执行顺序严格按照代码中的顺序执行，且优先于构造函数和实例代码块。
初始化复杂逻辑: 静态代码块非常适合用于复杂的静态属性初始化或执行依赖性较强的初始化逻辑。

4. 静态类

4.1 定义与概念

在Java中，静态类通常指的是静态嵌套类（Static Nested Class），即定义在另一个类中的静态类。静态嵌套类不持有外部类的实例引用。

4.2 使用方式

定义:

public class OuterClass {
    public static class NestedStaticClass {
        public void display() {
            System.out.println("Inside static nested class.");
        }
    }
}

实例化与调用:

OuterClass.NestedStaticClass nested = new OuterClass.NestedStaticClass();
nested.display();

4.3 特殊注意事项

不依赖外部类实例: 静态嵌套类可以直接访问外部类的静态属性和方法，但不能直接访问外部类的实例成员。
与非静态嵌套类的区别: 非静态嵌套类（内部类）需要通过外部类的实例来访问，而静态嵌套类不需要。

5. 共性规律与特殊技巧

5.1 共性规律

与类关联而非实例: static关键字声明的成员（属性、方法、代码块、类）都是与类本身相关，而非某个具体的实例。这使得它们能够在没有创建类的实例时也可以使用。
类加载时初始化: 所有静态成员都在类加载时初始化。这意味着它们的生命周期伴随类的生命周期。

5.2 特殊技巧

静态工厂方法: 静态方法常用于实现工厂模式，提供实例化对象的统一入口。例如 java.util.Collections 中的各种静态工厂方法。

单例模式: 静态属性与静态方法经常用于实现单例模式（Singleton Pattern），以确保一个类只有一个实例。

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

静态导入: 使用 import static 可以直接导入类的静态成员，使得代码更加简洁。比如：

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
            System.out.println(sqrt(16)); // 不需要 Math.sqrt(16) 
    } 
}

5.3 注意事项

静态方法的局限性: 静态方法不能被子类覆盖（Override），只能被隐藏（Hidden），这意味着多态性在静态方法中无法发挥作用。
过度使用静态可能导致设计不良: 过度依赖静态属性或方法会导致类之间的耦合性增加，降低代码的可维护性和可扩展性。因此，应当谨慎使用static关键字，特别是在大型项目中。

6. static关键字与其他关键字配合使用

在Java中，static关键字可以与其他关键字配合使用，以实现更复杂的功能和设计模式。这些组合在不同的场景中具有不同的含义和用途。以下是Java中static关键字与其他关键字的主要组合及其适用场景：

6.1. static + final

6.1.1 概念与定义

static final 变量: 当一个属性同时被声明为static和final时，它被称为常量。这意味着它是类级别的（static）且不可变的（final）。
static final 方法: 不可组合。因为final用于防止方法被子类重写，而static方法本身不能被重写。

6.1.2 使用方式

静态常量:

public class MyClass {
    public static final int MAX_VALUE = 100;
}

6.1.3 适用场景

定义常量: static final常用于定义常量，特别是在全局需要共享的情况下。例如，数学常量PI，数据库连接配置参数等。
性能优化: 由于static final变量在编译时就确定了值，可以被编译器进行内联，从而提高性能。

6.1.4 注意事项

必须在声明时初始化: static final变量必须在声明时进行初始化，或者在静态初始化块中进行初始化。

6.2. static + synchronized

6.2.1 概念与定义

static synchronized 方法: 当一个方法被声明为static synchronized时，意味着在同一时间只能有一个线程访问该类的这个静态方法。

6.2.2 使用方式

定义静态同步方法:

public class MyClass {
    public static synchronized void incrementCounter() {
        // 操作共享的静态变量
    }
}

6.2.3 适用场景

线程安全的静态方法: 当你需要确保多个线程在同一时间只能访问某个静态方法时，这种组合很有用。典型场景包括单例模式的延迟初始化（Lazy Initialization）和操作共享的静态资源（如文件、数据库连接等）。

6.2.4 注意事项

类级别锁: static synchronized方法会锁住整个类的Class对象，而不仅仅是实例。这可能会导致其他同步静态方法也被阻塞，因此需要小心使用，避免影响系统性能。

6.3. static + abstract

6.3.1 概念与定义

static abstract 组合: 在Java中，static和abstract不能同时修饰方法。这是因为abstract方法必须由子类实现，而static方法是与类本身相关的，不能被重写或实现。

6.3.2 适用场景

无效组合: 这种组合在Java中是无效的，无法使用。

6.4. static + volatile

6.4.1 概念与定义

static volatile 变量: 这是一个同时具有类级别共享性和可见性保证的变量。volatile保证了对该变量的修改对所有线程是可见的。

6.4.2 使用方式

定义静态易失变量:

public class MyClass {
    private static volatile int counter = 0;
}

6.4.3 适用场景

双重检查锁定（Double-Checked Locking）: 在实现线程安全的单例模式时，static volatile常用于保证在多线程环境下对象的唯一性。

public class Singleton {  
    private static volatile Singleton instance;  
    private Singleton() {}  
    public static Singleton getInstance() {    
        if(instance == null) {      
            synchronized(Singleton.class) {        
                if(instance == null) {          
                    instance = new Singleton();        
                }      
            }    
        }    
        return instance;  
    }
}

6.4.4 注意事项

保证可见性: volatile保证变量的可见性，但不保证原子性。如果需要保证操作的原子性，仍然需要使用同步机制。

6.5. static + inner class

6.5.1 概念与定义

static 嵌套类（静态内部类）: 静态内部类是定义在另一个类中的静态类。它与外部类的实例无关，因此不持有外部类的引用。

6.5.2 使用方式

定义静态嵌套类:

public class OuterClass {
    public static class NestedStaticClass {
        public void display() {
            System.out.println("Inside static nested class.");
        }
    }
}

实例化静态嵌套类:

OuterClass.NestedStaticClass nested = new OuterClass.NestedStaticClass();
nested.display();

6.5.3 适用场景

工具类和辅助类: 静态嵌套类适用于工具类、辅助类或逻辑上隶属于外部类但不依赖外部类实例的场景。例如，定义一个外部类的常量集合或静态方法的辅助类。
单例模式: 静态内部类也常用于实现单例模式中的延迟加载（Lazy Initialization）。

6.5.4 注意事项

独立性: 静态嵌套类独立于外部类的实例，因此它不能直接访问外部类的实例成员。

6.6. static + interface (Java 8+)

6.6.1 概念与定义

static 方法在接口中: 从Java 8开始，接口可以包含静态方法。静态方法在接口中是与接口关联的，而不是与实现类关联。

6.6.2 使用方式

定义接口中的静态方法:

public interface MyInterface {
    static void staticMethod() {
        System.out.println("Static method in interface");
    }
}

调用接口中的静态方法:

MyInterface.staticMethod();

6.6.3 适用场景

提供接口工具方法: 接口中的静态方法通常用于提供与接口相关的工具方法或辅助功能。例如，接口可以提供默认的实现方法或创建某些对象的静态工厂方法。

6.6.4 注意事项

无法被实现类覆盖: 接口中的静态方法不能被实现类覆盖，因为它们与接口本身关联，而不是与接口的实现类关联。

6.7. static + enum

6.7.1 概念与定义

static 方法和属性在enum中: enum可以包含静态方法和静态属性，且这些方法和属性与enum类型关联。

6.7.2 使用方式

定义静态方法和属性在enum中:

public enum Day {
    SUNDAY, MONDAY, TUESDAY;

    private static final String GREETING = "Hello";

    public static void printGreeting() {
        System.out.println(GREETING);
    }
}

调用enum中的静态方法:

Day.printGreeting();

6.7.3 适用场景

工具方法和常量: 在enum中定义与枚举类型相关的工具方法和常量非常常见。例如，可以定义一个静态方法用于解析字符串为枚举值，或者提供与枚举常量相关的共享信息。

6.7.4 注意事项

与枚举常量独立: static成员与枚举常量无关，因此它们不会因枚举常量的变化而改变。

6.8. 综合使用场景与注意事项

6.8.1 设计模式

单例模式: 静态属性和静态方法常用于实现单例模式，确保一个类在JVM中只有一个实例。结合volatile和 synchronized，可以实现线程安全的懒加载单例模式。
工厂模式: 静态方法常用于实现工厂模式，提供一种创建对象的统一入口。例如，通过静态工厂方法根据参数创建不同的实例。

6.8.2 工具类

工具类设计: 静态方法通常用于设计工具类（Utility Class），这些类通常不需要实例化。例如，java.lang.Math和java.util.Collections等工具类中包含大量的静态方法。

6.8.3 内存管理与性能优化

内存消耗: 静态变量由于其生命周期与类的生命周期相同，在应用程序运行期间一直占用内存。因此，滥用静态变量可能导致内存泄漏。
性能优化: 静态常量在编译时就确定了值，可以被编译器内联，从而提升代码执行性能。

6.8.4 并发与线程安全

类级别锁: 使用static synchronized方法时需要注意，它会锁住整个类，从而影响其他静态同步方法的并发性。
通过这些组合使用，Java开发者可以更加灵活和高效地设计应用程序，实现更优雅的代码结构和更强大的功能。

7. 常见笔试题

1、下面这段代码的输出结果是什么？

public class Test extends Base {
    static {
        System.out.println("test static");
    }
    public Test() {
        System.out.println("test constructor");
    }
    public static void main(String[] args) {
        new Test();
    }
}
class Base {
    static {
        System.out.println("base static");
    }
    public Base() {
        System.out.println("base constructor");
    }
}

输出结果为：

base static
test static
base constructor
test constructor

分析下这段代码的执行过程：

找到main方法入口，main方法是程序入口，但在执行main方法之前，要先加载Test类
加载Test类的时候，发现Test类继承Base类，于是先去加载Base类
加载Base类的时候，发现Base类有static块，而是先执行static块，输出base static结果
Base类加载完成后，再去加载Test类，发现Test类也有static块，而是执行Test类中的static块，输出test static结果
Base类和Test类加载完成后，然后执行main方法中的new Test()，调用子类构造器之前会先调用父类构造器
调用父类构造器，输出base constructor结果
然后再调用子类构造器，输出test constructor结果

2、这段代码的输出结果是什么？

public class Test {
    Person person = new Person("Test");
    static {
        System.out.println("test static");
    }
    public Test() {
        System.out.println("test constructor");
    }
    public static void main(String[] args) {
        new MyClass();
    }
}
class Person {
    static {
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person " + str);
    }
}
class MyClass extends Test {
    Person person = new Person("MyClass");
    static {
        System.out.println("myclass static");
    }
    public MyClass() {
        System.out.println("myclass constructor");
    }
}

输出结果为：

test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor

这段代码的执行过程：

找到main方法入口，main方法是程序入口，但在执行main方法之前，要先加载Test类
加载Test类的时候，发现Test类有static块，而是先执行static块，输出test static结果
然后执行new MyClass(),执行此代码之前，先加载MyClass类，发现MyClass类继承Test类，而是要先加载Test类，Test类之前已加载
加载MyClass类，发现MyClass类有static块，而是先执行static块，输出myclass static结果
然后调用MyClass类的构造器生成对象，在生成对象前，需要先初始化父类Test的成员变量，而是执行Person person = new Person("Test")代码，发现Person类没有加载
加载Person类，发现Person类有static块，而是先执行static块，输出person static结果
接着执行Person构造器，输出person Test结果
然后调用父类Test构造器，输出test constructor结果，这样就完成了父类Test的初始化了
再初始化MyClass类成员变量，执行Person构造器，输出person MyClass结果
最后调用MyClass类构造器，输出myclass constructor结果，这样就完成了MyClass类的初始化了

3、这段代码的输出结果是什么？

public class Test {
    static {
        System.out.println("test static 1");
    }
    public static void main(String[] args) {}
    static {
        System.out.println("test static 2");
    }
}

输出结果为：

test static 1
test static 2

虽然在main方法中没有任何语句，但是还是会输出。

通过掌握static关键字的使用，你可以更好地设计和组织Java类，确保代码在性能、可维护性和功能性之间取得平衡。

goTsHgo

关注

9
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java中 static 关键字相关的用法

静态属性（也称为类属性）是属于类本身的变量，而不是类的某个实例的变量。这意味着，无论创建多少个类的实例，静态属性都只有一个副本，所有实例共享这一副本。静态方法是属于类而不是类实例的方法。它们只能访问静态属性和静态方法，不能访问实例属性或实例方法。静态代码块是类中的一段代码，它会在类加载时自动执行。它通常用于类的初始化工作，如静态属性的初始化。在Java中，静态类通常指的是静态嵌套类（Static Nested Class），即定义在另一个类中的静态类。静态嵌套类不持有外部类的实例引用。
复制链接

扫一扫

专栏目录