三分钟搞懂Java修饰符：你不知道的用法和技巧！

Hello，大家好！今天我们来聊一聊Java中的修饰符。这些小东西在Java编程中可是非常重要的。

别担心，虽然听起来有点复杂，但掌握它们其实很简单。接下来，用三分钟时间带你搞懂Java修饰符！

什么是修饰符？

修饰符是一些关键字，用来修饰类、方法、变量等，使它们具有特定的访问权限或行为。

在Java中，修饰符分为两大类：访问修饰符和非访问修饰符。

访问修饰符

1. public：公开的，任何地方都可以访问。

2. protected：受保护的，同一个包或者子类可以访问。

3. default（默认的，不写修饰符）：包级私有的，同一个包内可以访问。

4. private：私有的，只有本类可以访问。

非访问修饰符

1. static：静态的，属于类而不是实例。

2. final：最终的，不能被修改或继承。

3. abstract：抽象的，不能实例化，需要子类实现。

4. synchronized：同步的，常用于线程控制。

访问修饰符实例

Public和Private的使用

public class AccessModifierExample {
    public String publicVar = "我是public的";
    private String privateVar = "我是private的";

    public void showPublic() {
        System.out.println(publicVar);
    }

    private void showPrivate() {
        System.out.println(privateVar);
    }

    public static void main(String[] args) {
        AccessModifierExample example = new AccessModifierExample();
        example.showPublic();
        // example.showPrivate(); // 这行会报错，因为showPrivate是私有的
    }
}

运行结果：

我是public的

在这个例子中，publicVar和showPublic是公开的，所以可以在类外访问，而privateVar和showPrivate是私有的，只能在类内访问。

非访问修饰符实例

Static的使用

public class StaticExample {
    public static int staticVar = 42;

    public static void staticMethod() {
        System.out.println("我是静态方法");
    }

    public static void main(String[] args) {
        System.out.println(StaticExample.staticVar);
        StaticExample.staticMethod();
    }
}

运行结果：

42
我是静态方法

static修饰符使得变量和方法属于类，而不是类的实例。所以，可以直接通过类名访问。

Final的使用

public class FinalExample {
    public final int finalVar = 100;

    public final void finalMethod() {
        System.out.println("我是最终方法");
    }

    public static void main(String[] args) {
        FinalExample example = new FinalExample();
        System.out.println(example.finalVar);
        example.finalMethod();
    }
}

运行结果：

100
我是最终方法

final修饰符使得变量的值不可改变，方法不可被重写。

Synchronized的使用

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();

        Thread t1 = new Thread(example::increment);
        Thread t2 = new Thread(example::increment);

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("最终计数: " + example.getCount());
    }
}

运行结果可能为：

最终计数: 2

synchronized确保同一时间只有一个线程可以访问方法，避免线程安全问题。

总结

今天我们快速了解了Java中的各种修饰符及其用法。修饰符虽然简单，但在实际开发中却有着非常重要的作用。

希望通过今天的学习，你能更好地使用它们，提高代码的安全性和可维护性。关注订阅，下次见，Happy Coding！