static关键字的用法和作用

最新推荐文章于 2024-10-02 20:11:58 发布

极客李华

最新推荐文章于 2024-10-02 20:11:58 发布

阅读量1.9k

点赞数 27

分类专栏： 100道Java后端大厂面试题详解文章标签： java

本文链接：https://blog.csdn.net/qq_51447496/article/details/136060619

版权

100道Java后端大厂面试题详解专栏收录该内容

17 篇文章 5 订阅

订阅专栏

static关键字的用法和作用

作者简介：一名后端开发人员，每天分享后端开发以及人工智能相关技术，行业前沿信息，面试宝典。
座右铭：未来是不可确定的，慢慢来是最快的。
个人主页：极客李华-CSDN博客
合作方式：私聊+
这个专栏内容：BAT等大厂常见后端java开发面试题详细讲解，更新数目100道常见大厂java后端开发面试题。
我的CSDN社区：https://bbs.csdn.net/forums/99eb3042821a4432868bb5bfc4d513a8
微信公众号，抖音，b站等平台统一叫做：极客李华，加入微信公众号领取各种编程资料，加入抖音，b站学习面试技巧，职业规划

讲解static关键字的用法和作用

1. 什么是static关键字？

在Java中，static 是一个关键字，用于声明静态成员。静态成员属于类，而不属于类的任何实例。当类被加载时，静态成员就会被初始化，并且在整个程序的生命周期内只会被初始化一次。

2. static关键字的用法

static 关键字可以用于以下几个方面：

静态变量（类变量）： 用于声明类级别的变量，所有类的实例共享这个变量。
静态方法（类方法）： 用于声明类级别的方法，可以直接通过类名调用，无需创建类的实例。
静态代码块： 用于在类被加载时执行一次性的初始化操作。
静态内部类： 用于声明一个嵌套的静态类，该类与外部类的实例无关，可以直接通过外部类名访问。

3. 静态变量的示例

静态变量是所有类的实例共享的，修改一个类的实例的静态变量会影响到其他所有实例。下面是一个示例：

public class Counter {
    // 静态变量，用于记录创建了多少个实例
    public static int count = 0;

    public Counter() {
        count++; // 每次创建实例时，计数器加一
    }

    public static void main(String[] args) {
        Counter c1 = new Counter();
        System.out.println("Counter.count after creating c1: " + Counter.count);

        Counter c2 = new Counter();
        System.out.println("Counter.count after creating c2: " + Counter.count);

        Counter c3 = new Counter();
        System.out.println("Counter.count after creating c3: " + Counter.count);
    }
}

在这里插入图片描述

4. 静态方法的示例

静态方法可以直接通过类名调用，无需创建类的实例。例如：

public class MathUtil {
    /**
     * 计算阶乘的静态方法
     * @param n 非负整数
     * @return n的阶乘
     */
    public static int factorial(int n) {
        // 如果n小于等于1，阶乘为1
        if (n <= 1) {
            return 1;
        }
        // 递归调用计算阶乘
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        int num = 5;
        // 调用静态方法计算阶乘
        int result = factorial(num);
        // 输出计算结果
        System.out.println(num + "的阶乘是：" + result);
    }
}

在这里插入图片描述

5. 静态代码块的示例

静态代码块用于在类加载时执行一次性的初始化操作。例如：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnection {
    // 数据库连接对象
    private static Connection connection;

    // 数据库连接URL
    private static final String DB_URL = "jdbc:mysql://localhost:3306/mydatabase";

    // 数据库用户名
    private static final String USER = "username";

    // 数据库密码
    private static final String PASS = "password";

    // 静态代码块，在类加载时执行
    static {
        try {
            // 加载数据库驱动程序，这里会在类加载时执行
            Class.forName("com.mysql.jdbc.Driver");
            // 建立数据库连接
            connection = DriverManager.getConnection(DB_URL, USER, PASS);
            System.out.println("数据库连接成功！");
        } catch (ClassNotFoundException e) {
            System.err.println("数据库驱动程序加载失败：" + e.getMessage());
        } catch (SQLException e) {
            System.err.println("数据库连接失败：" + e.getMessage());
        }
    }

    // 获取数据库连接对象的静态方法
    public static Connection getConnection() {
        return connection;
    }

    // 关闭数据库连接的静态方法
    public static void closeConnection() {
        if (connection != null) {
            try {
                connection.close();
                System.out.println("数据库连接已关闭！");
            } catch (SQLException e) {
                System.err.println("关闭数据库连接时发生错误：" + e.getMessage());
            }
        }
    }

    public static void main(String[] args) {
        // 获取数据库连接对象
        Connection conn = DatabaseConnection.getConnection();

        // 在这里可以使用连接进行数据库操作...

        // 关闭数据库连接
        DatabaseConnection.closeConnection();
    }
}

