詳解Java程式設計中protected修飾符與static修飾符的作用

protected 
來談談protected存取權限問題。看下面範例1：
Test.java

class MyObject {}
  
public class Test {
  public static void main(String[] args) {
    MyObject obj = new MyObject();
    obj.clone(); // Compile error.
  }
}

此時出現上文提到的錯誤：The method clone from the type Object is not visiuable.
我們已經清楚Object.clone()是protected方法。這說明，該方法可以被同包（java.lang）下和它（java.lang.Object）的子類別存取。這裡是MyObject類別（預設繼承java.lang.Object）。
同樣Test也是java.lang.Object的子類別。但是，不能在一個子類別中存取另一個子類別的protected方法，儘管這兩個子類別繼承自同一個父類別。
再看範例2：
Test2.java

class MyObject2 {
  protected Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}
  
public class Test2 {
  public static void main(String[] args) throws CloneNotSupportedException {
    MyObject2 obj = new MyObject2();
    obj.clone(); // Compile OK.
  }
}

這裡，我們在MyObject2類別中覆寫（override）父類別的clone（）方法，在另一個類別Test2中呼叫clone（）方法，編譯通過。
編譯通過的原因顯而易見，當你在MyObject2類別中覆寫clone（）方法時，MyObject2類別和Test2類別在同一個套件下，所以此protected方法對Test2類別可見。
分析到這裡，我們在回憶一下Java中的淺複製與深複製文中，章節2.2中的聲明，②在派生類別中覆蓋基類的clone()方法，並聲明為public。現在明白這句話的原因了吧（為了讓它類別能呼叫這個類別的clone()方法，重載之後要把clone()方法的屬性設為public）。
下面再來看範例3：
Test3.java

package 1
class MyObject3 {
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}
  
package 2
public class Test3 extends MyObject3 {
  public static void main(String args[]) {
    MyObject3 obj = new MyObject3();
    obj.clone(); // Compile error.
    Test3 tobj = new Test3();
    tobj.clone();// Complie OK.
  }
}

   

這裡我用Test3類別繼承MyObject3，注意這兩個類別是不同包裝的，否則就是範例2的情形。在Test3類別中呼叫Test3類別的實例tobj的clone（）方法，編譯通過。而同樣呼叫MyObject3類別的實例obj的clone（）方法，編譯錯誤！
意想不到的結果，protected方法不是可以被繼承類別存取嗎？
必須明確，類別Test3確實是繼承了類別MyObject3（包含它的clone方法），所以在類別Test3中可以呼叫自己的clone方法。但類別MyObject3的protected方法對其不同包子類別Test3來說，是不可見的。

方法的存取控制：

static
1．關鍵字static（先記住這些，再往下看）
1）靜態方法和靜態變數是屬於某一個類，而不是屬於類別的物件。
2）靜態方法和靜態變數的引用直接透過類別名稱引用。
3）在靜態方法中不能呼叫非靜態的方法和引用非靜態的成員變數。反之，則可以。
4）靜態變數在某種程式上與其他語言的全域變數相類似，如果不是私有的就可以在類別的外部進行存取。
2．何時使用static
在我們創建一個類別的實例時（物件），通常使用new方法，這樣這個類別的資料空間才會被創建，其方法才能被呼叫。
     但是，有時候我們希望一個類別雖然可以被創建n個物件（顯然這n個物件的資料空間是不相同的），但這n個物件的某些資料是相同的，即不管這個類別有多少的實例，這些資料對這些實例而言之有一份記憶體拷貝（見範例1）。這是靜態變數的情形。
另一種情形是，你希望某個方法不與包含它的類別的任何物件關聯在一起。也就是說，即使沒有建立對象，也能夠呼叫這個方法。 static 方法的一個重要用法就是在不建立任何物件的前提下，就可以呼叫它（請參閱範例2）。這是靜態方法的情況。
還有一種特殊的用法出現在內部類別中，通常一個普通類別不允許宣告為靜態的，只有一個內部類別才可以。這時這個宣告為靜態的內部類別可以直接當作一個普通類別來使用，而不需實例一個外部類別（見範例3）。這是靜態類別的情形。
範例1

