Java非访问修饰符

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

2. final修饰符

2.1. final变量

final变量只能显式地初始化一次，声明为final的引用变量永远不能重新分配以引用不同的对象。但是，可以更改对象内的数据。因此，可以更改对象的状态，但不能更改引用。
对于变量，final修饰符通常与static一起使用，以使常量成为类变量。

示例

public class test {
   final int value = 10;

   // 以下是声明常量的示例：
   public static final int boxwidth = 6;
   static final string title = "manager";

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

2.2. final方法

任何子类都不能覆盖final方法。如前所述，final修饰符可防止在子类中修改方法。

声明final方法的主要目的是不让其它人改变方法的内容。

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

public class test {
   public final void changename() {
      // 方法主体
   }
}

2.3. final类

使用声明为final的类的主要目的是防止类被子类化。如果一个类被标记为final，那么这个类不能被其它类继承。

示例

public final class test {
   // body of class
}

3. abstract饰符

3.1. 抽象类

抽象(abstract)类不能实例化。如果一个类声明为抽象(abstract)，那么唯一的目的是扩展该类。

一个类不能是同时是abstract和final(因为final类不能被扩展)。如果一个类包含抽象方法，那么该类应该被声明为abstract。否则，将抛出编译错误。

抽象类可以包含抽象方法以及普通方法。

示例

abstract class caravan {
   private double price;
   private string model;
   private string year;
   public void getyear(string y){}；// 这是一个普通方法
   public abstract void gofast();   // 这是一个抽象方法
   public abstract void changecolor();// 这是一个抽象方法
}

3.2. 抽象方法
抽象方法是在没有任何实现的情况下声明的方法。方法体(实现)由子类提供。抽象方法永远不会是最终的或严格的。

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

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

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

示例

public abstract class superclass {
   abstract void m();   // 抽象方法
}

class subclass extends superclass {
   // 实现抽象方法
   void m() {
      // 实现代码.........
   }
}

4. synchronized修饰符

synchronized关键字用于指示一次只能访问一个方法的方法。synchronized修饰符可以应用于四个访问级别修饰符中的任何一个。

示例

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

5. transient修饰符

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

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

示例

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

6. volatile修饰符

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

访问volatile变量会同步主内存中变量的所有缓存复制。 volatile只能应用于实例变量，类型为private。 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
   }
}

通常，在一个线程(使用runnable开始的线程)中调用run()，并从另一个线程调用stop()。如果在第1行中使用了active的缓存值，那么当在第2行中将active设置为false时，循环可能不会停止。