修饰符¶

Java修饰符¶

Java的修饰符分为两类：即访问修饰符和非访问修饰符。

访问控制修饰符¶

根据不同的访问权限，分为以下四类：

default（默认，什么都不写）：在同一包内部可见，不使用任何修饰符。使用对象包括：类、接口、变量和方法；
private：在同一类内部可见。使用对象包括：变量和方法；
public：对所有类可见。使用对象包括：类、接口、变量和方法；
protected：对同一包内部的类和所有子类可见。使用对象包括：变量和方法；

默认访问修饰符¶

Java
String version = "1.5.1";
boolean processOrder() {
   return true;
}

private¶

Java
public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

public¶

Java
public static void main(String[] arguments) {
   // ...
}

protected¶

Java
class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

注意：

父类声明为public的方法在子类中也必须为public；
父类声明为protected的方法要么声明为protected，要么声明为public，不能声明为private；
父类声明为private的方法不能被继承。

非访问控制符¶

static：修饰类方法和变量；
final：修饰类、方法和变量，final修饰的类不能被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量无法被修改；
abstract：创建抽象类和抽象方法；
synchronized和volatile：主要用于线程的编程。

static¶

静态变量：static关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为static变量。
静态方法：static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

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");
   }
}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");
   }
}

final¶

final变量：变量一旦赋值后，不能被重新赋值。被final修饰的实例变量必须显式指定初始值。final修饰符通常和static修饰符一起使用来创建类常量。

Java
public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

final方法：可以被子类继承，但是不能被子类重写。

Java
public class Test{
    public final void changeName(){
       // 方法体
    }
}

final类：不能被继承，没有类能够继承final类的任何特性。

Java
public final class Test {
   // 类体
}

abstract¶

抽象类：不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法。

Java
abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); // 抽象方法
   public abstract void changeColor();
}

抽象方法：抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成final和static。

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

class SubClass extends SuperClass{
     // 实现抽象方法
      void m(){
          .........
      }
}

synchronized, transient, volatile¶

被synchronized关键字声明的方法同一时间只能被一个线程访问，synchronized修饰符可以应用于四个访问修饰符；
序列化的对象包含被transient修饰的实例变量时，java虚拟机（JVM）跳过该特定的变量；
volatile修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

Java
public class MyRunnable implements Runnable {
    private volatile boolean active;
    public void run() {
        active = true;
        while (active) { // line 1
            ; // do something
        }
    }

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

在上面的代码中，通常情况下，在一个线程调用run()方法（在Runnable开启的线程），在另一个线程调用stop()方法。如果第一行中缓冲区的active值被使用，那么在第二行的active值为false时循环不会停止。但是以上代码中由于使用了volatile修饰active，所以该循环会停止。

参考链接¶

菜鸟教程：Java修饰符