Java修飾符關鍵詞大全

Java修飾符是你添加到變量、類和方法以改變其含義的關鍵詞。它們可分爲兩組：

1. 訪問控制修飾符

2. 非訪問修飾符

修飾符        說明

public       公共可見

private      類可見

protected    包和全部的子類可見

那麼如何使用這三種訪問控制修飾符呢？請看下面兩個類。請忽略此處代碼的低效，由於這是教程。

建立一個名爲project/mypackage/Person.java文件，並添加如下代碼：

package mypackage; class Person {
     private String firstname;
     private String lastname;
    protected void setFirstname(String firstname) { 
            this.firstname = firstname;     }     
    protected void setLastname(String lastname) {
            this.lastname = lastname;     }   
    protected String getFirstname() {         
            return this.firstname;     }    
    protected String getLastname() {    
         return this.lastname; 
         } }

上面的Person類有private變量和protected方法。這意味着這些變量將只能從類訪問，方法將只能從mypackage包訪問。

接下來建立一個名爲project/mypackage/Company.java的文件，並添加如下代碼：

package mypackage;
 import java.util.*;
  public class Company { 
      private ArrayList<Person> people; 
          public Company() {
            this.people = new ArrayList<Person>();
                 } 
          public void addPerson(String firstname, String lastname) { 
               Person p = new Person(); 
               p.setFirstname(firstname);   
               p.setLastname(lastname);  
                this.people.add(p);
                      }    
       public void printPeople() {
         for(int i = 0; i < this.people.size(); i++) {
         System.out.println(this.people.get(i).getFirstname() + " " + this.people.get(i).getLastname());    
              }     } }

上面的類是公共的，所以它能夠從包內部和外部的任何類進行訪問。它有一個只能在類內訪問的私有變量，以及一堆的公共方法。因爲Person類和Company類共享相同的包，因此Company類能夠訪問Person類以及全部它的方法。

爲了完成訪問控制修飾符的示範，讓咱們在一個新的project/MainDriver.java文件中建立一個驅動程序類：

import mypackage.*;
 public class MainDriver { 
     public static void main(String[] args) {
        Company c = new Company(); 
        c.addPerson("Nic", "Raboy");  
        c.printPeople(); 
          Person p = new Person();   
          p.setFirstname("Maria"); 
          p.setLastname("Campos"); 
           } }

請記住，因爲Company類是公共的，因此咱們在添加和打印人的時候沒有問題。然而，因爲Person類是受保護的，因此咱們會獲得一個編譯時錯誤，由於MainDriver不是mypackage包的一部分。

如今，讓咱們來看看現有的非訪問修飾符，以及如何使用它們的一些示例代碼。

    修飾符          說明

   static     用於建立類、方法和變量

    final    用於最終肯定類、變量和方法的實施方式

   abstract    用於建立抽象方法和類

  synchronized   用於多線程的同步機制對資源進行加鎖，使得在同一個時間，只有一個線程能夠進行操做

  Volatile      一個變量聲明爲volatile，就意味着這個變量是隨時會被其餘線程修改的，所以不能將它cache在線程memory中。

那麼如何使用這五個非訪問修飾符呢？

Java中static修飾符的一個很好的例子就是：

int max = Integer.MAX_VALUE
int numeric = Integer.parseInt("1234");

在上面的例子中，請注意咱們利用了Integer類中變量和方法，而不是先實例化。這是由於那些特定的方法和變量都是靜態的。

abstract修飾符則略有不一樣。你能夠建立一個帶方法的類，但它們基本只能定義。你不能對它們添加邏輯。例如：

abstract class Shape {    
 abstract int getArea(int width, int height); }

而後在子類裏，你才能夠增長例以下面這樣的代碼：

class Rectangle extends Shape {  
   int getArea(int width, int height) {   
         return width * height;     } }

下面要講講synchronized和volatile修飾符。

先來看一個線程的例子，在這個例子裏咱們將從兩個不一樣的線程去訪問相同的方法：

import java.lang.*;
 public class ThreadExample {   
   public static void main(String[] args) {  
          Thread thread1 = new Thread(new Runnable() {  
                  public void run() {  
                  print("THREAD 1");     
                          }         });   
                  Thread thread2 = new Thread(new Runnable() {    
                           public void run() {               
                    print("THREAD 2");             }         });   
                          thread1.start();         thread2.start();     }    
                     public static void print(String s) {      
                        for(int i = 0; i < 5; i++) {            
                      System.out.println(s + ": " + i);         }     } }

運行上述代碼將輸出打印一個隨機的順序。多是連續的，也可能不連續，取決於CPU。然而，若是咱們使用synchronized修飾符，那麼第一個線程必須在第二個線程開始打印以前完成。print(String s)方法能夠是這樣的：

public static synchronized void print(String s) {   
  for(int i = 0; i < 5; i++) {     
      System.out.println(s + ": " + i);     } }

接下來，讓咱們看看使用volatile 修飾符的例子：

import java.lang.*;
 public class ThreadExample {
      public static volatile boolean isActive;  
      public static void main(String[] args) {
               isActive = true;     
               Thread thread1 = new Thread(new Runnable() {   
                  public void run() {    
                       while(true) {  
                         if(isActive) {      
                          System.out.println("THREAD 1"); 
                        isActive = false;                     }                 }             }         });       
                         Thread thread2 = new Thread(new Runnable() {             public void run() {         
                         while(true) {     
                                 if(!isActive) {   
                            System.out.println("THREAD 2");                                              try {                            
                             Thread.sleep(100);        
                               } catch (Exception e) {                         }                         isActive = true;     
                                               }                 }             }         });        
                         thread1.start();  
                         thread2.start();     } }

因爲volatile變量是一種狀態標誌，因此運行上面的代碼會打印線程數，並在它們之間交替。這是由於該標誌被存儲在主存儲器中。若是咱們去掉volatile關鍵字，該線程將只交替一次，由於只使用一個本地參考，兩個線程基本上彼此隱身。

結論

Java修飾符理解起來會有一點棘手，並且實際上不少程序員並不怎麼熟悉它們。這是一個很好的面試問題，能夠用於測試你的書本知識。最後，若是我有什麼遺漏或解釋錯誤的地方，歡迎各位不吝指出。