在Java中，修饰符是一种关键字，用于修饰类、变量、方法等结构的访问权限、范围等特征。本文将会详细讲解Java中常用修饰符的使用方法，帮助读者更好地理解和掌握Java编程。

Java中常用修饰符的使用方法汇总

在Java中，修饰符是一种关键字，用于修饰类、变量、方法等结构的访问权限、范围等特征。本文将会详细讲解Java中常用修饰符的使用方法，帮助读者更好地理解和掌握Java编程。

访问修饰符

Java中访问修饰符包括public、protected、default和private四种，它们分别控制着变量、方法和类的访问权限。下面逐一进行说明：

public

使用public修饰的成员可以被任何其他类访问，无论这些类是否在同一个包中，即为公共访问权限。

示例：

public class Person {
    public String name;
    public void printName() {
        System.out.println("name: " + name);
    }
} 

public class Test {
    public static void main(String[] args) {
        Person xiaoming = new Person();
        xiaoming.name = "小明";
        xiaoming.printName();
    } 
}

上述代码中，Person类中为name和printName方法均被public修饰，由于它们具有公共访问权限，因此在Test类中可以直接访问。

protected

使用protected修饰的成员可以被本类、同一个包中的其他类、以及该类的子类访问，即为受保护的访问权限。

示例：

public class Person {
    protected int age;
} 

public class Teacher extends Person {
    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
} 

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.setAge(30);
        System.out.println("age: " + teacher.getAge());
    } 
}

上述代码中，Person类中的age变量被protected修饰，在Teacher类中能够通过继承来访问这个变量，并添加了setAge和getAge方法，可以在Test类中通过teacher对象访问到age变量的值。

default

使用default修饰的成员只能在同一个包中被访问，没有访问修饰符时默认为default，即为包访问权限。

示例：

package com.example;

class Person {
    String name;
    int age;

    void display() {
        System.out.println("name: " + name + ", age: " + age);
    }
} 

public class Test {
    public static void main(String[] args) {
        Person xiaoming = new Person();
        xiaoming.name = "小明";
        xiaoming.age = 18;
        xiaoming.display();
    } 
}

上述代码中，Person类没有使用任何访问修饰符，在Test类中只有在将Person类和Test类放在同一个包中之后才能够访问到Person类中的变量和方法，即为包访问权限。

private

使用private修饰的成员只能在本类中被访问，不能被其他类访问，即为私有访问权限。

示例：

public class Person {
    private String name;
    private void printName() {
        System.out.println("name: " + name);
    }

    public void setName(String name) {
        this.name = name;
    }

    public void display() {
        printName();
    }
} 

public class Test {
    public static void main(String[] args) {
        Person xiaoming = new Person();
        xiaoming.setName("小明");
        xiaoming.display();
    } 
}

上述代码中，Person类中的name变量和printName方法均被private修饰，只有在Person类内部才能够被访问。

非访问修饰符

除了访问修饰符外，Java中还有final、abstract、static和volatile四种非访问修饰符。

final

使用final修饰的成员不能被改变，即为不可变的。

示例：

public class Person {
    public final String name = "小明";
    public final int age = 18;
} 

public class Test {
    public static void main(String[] args) {
        Person xiaoming = new Person();
        xiaoming.name = "小红";
        xiaoming.age = 20;
        System.out.println("name: " + xiaoming.name + ", age: " + xiaoming.age);
    } 
}

上述代码中，Person类中的name变量和age变量均被final修饰，因此不能够被改变，如果在Test类中执行对这两个变量的赋值操作，则会报错。

abstract

使用abstract修饰的类必须被继承，不能被实例化，即为抽象类。

示例：

public abstract class Animal {
    public abstract void move();
} 

public class Dog extends Animal {
    public void move() {
        System.out.println("狗会跑");
    }
} 

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.move();
    } 
}

上述代码中，Animal类被声明为抽象类，并使用了abstract修饰其move方法，必须在子类中进行实现。在Test类中，先将Dog类实例化为一个Animal类型的变量animal，然后使用animal.move()方法来调用的是Dog类中实现的move方法。

static

使用static修饰的成员是静态成员，属于类本身而非对象，可以通过类名直接访问，也可以通过对象访问。

示例：

public class Person {
    private static int count = 0;
    private int id;
    private String name;

    public Person(String name) {
        this.name = name;
        this.id = ++count;
    }

    public static int getCount() {
        return count;
    }

    public void display() {
        System.out.println("id: " + id + ", name: " + name);
    }
}

public class Test {
    public static void main(String[] args) {
        Person xiaoming = new Person("小明");
        Person xiaohong = new Person("小红");
        System.out.println("count: " + Person.getCount());
        xiaoming.display();
        xiaohong.display();

    } 
}

上述代码中，Person类中的count变量被声明为静态变量，可以使用Person.getCount()方法来获取所有Person对象的计数器，也可以通过对象调用display方法来输出每个人的id和name。

volatile

使用volatile修饰的成员具有可见性，即被volatile修饰的变量在一个线程中被修改后，在其他线程中是可见的。

示例：

public class Counter extends Thread {
    volatile int count = 0;

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

    public void run() {
        for (int i = 0; i < 10000; i++) {
            increment();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Counter counter1 = new Counter();
        Counter counter2 = new Counter();
        counter1.start();
        counter2.start();
        try {
            counter1.join();
            counter2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("count: " + counter1.count);
    } 
}

上述代码中，Counter类中的count变量被声明为volatile，确保在计数线程1中修改count变量后，在计数线程2中是可见的。在Test类中，创建了两个计数线程counter1和counter2，并启动它们，最后使用counter1.count输出计数结果。