根据上述代码中的静态代码块和主方法，可以预测以下结果：

在 main 方法中，首先会调用 getConnection() 方法获取数据库连接对象。
在调用 getConnection() 方法时，会触发静态代码块的执行，静态代码块中的内容会被执行，包括加载数据库驱动程序和建立数据库连接。
如果数据库驱动加载成功并且连接建立成功，会输出 “数据库连接成功！”。
如果数据库驱动加载失败或连接建立失败，会输出相应的错误信息。
在 main 方法中，如果连接成功，可以在注释处进行数据库操作。
最后调用 closeConnection() 方法关闭数据库连接，如果关闭成功，会输出 “数据库连接已关闭！”。

根据代码逻辑和预测，如果一切正常，预计会看到以下输出：

数据库连接成功！
数据库连接已关闭！

这表示数据库连接建立成功，并且在使用完成后被正确关闭。

6. 静态内部类的示例

静态内部类是声明在另一个类内部的类，它可以拥有自己的静态变量、静态方法等。例如：

public class OuterClass {
    // 静态内部类
    static class InnerClass {
        // 静态内部类的静态方法
        static void display() {
            System.out.println("静态内部类的静态方法");
        }
    }

    // 外部类的静态方法
    static void outerMethod() {
        System.out.println("外部类的静态方法");
    }

    public static void main(String[] args) {
        // 调用静态内部类的静态方法
        InnerClass.display();

        // 调用外部类的静态方法
        outerMethod();
    }
}

在这里插入图片描述

静态关键字的应用场景

1. 单例模式

静态关键字常用于实现单例模式，确保整个应用程序中只有一个实例存在。通过将构造函数私有化，然后提供一个静态方法返回该类的唯一实例。

public class Singleton {
    // 私有静态变量，用于保存唯一实例
    private static Singleton instance;

    // 私有构造方法，防止外部直接实例化
    private Singleton() {}

