Java的修饰符主要分为以下两类：

• 访问修饰符
• 非访问修饰符

访问修饰符

非访问修饰符

1. static 用于创建类方法和变量
2. final 用于完成类，方法和变量的实现
3. abstract 用于创建抽象类和方法
4. synchronized 用于线程
5. transient用于跳过序列化
6. volatile 用于线程

1.static修饰符

静态变量 ： static 用于创建独立于类实例的变量。和类的实例数无关，只存在一个静态变量副本。静态变量也称为类变量。局部变量不能声明为 static 。

静态方法 ： static 用于创建独立于类实例的方法。静态方法不能使用作为类的对象的实例变量，静态方法也叫类方法。不引用变量。使用类名+”.”及变量或方法的名称来访问类变量或方法。

 public class StaticDemo {
    private static int count = 0;

    protected static int getCount() {
        return count;
    }

    private static void addCount() {
        count++;
    }

    public StaticDemo() {
        StaticDemo.addCount();
    }

    public static void main(String[] arguments) {
        System.out.println("Starting with " + StaticDemo.getCount() + " instances");

        for (int i = 0; i < 10; ++i) {
            new StaticDemo();
        }
        System.out.println("Created " + StaticDemo.getCount() + " instances");
    }
}
  

运行结果：

 Starting with 0 instances
Created 10 instances  

2.final修饰符

final变量 ：只能显示初始化一次，不能重新分配用来引用不同的对象。可以更改对象内的数据。 final 通常与 static 一起使用，以使常量成为类变量。

 public class TestFinal {
    final int value = 1;

    // 以下是声明常量的示例：
    public static final double PI = 3.1415926;
    static final String str = "Hello";

    public void changeValue() {
        value = 2;   // 会出错，不能重新赋值
    }
}  

final方法 ：任何子类都不能重写final方法。用 final 声明方法的目的是不让他人改变。

 public class TestFinal{
    public final sayHi(){
    //方法主体
    }
}  

final类 :不能被继承。

 public final class TestFinal{
  //类主体
}
  

3.abstract修饰符

抽象类

abstract 修饰的类不能被实例化。只能继承该类。

abstract 和 final 不能同时修饰一个类。

抽象类中可以包含非抽象方法。

 abstract class Dog {
    private int size;
    private String name;
    public void run(){ //非抽像方法
        
    };
    public abstract  void eat();  //抽象方法
}
  

抽象方法

抽象方法是没有任何实现情况下声明的方法。方法由子类实现。

扩展抽象类的任何类都必须实现超类的所有抽象方法，除非子类也是抽象类。

 public abstract class Dog {
    public abstract  void eat();  //抽象方法
}

public GermanShepherdDog extends Dog{
    public  void eat(){
        //实现抽像方法    
    }
}  

4.synchronized修饰符

synchronized 修饰方法，保证在同一时刻只能有一个线程执行该代码块。常用于高并发场景需要一次只能访问一个的情况。

 public synchornized void getLock(){
          
}  

5.transient修饰符

实例变量标记为 transient ，表示JVM在序列化包含它的对象时跳过特定变量。

transient 包含在创建变量的语句中，位于变量的类或数据类型之前。

 public transient lint count=1;  

6.volatile修饰符

Java语言提供了一种稍弱的同步机制，即 volatile 变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为 volatile 类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

　　在访问 volatile 变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此 volatile 变量是一种比 sychronized 关键字更轻量级的同步机制。

 public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}  

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。

但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。