Java非访问修饰符

Java提供了一些非访问修饰符来实现很多其他的功能。

static 修饰符用于创建类的方法和变量
final 修饰符的类最终实现，方法和变量的实现。
abstract 修饰符用于创建抽象类和方法。
synchronized 和 volatile 修饰符这是用于线程

static 修饰符：

Static 变量：

静态关键字用于创建，将独立的类中创建任何实例存在变数。静态变量的一个副本，无论存在的类的实例的数量。

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

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 变量:

final变量可以显式初始化一次。声明为final引用变量不能被重新分配到引用一个不同的对象。

然而该对象内的数据是可以改变的。这样的对象的状态可以改变，但不引用。

变量使用 final 修饰符通常用于静态，使常数的类变量。

例子：

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方法不能被任何被子类覆盖。如前面提到的最终修饰符防止被修改在子类中的方法。

做一个这样的方法最终的主要目的是，该方法的内容不应受到任何外界改变。

例子：

声明在类声明中的final修饰符的方法，如下面的例子：

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

final 类:

使用被声明为final的类的主要目的是防止类被创建子类。如果一个类被标记为final 则没有类可以从最终的类继承的任何功能。

例子：

public final class Test {
   // body of class
}

abstract 修饰符：

abstract 类:

抽象类不能被实例化。如果一个类被声明为抽象的那么唯一目的是为类进行扩展。

一个类不能既是抽象和final。（因为一个final类不能扩展）。如果一个类包含抽象方法那么这个类必须声明为abstract。否则编译错误将被抛出。

一个抽象类可以包含抽象方法和普通的方法。

例子：

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

abstract 方法:

一个抽象的方法是用任何实现声明的方法。方法本体（实现）是由子类提供。抽象方法不能是最终的或严格。

继承抽象类的任何类都必须实现父类的所有抽象方法，除非子类也是一个抽象类。

如果一个类包含一个或多个抽象方法那么这个类必须被声明为abstract。一个抽象类，并不需要包含抽象方法。

抽象方法以分号结束。例如：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行的主动缓存的值时，该循环时，可能会设置为活动为false，在第2行不会停止。这就是为什么想使用volatile。