    // 公共静态方法，返回唯一实例
    public static Singleton getInstance() {
        // 使用双重检查锁定确保线程安全
        if (instance == null) {
            synchronized (Singleton.class) {
                // 再次检查实例是否为null，确保只有一个线程能够创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // main 方法用于测试单例模式
    public static void main(String[] args) {
        // 获取单例对象
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        // 判断两个对象是否相同
        if (singleton1 == singleton2) {
            System.out.println("两个对象是同一个实例，单例模式生效！");
        } else {
            System.out.println("单例模式失败，存在多个实例！");
        }
    }
}

私有构造方法：单例模式的第一步是将类的构造方法设置为私有，这样外部就无法直接通过 new 关键字来实例化对象。在这个例子中，private Singleton() {} 就是私有构造方法。

静态变量保存唯一实例：单例模式需要一个静态变量来保存唯一实例。在这个例子中，private static Singleton instance; 声明了一个私有的静态变量 instance，用于保存唯一的 Singleton 实例。

静态方法获取实例：提供一个公共的静态方法来获取该类的实例。在这个例子中，public static Singleton getInstance() 就是获取实例的静态方法。这个方法中实现了双重检查锁定，确保在多线程环境下只有一个实例被创建。

双重检查锁定（Double-Checked Locking）：双重检查锁定是为了在多线程环境下提高性能。首先检查实例是否为 null，如果为 null，则进入同步块，再次检查实例是否为 null，然后再创建实例。这样可以避免多个线程同时进入同步块创建实例。

为什么使用 static 关键字：在这个例子中，静态关键字 static 用来声明静态变量 instance 和静态方法 getInstance()。静态变量被所有的对象所共享，因此它可以用来保存唯一的实例。静态方法属于类，可以直接通过类名调用，无需创建类的实例。因此，我们可以通过 Singleton.getInstance() 来获取 Singleton 类的唯一实例。
在这里插入图片描述

2. 工具类

静态方法通常用于工具类，这些方法与类的实例无关，通过类名直接调用。例如 java.lang.Math 类中的数学函数就是静态方法。

public class MathUtil {
    // 私有构造方法，防止外部实例化
    private MathUtil() {}

    /**
     * 计算两个整数的最大公约数
     * @param a 整数a
     * @param b 整数b
     * @return 最大公约数
     */
    public static int gcd(int a, int b) {
        while (b != 0) {
            int temp = b;
            b = a % b;
            a = temp;
        }
        return a;
    }

    /**
     * 计算两个整数的最小公倍数
     * @param a 整数a
     * @param b 整数b
     * @return 最小公倍数
     */
    public static int lcm(int a, int b) {
        return a * b / gcd(a, b);
    }

    public static void main(String[] args) {
        int num1 = 12;
        int num2 = 18;

        // 计算最大公约数和最小公倍数
        int gcdResult = gcd(num1, num2);
        int lcmResult = lcm(num1, num2);

        // 输出结果
        System.out.println("最大公约数：" + gcdResult);
        System.out.println("最小公倍数：" + lcmResult);
    }
}

在这里插入图片描述

3. 常量

静态变量通常用于声明常量，例如 java.awt.Color 类中的常量，如 Color.RED，Color.GREEN 等。

public class Constants {
    // 私有构造方法，防止外部实例化
    private Constants() {}

    // 定义常量
    public static final int MAX_SIZE = 100;
    public static final double PI = 3.14159265358979323846;
    public static final String DEFAULT_NAME = "John Doe";

    public static void main(String[] args) {
        // 输出常量值
        System.out.println("最大尺寸：" + MAX_SIZE);
        System.out.println("圆周率：" + PI);
        System.out.println("默认名称：" + DEFAULT_NAME);
    }
}

在这里插入图片描述

4. 计数器

静态变量常用于实现计数器功能，例如记录某个类的实例被创建的次数。

public class Counter {
    // 静态变量，用于记录实例被创建的次数
    private static int count = 0;

    // 私有构造方法，防止外部直接实例化
    private Counter() {
        count++; // 每次创建实例时增加计数
    }

    // 静态方法，获取实例创建次数
    public static int getCount() {
        return count;
    }

    public static void main(String[] args) {
        // 创建多个实例
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();

        // 输出实例创建次数
        System.out.println("实例创建次数：" + Counter.getCount());
    }
}

在这里插入图片描述

5. 数据库连接池

在数据库连接池中，常使用静态变量来保存连接池实例，确保整个应用程序中只有一个数据库连接池存在。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class ConnectionPool {
    // 静态变量，用于保存数据库连接池实例
    private static ConnectionPool instance;

    // 数据库连接列表
    private List<Connection> connections = new ArrayList<>();

    // 数据库连接池大小
    private static final int POOL_SIZE = 10;

    // 私有构造方法，防止外部直接实例化
    private ConnectionPool() {
        // 初始化数据库连接池
        for (int i = 0; i < POOL_SIZE; i++) {
            try {
                Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
                connections.add(connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    // 静态方法，获取数据库连接池实例
    public static synchronized ConnectionPool getInstance() {
        if (instance == null) {
            instance = new ConnectionPool();
        }
        return instance;
    }

    // 获取数据库连接
    public synchronized Connection getConnection() throws SQLException {
        if (connections.isEmpty()) {
            throw new SQLException("连接池已耗尽");
        }
        return connections.remove(0);
    }

    // 将连接放回连接池
    public synchronized void releaseConnection(Connection connection) {
        connections.add(connection);
    }

    public static void main(String[] args) {
        try {
            // 获取数据库连接池实例
            ConnectionPool pool = ConnectionPool.getInstance();

            // 从连接池获取连接
            Connection conn1 = pool.getConnection();
            Connection conn2 = pool.getConnection();

            // 使用连接...

            // 将连接放回连接池
            pool.releaseConnection(conn1);
            pool.releaseConnection(conn2);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

这段代码实现了一个简单的数据库连接池。让我们逐步解释其编写思路以及适用场景：

静态变量保存实例： 使用静态变量 instance 来保存数据库连接池的实例，确保整个应用程序中只有一个数据库连接池存在。这样的设计可以避免在不同的地方创建多个连接池，保证连接池的单例性。
数据库连接列表： 使用一个列表 connections 来保存数据库连接。这个列表中的元素是 Connection 类型的对象，代表一个数据库连接。
数据库连接池大小： 通过常量 POOL_SIZE 来指定数据库连接池的大小。在这个示例中，连接池的大小为10。
私有构造方法： 类的构造方法被私有化，这样外部就无法直接实例化连接池对象，只能通过静态方法 getInstance() 来获取连接池的实例。
初始化连接池： 在连接池被实例化时，会初始化指定数量的数据库连接，并添加到连接池中。这样在应用程序启动时就会创建预设数量的数据库连接，提高了效率。
获取连接和释放连接： getConnection() 方法用于从连接池中获取连接，如果连接池为空则抛出异常。releaseConnection() 方法用于将连接放回连接池。
适用场景： 这样的数据库连接池适用于需要频繁地与数据库交互的应用程序。通过维护一个连接池，可以减少因为频繁地创建和销毁连接而产生的开销，提高了数据库访问的效率和性能。特别是在并发访问量较高的情况下，连接池可以有效地管理数据库连接，避免连接过多导致资源浪费或者数据库连接过少导致请求阻塞的情况发生。