一篇文章带你入门Java修饰符

Java中修饰符是控制访问权限和类、变量和方法行为的关键字。在Java中，共有四类修饰符：访问修饰符、非访问修饰符、类修饰符和方法修饰符。接下来将详细介绍这四类修饰符以及它们的使用规范。

一、访问修饰符

访问修饰符	含义
public	所有类可见
protected	同一包内和子类可见
private	仅本类可见
没有修饰符	同一包内可见

使用规范

1. 类成员变量和方法通常使用私有（private）访问修饰符；
2. 向外暴露接口的方法使用公共（public）访问修饰符；
3. 继承和使用多态时，使用受保护（protected）访问修饰符。

示例1

public class Example1 {
    private int a; // 私有成员变量a

    public void setA(int a) { // 公共方法setA
        this.a = a;
    }

    public int getA() { // 公共方法getA
        return a;
    }
}

在上面的例子中，成员变量a使用私有（private）访问修饰符，而setA和getA方法使用公共（public）访问修饰符。这样做的目的是为了保证类内部的数据安全性，并对外暴露公共接口（setA和getA方法）获取数据。

示例2

package example;

public class Example2 {
    protected int a; // 受保护成员变量a
}

在上面的示例中，成员变量a使用受保护（protected）访问修饰符。因此，在Example2类的子类中（假设Example3为其子类），可以访问a变量，而且在包example中的其他类也可以访问。

二、非访问修饰符

非访问修饰符	含义
static	静态变量和方法
final	常量
abstract	抽象方法
transient	反序列化时不被序列化的变量
volatile	多线程访问变量

使用规范

1. 当多个对象共享某一变量时，使用静态（static）修饰符；
2. 在定义常量时，使用常量（final）修饰符；
3. 当需要在子类中重写方法时，使用抽象（abstract）修饰符；
4. 当需要将对象序列化和反序列化时，使用瞬态（transient）修饰符；
5. 当多个线程需要访问同一变量时，使用易失性（volatile）修饰符。

示例1

public class Example3 {
    private static int count = 0; // 静态变量count

    public Example3() {
        count++; // 每创建一个对象，count值加1
    }

    public static int getCount() { // 静态方法getCount
        return count;
    }
}

在上面的示例中，count变量使用静态（static）修饰符，这样在创建Example3对象时，每次都会自增count的值。同时，getCount方法也使用了静态修饰符，以便于在其他地方获取已经创建对象的数量。

示例2

public class Example4 {
    private final double PI = 3.1415926; // 常量PI

    public double getCircleArea(double r) { // 根据半径计算圆的面积
        return PI * Math.pow(r, 2); // 使用PI常量
    }
}

在上面的示例中，常量PI使用常量（final）修饰符。由于PI是圆周率，其值不可变，因此常量修饰符保证了PI的常量性。同时，在getCircleArea方法中通过PI常量计算圆的面积，这样不仅保证了结果的精确性，也降低了代码维护成本。

三、类修饰符

类修饰符	含义
final	类不能被继承
abstract	抽象类不能被实例化

使用规范

1. 在设计枚举类或单例模式时，使用final修饰符来保证类的唯一性；
2. 在设计基类时，使用抽象（abstract）修饰符来保证衍生类必须实现的方法和属性。

示例1

public final class Example5 {
    private static final Example5 instance = new Example5(); // 单例类

    private Example5() {}

    public static Example5 getInstance() {
        return instance;
    }
}

在上面的示例中，由于Example5类是一个单例模式，其不能被其他类继承。因此需要使用final修饰符来保证类的唯一性。

示例2

public abstract class Example6 {
    public abstract void print(); // 抽象方法，子类必须实现

    public void show() {
        System.out.println("Hello World!");
    }
}

在上面的示例中，由于Example6类是一个基类，其包含一个抽象（abstract）方法print和一个实例方法show。由于print方法是抽象方法，不能被实现，因此需要所有子类来实现print方法，这样保证了程序的稳定性和可扩展性。

四、方法修饰符

方法修饰符	含义
final	不能被重写
abstract	无实现方法的方法

使用规范

1. 对于不需要被继承或修改的方法，可以用final修饰符保证方法不可重写；
2. 对于基类中需要被子类实现的方法，应该使用抽象（abstract）修饰符保证该方法无实现，强制子类实现。

示例1

public class Example7 {
    public final void doSomething() {
        // 不能被子类重写
    }
}

在上面的示例中，doSomething方法使用了final修饰符，表示该方法不能被子类重写，保证了程序的稳定性和可扩展性。

示例2

public abstract class Example8 {
    public abstract void print(); // 抽象方法，子类必须实现

    public void show() {
        System.out.println("Hello World!");
    }
}

在上面的示例中，print方法使用了抽象（abstract）修饰符，表示这是一个无实现方法。在基类中，print方法需要被所有子类实现。