public class TStatic {
  static int i;
  
  public TStatic() {
    i = 4;
  }
  
  public TStatic(int j) {
    i = j;
  }
  
  public static void main(String args[]) {
    System.out.println(TStatic.i);
    TStatic t = new TStatic(5); // 声明对象引用，并实例化。此时i=5
    System.out.println(t.i);
    TStatic tt = new TStatic(); // 声明对象引用，并实例化。此时i=4
    System.out.println(t.i);
    System.out.println(tt.i);
    System.out.println(t.i);
  }
}

結果：

0
5
4
4
4

static變數在類別被載入時創建，只要類別存在，static變數就存在。它們在定義時必須進行初始化。上例中沒有初始化i,所以會得到預設的初始值0。 static的變數的初始化僅能一次，static變數只是接受了最後一次的初始化。
實際這還是多個實例共享一個靜態的變數的問題。
 
範例2
未宣告為static

class ClassA {
  int b;
  
  public void ex1() {}
  
  class ClassB {
    void ex2() {
      int i;
      ClassA a = new ClassA();
      i = a.b; // 这里通过对象引用访问成员变量b
      a.ex1(); // 这里通过对象引用访问成员函数ex1
    }
  }
}

   

 
聲明為static

class ClassA {
  static int b;
  
  static void ex1() {}
}
  
class ClassB {
  void ex2() {
    int i;
    i = ClassA.b; // 这里通过类名访问成员变量b
    ClassA.ex1(); // 这里通过类名访问成员函数ex1
  }
}

   

在使用静态方法时要注意，在静态方法中不能调用非静态的方法和引用非静态的成员变量（在static方法中也不能以任何方式引用this或super）。理由很简单，对于静态的东西，JVM在加载类时，就在内存中开辟了这些静态的空间（所以可以直接通过类名引用），而此时非静态的方法和成员变量所在的类还没有实例化。
所以如果要使用非静态的方法和成员变量，可以直接在静态方法中实例化该方法或成员变量所在的类。public static void main就是这么干的。
 
示例3

public class StaticCls {
  public static void main(String[] args) {
    OuterCls.InnerCls oi = new OuterCls.InnerCls();// 这之前不需要new一个OuterCls
  }
}
  
class OuterCls {
  public static class InnerCls {
    InnerCls() {
      System.out.println("InnerCls");
    }
  }
}

 
结果：

InnerCls

3．静态初始化
static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。静态代码块（在“static{”后面跟着一段代码），是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。看下面示例。

class Value {
  static int c = 0;
  
  Value() {
    c = 15;
  }
  
  Value(int i) {
    c = i;
  }
  
  static void inc() {
    c++;
  }
}
  
class Count {
  public static void prt(String s) {
    System.out.println(s);
  }
  
  Value v = new Value(10);
  
  static Value v1, v2;
  static {
    prt("in the static block of calss Count v1.c=" + v1.c + " v2.c="
       + v2.c);
    v1 = new Value(27);
    prt("in the static block of calss Count v1.c=" + v1.c + " v2.c="
       + v2.c);
    v2 = new Value();
    prt("in the static block of calss Count v1.c=" + v1.c + " v2.c="
       + v2.c);
  }
}
  
public class TStaticBlock {
  public static void main(String[] args) {
    Count ct = new Count();
    Count.prt("in the main:");
    Count.prt("ct.c=" + ct.v.c);
    Count.prt("v1.c=" + Count.v1.c + " v2.c=" + Count.v2.c);
    Count.v1.inc();
    Count.prt("v1.c=" + Count.v1.c + " v2.c=" + Count.v2.c);
    Count.prt("ct.c=" + ct.v.c);
  }
}

 

 
结果：

in the static block of calss Count v1.c=0 v2.c=0
in the static block of calss Count v1.c=27 v2.c=27
in the static block of calss Count v1.c=15 v2.c=15
in the main:
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11

   

不管是v,v1还是v2，它们操作的成员变量都是同一个静态变量c。
在类Count中先初始化v1，v2（static Value v1, v2;），再初始化静态代码块（static{}），最后初始化v。

更多詳解Java程式設計中protected修飾符與static修飾符的作用相关文章请关注PHP中文网！