Java - 非访问修饰符

---

---

Java 提供了许多非访问修饰符来实现许多其他功能。

• 用于创建类方法和变量的 static 修饰符。

• 用于完成类、方法和变量实现的 final 修饰符。

• 用于创建抽象类和方法的 abstract 修饰符。

• 用于线程的 synchronized 和 volatile 修饰符。

静态修饰符

静态变量

static 关键字用于创建独立于为类创建的任何实例存在的变量。无论类的实例数量多少，都只存在一个静态变量副本。

静态变量也称为类变量。局部变量不能声明为静态。

静态方法

static 关键字用于创建独立于为类创建的任何实例存在的方法。

静态方法不使用其定义所在类的任何对象的任何实例变量。静态方法从参数中获取所有数据，并根据这些参数计算某些内容，而不引用变量。

类变量和方法可以使用类名后跟一个点和变量或方法的名称来访问。

示例

静态修饰符用于创建类方法和变量，如下例所示：

public class InstanceCounter {

   private static int numInstances = 0;

   protected static int getCount() {
      return numInstances;
   }

   private static void addInstance() {
      numInstances++;
   }

   InstanceCounter() {
      InstanceCounter.addInstance();
   }

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

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

输出

Started with 0 instances
Created 500 instances

最终修饰符

最终变量

最终变量只能显式初始化一次。声明为 final 的引用变量永远不能重新分配以引用不同的对象。

但是，对象中的数据可以更改。因此，可以更改对象的状态，但不能更改引用。

对于变量，final 修饰符通常与 static 一起使用以使常量成为类变量。

示例

public class Test {
   final int value = 10;

   // The following are examples of declaring constants:
   public static final int BOXWIDTH = 6;
   static final String TITLE = "Manager";

   public void changeValue() {
      value = 12;   // will give an error
   }
}

最终方法

最终方法不能被任何子类覆盖。如前所述，final 修饰符阻止方法在子类中被修改。

使方法成为最终的主要目的是方法的内容不应被任何外部人员更改。

示例

您可以在类声明中使用 final 修饰符声明方法，如下例所示：

public class Test {
   public final void changeName() {
      // body of method
   }
}

最终类

使用声明为 final 的类的主要目的是防止该类被子类化。如果一个类被标记为 final，那么任何类都不能继承 final 类的任何特性。

示例

public final class Test {
   // body of class
}

抽象修饰符

抽象类

抽象类永远不能被实例化。如果一个类被声明为抽象，那么唯一的目的是为了扩展该类。

一个类不能同时是抽象的和最终的（因为最终类不能被扩展）。如果一个类包含抽象方法，则该类应声明为抽象。否则，将抛出编译错误。

抽象类可以同时包含抽象方法和普通方法。

示例

abstract class Caravan {
   private double price;
   private String model;
   private String year;
   public abstract void goFast();   // an abstract method
   public abstract void changeColor();
}

抽象方法

抽象方法是一种没有实现的声明方法。方法体（实现）由子类提供。抽象方法永远不能是最终的或严格的。

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

如果一个类包含一个或多个抽象方法，则该类必须声明为抽象类。抽象类不需要包含抽象方法。

抽象方法以分号结尾。例如：public abstract sample();

示例

public abstract class SuperClass {
   abstract void m();   // abstract method
}

class SubClass extends SuperClass {
   // implements the abstract method
   void m() {
      .........
   }
}

Synchronized 修饰符

synchronized 关键字用于指示方法一次只能被一个线程访问。synchronized 修饰符可以与任何四个访问级别修饰符一起使用。

示例

public synchronized void showDetails() {
   .......
}

Transient 修饰符

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

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

示例

public transient int limit = 55;   // will not persist
public int b;   // will persist

Volatile 修饰符

volatile 修饰符用于让 JVM 知道访问该变量的线程必须始终将其自己的变量私有副本与内存中的主副本合并。

访问 volatile 变量会同步内存中所有变量的缓存副本。Volatile 只能应用于实例变量，这些变量是对象类型或私有类型。volatile 对象引用可以为 null。

示例

public class MyRunnable implements Runnable {
   private volatile boolean active;

   public void run() {
      active = true;
      while (active) {   // line 1
         // some code here
      }
   }

   public void stop() {
      active = false;   // line 2
   }
}

通常，run() 在一个线程（您使用 Runnable 启动的线程）中调用，而 stop() 在另一个线程中调用。如果在第 1 行中使用了 active 的缓存值，那么当您在第 2 行中将 active 设置为 false 时，循环可能不会停止。这时您需要使用volatile。