java修飾符

『壹』 java 修飾符有哪幾個

1、類的修飾符分為：可訪問控制符和非訪問控制符兩種。

可訪問控制符是：公共類修飾符 public

非訪問控制符有：抽象類修飾符 abstract ；最終類修飾符 final

1 ）公共類修飾符 public ： Java 語言中類的可訪問控制符只有一個： public 即公共的。每個 Java 程序的主類都必須是 public 類作為公共工具供其它類和程序使用的應定義為 public 類。

2 ）抽象類修飾符 abstract ：凡是用 abstract 修飾符修飾的類，被稱為抽象類。所謂抽象類是指這種類沒有具體對象的一種概念類。這樣的類就是 Java 語言的 abstract 類。

3 ） 最終類修飾符 final ：當一個類不可能有子類時可用修飾符 final 把它說明為最終類。被定義為 final 的類通常是一些有固定作用、用來完成某種標准功能的類。

4 ）類預設訪問控制符：如果一個類沒有訪問控制符，說明它具有預設的訪問控制符特性。此時，這個類只能被同一個包中的類訪問或引用。這一訪問特性又稱為包訪問性。

2 ．域的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。

可訪問控制符有 4 種：公共訪問控制符： public ；私有訪問控制符： private ；保護訪問控制符： protected ；私有保護訪問控制符： private protected

非訪問控制符有 4 種：靜態域修飾符： static ；最終域修飾符： final ；易失 ( 共享 ) 域修飾符： volatile ；暫時性域修飾符： transient

1 ）公共訪問控制符 public ：用 public 修飾的域稱為公共域。如果公共域屬於一個公共類，則可以被所有其它類所引用。由於 public 修飾符會降低運行的安全性和數據的封裝性，所以一般應減少 public 域的使用。

2 ）私有訪問控制符 private ： 用 private 修飾的成員變數 ( 域 ) 只能被該類自身所訪問，而不能被任何其它類 ( 包括子類 ) 所引用。

3 ）保護訪問控制符 protected ：用 protected 修飾的成員變數可以被三種類所引用：①該類自身；②與它在同一個包中的其它類；③在其它包中的該類的子類。使用修飾符 protected 的主要作用是允許其它包中它的子類來訪問父類的特定屬性。

4 ）私有保護訪問控制符 private protected ：用修飾符 private protected 修飾的成員變數可以被該類本身或該類的子類兩種類訪問和引用。

5 ）靜態域修飾符 static ：用 static 修飾的成員變數僅屬於類的變數，而不屬於任何一個具體的對象，靜態成員變數的值是保存在類的內存區域的公共存儲單元，而不是保存在某一個對象的內存區間。任何一個類的對象訪問它時取到的都是相同的數據；任何一個類的對象修改它時 , 也都是對同一個內存單元進行操作。

6 ）最終域修飾符 final ：最終域修飾符 final 是用來定義符號常量的。一個類的域 ( 成員變數 ) 如果被修飾符 final 說明，則它的取值在程序的整個執行過程中都是不變的。

7 ）易失 ( 共享 ) 域修飾符 volatile ：易失 ( 共享 ) 域修飾符 volatile 是用來說明這個成員變數可能被幾個線程所控制和修改。也就是說在程序運行過程中，這個成員變數有可能被其它的程序影響或改變它的取值。因此，在使用中要注意這種成員變數取值的變化。通常 volatile 用來修飾接受外部輸入的域。

8 ）暫時性域修飾符 transient ：暫時性域修飾符 transient 用來定義一個暫時性變數。其特點是：用修飾符 transient 限定的暫時性變數，將指定 Java 虛擬機認定該暫時性變數不屬於永久狀態，以實現不同對象的存檔功能。否則，類中所有變數都是對象的永久狀態的一部分，存儲對象時必須同時保存這些變數。

3 ．方法的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。

可訪問控制符有 4 種：公共訪問控制符： public ；私有訪問控制符： private ；保護訪問控制符： protected ；私有保護訪問控制符： private protected

非訪問控制符有 5 種：抽象方法控制符： abstract ；靜態方法控制符： static ；最終方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized

1 ）抽象方法控制符 abstract ：用修飾符 abstract 修飾的方法稱為抽象方法。抽象方法是一種僅有方法頭，沒有方法體和操作實現的一種方法。

2 ）靜態方法控制符 static ：用修飾符 static 修飾的方法稱為靜態方法。靜態方法是屬於整個類的類方法；而不使用 static 修飾、限定的方法是屬於某個具體類對象的方法。 由於 static 方法是屬於整個類的，所以它不能操縱和處理屬於某個對象的成員變數，而只能處理屬於整個類的成員變數，即 static 方法只能處理 static 的域。

3 ）最終方法控制符 final ：用修飾符 final 修飾的方法稱為最終方法。最終方法是功能和內部語句不能更改的方法，即最終方法不能重載。這樣，就固定了這個方法所具有的功能和操作，防止當前類的子類對父類關鍵方法的錯誤定義，保證了程序的安全性和正確性。所有被 private 修飾符限定為私有的方法，以及所有包含在 final 類 ( 最終類 ) 中的方法，都被認為是最終方法。

4 ）本地方法控制符 native ：用修飾符 native 修飾的方法稱為本地方法。為了提高程序的運行速度，需要用其它的高級語言書寫程序的方法體，那麼該方法可定義為本地方法用修飾符 native 來修飾；

5 ）同步方法控制符 synchronized ：該修飾符主要用於多線程共存的程序中的協調和同步。

本文出自http://hi..com/lifa868/blog/item/d91674ecb346c64779f0557d.html

『貳』 Java中修飾符怎麼用

java修飾符要分清類的修飾符和成員修飾符
類的修飾符有final、abstract、public等（注意的是：一個程序中只能有一個並列的public類）
成員的的修飾符就比較多了 public friendly protected private static final syhncronazed等等.
分不清的話 都先別寫修飾符。慢慢理解就好了。

『叄』 Java內部類的修飾符有哪些

一、內部類可以為四種：

⒈ 靜態內部類

⒉ 成員內部類

⒊ 局部內部類

⒋
匿名內部類幾種內部類的共性：

A、內部類仍然是一個獨立的類，在編譯之後會內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類命和$符號。

B、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變數，無論是否是private的。

1、靜態嵌套類：從技術上講，靜態嵌套類不屬於內部類。因為內部類與外部類共享一種特殊關系，更確切地說是對實例的共享關系。而靜態嵌套類則沒有上述關系。它只是位置在另一個類的內部，因此也被稱為頂級嵌套類。靜態的含義是該內部類可以像其他靜態成員一樣，沒有外部類對象時，也能夠訪問它。靜態嵌套類不能訪問外部類的成員和方法。 class Outer{ static class Inner{} } class Test { public static void main(String[] args){ Outer.Inner n = new Outer.Inner(); } }

2、成員內部類：形式如下
class Outer { class Inner{} }
編譯上述代碼會產生兩個文件：Outer.class和Outer$Inner.class。成員內部類內不允許有任何靜態聲明！下面代碼不能通過編譯。
class Inner{ static int a = 10;
}能夠訪問成員內部類的唯一途徑就是通過外部類的對象！

A、從外部類的非靜態方法中實例化內部類對象。 class Outer { private
int i = 10; public void makeInner(){ Inner in = new Inner();
in.seeOuter(); } class Inner{ public void seeOuter(){
System.out.print(i); } }
}表面上，我們並沒有創建外部類的對象就實例化了內部類對象，和上面的話矛盾。事實上，如果不創建外部類對象也就不可能調用makeInner()方法，所以到頭來還是要創建外部類對象的。可能試圖把makeInner()方法修飾為靜態方法，即static
public void
makeInner()。這樣不創建外部類就可以實例化外部類了！但是在一個靜態方法里能訪問非靜態成員和方法嗎？顯然不能。它沒有this引用。沒能跳出那條規則！但是如果在這個靜態方法中實例化一個外部類對象，再用這個對象實例化外部類完全可以！也就是下一條的內容。

B、從外部類的靜態方法中實例化內部類對象。
class Outer { private int i = 10; class Inner{ public void seeOuter(){
System.out.print(i);
} } public static void main(String[] args) { Outer out = new Outer();
Outer.Inner in = out.new Inner(); //Outer.Inner in = new Outer().new
Inner(); in.seeOuter(); }
}被注釋掉的那行是它上面兩行的合並形式，一條簡潔的語句。對比一下：在外部類的非靜態方法中實例化內部類對象是普通的new方式：Inner in =
new Inner();在外部類的靜態方法中實例化內部類對象，必須先創建外部類對象：Outer.Inner
in = new Outer().new
Inner();

C、內部類的this引用。普通的類可以用this引用當前的對象，內部類也是如此。但是假若內部類想引用外部類當前的對象呢？用「外部類名」.this；的形式,如下例的Outer.this。
class Outer { class Inner{ public void seeOuter(){
System.out.println(this); System.out.println(Outer.this); } }
}

D、成員內部類的修飾符。對於普通的類，可用的修飾符有final、abstract、strictfp、public和默認的包訪問。但是成員內部類更像一個成員變數和方法。可用的修飾符有：final、abstract、public、private、protected、strictfp和static。一旦用static修飾內部類，它就變成靜態內部類了。

3、方法內部類：顧名思義，把類放在方法內。
class Outer { public void doSomething(){ class Inner{ public void
seeOuter(){ } } }
}

A、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。

B、方法內部類對象不能使用該內部類所在方法的非final局部變數。因為方法的局部變數位於棧上，只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，局部變數成為歷史。但是該方法結束之後，在方法內創建的內部類對象可能仍然存在於堆中！例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變數內。正因為不能保證局部變數的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。下面是完整的例子：
class Outer { public void doSomething(){ final int a =10; class Inner{
public void seeOuter(){ System.out.println(a); } } Inner in = new
Inner(); in.seeOuter(); } public static void main(String[] args) { Outer
out = new Outer(); out.doSomething(); }
}

C、方法內部類的修飾符。與成員內部類不同，方法內部類更像一個局部變數。可以用於修飾方法內部類的只有final和abstract。

D、靜態方法內的方法內部類。靜態方法是沒有this引用的，因此在靜態方法內的內部類遭受同樣的待遇，即：只能訪問外部類的靜態成員。

4、匿名內部類：顧名思義，沒有名字的內部類。表面上看起來似乎有名字，實際那不是名字。

A、繼承式的匿名內部類。
class Car { public void drive(){ System.out.println("Driving a car!"); }
} class Test{ public static void main(String[] args) { Car car = new
Car(){ public void drive(){ System.out.println("Driving another car!"); }
}; car.drive(); } }結果輸出了：Driving another
car!
Car引用變數不是引用Car對象，而是Car匿名子類的對象。建立匿名內部類的關鍵點是重寫父類的一個或多個方法。再強調一下，是重寫父類的方法，而不是創建新的方法。因為用父類的引用不可能調用父類本身沒有的方法！創建新的方法是多餘的。簡言之，參考多態。B、介面式的匿名內部類。
interface Vehicle { public void drive(); } class Test{ public static
void main(String[] args) { Vehicle v = new Vehicle(){
public void drive(){ System.out.println("Driving a car!"); } };
v.drive(); }
}上面的代碼很怪，好像是在實例化一個介面。事實並非如此，介面式的匿名內部類是實現了一個介面的匿名類。而且只能實現一個介面。

C、參數式的匿名內部類。class
Bar{ void doStuff(Foo f){}}interface Foo{ void foo();}class Test{
static void go(){ Bar b = new Bar();
b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); }
});
}}

二、許可權修飾符：public、protected、default、private。

修飾符：abstract、static、final。

public 使用對象：最廣，類、介面、變數、方法。

protected使用對象：變數、方法 注意：不能修飾類（外部類）。

default 使用對象：類、介面、變數、方法。（即預設，什麼也不寫）。

private 使用對象：變數、方法 注意：不能修飾類（外部類）。

abstract使用對象：類、介面、方法。

static 使用對象：類、變數、方法、初始化函數（注意：修飾類時只能修飾 內部類 ）。

final 使用對象：類、變數、方法。

transient：告訴編譯器，在類對象序列化的時候，此變數不需要持久保存

volatile：指出可能有多個線程修改此變數，要求編譯器優化以保證對此變數的修改能夠被正確的處理。

native：用該修飾符定義的方法在類中沒有實現，而大多數情況下該方法的實現是用C、C++編寫的。

synchronized：修飾方法，多線程的支持。

『肆』 在java中一個類的修飾符有哪些

一：訪問修飾符：
1.省略訪問修飾符
具有默認的訪問特性，即具有包訪問特性，只能被同一個包中的類使用。
2.public訪問修飾符
用於說明類和類的成員的訪問許可權。這種類叫公有類。在一個文件中只能有一個public類型的類。
例如：Rect和UseImport兩個類，分別在兩個不同的包中。順便回顧一下不同類要用import導入。（哎，一直就沒記住）
//Rect.java
pacakage my;
public class Rect
{
private int a,b;
public void init(int len,int width)
{
a=len;
b=width;
}
public int area()
{
return a*b;
}
}
//UseImport.java
import.my.*;//導入my 包的所有類
public class UseImport
{
public static void main(string[] args)
{
Rect x=new Rect();
x.init(2,3);
System.out.println("矩形面積為："+x.area());
}
}
3.private
用private修飾的類成員成為私有成員，只能在聲明該成員的類中使用，不能在類外使用。一般通過本類中公有方法進行訪問。
4.protected
protected修飾的類成員為保護成員，可以被三種類使用，分別是該類本身，該類的所有子類，該類同包的其他類，該類的子類。
5.private protected
私有保護成員。可被兩種類使用。分別是：該類本身和該類的所有子類。
二：特徵修飾符
1.abstract：抽象
修飾類為抽象類，修飾方法為抽象方法。只要類中有抽象方法，就必須定義為抽象類。抽象方法只能聲明，不能實現。但是可以在其子類中對抽象方法進行實現。抽象類中也可以包含非抽象方法。
2.final：最終
修飾的類為終止類，不能有子類。修飾變數為終止變數，只可賦值一次。修飾方法為終止方法，不能在子類中更改。如Socket、ServerSocket等都是final類，防止黑客派生子類進行破壞。同時，final與abstract是相互矛盾的。
3.static：靜態
靜態成員無需通過對象調用，可以直接通過類名直接調用。
public class RectArea//輸出6 和 12
{
public static void main(String[] args)
{
System.out.println(area(2,3));
System.out.println(area(3,4));
}
static void area(int a,int b)

『伍』 java默認方法的修飾符是什麼

默認什麼都不加，就是default（不用把default寫出來）。
意思就是只能由跟這個類在同一個包中的類來訪問，比private限制更少，但比protected限制更多。'
Java訪問修飾符包括private，default，protected和public。含義分別表示私有的，默認的，受保護的和公有的訪問修飾符。這些訪問修飾符既可以修飾類中的屬性，又可以修飾類中的方法，而public和default還可以修飾類。在同一個java文件里，公有類有且僅有一個，並且該文件命名為類名.java。
Java訪問修飾符就是確定類中屬性或方法的訪問許可權，換句話說，就是這些屬性和方法所起的作用范圍。
private，私有的訪問許可權，也是最嚴格的訪問許可權，僅只能在設置了該許可權的類中訪問，利用這個訪問許可權，表現出封裝思想。
default，默認的訪問許可權，也是可以省略的訪問許可權，它不僅能在設置了該許可權的類中訪問，也可以在同一包中的類或子類中訪問。
protected，受保護的訪問許可權，它除了具有default的訪問許可權外，還可以在不同包中所繼承的子類訪問。
public，公有的訪問許可權，也是最寬松的訪問許可權，不僅可以是同一個類或子類，還是同一個包中的類或子類，又還是不同包中的類或子類，都可以訪問。
要想更深入地理解這些訪問許可權，一方面需要明白各自的作用域，另一方面更是要弄清楚各自所體現出來的編程思想，比方說，prvite表現的封裝思想，public表現的面向介面編程的思想等。
在面向對象設計和編程的過程中，歸根結底就是類的設計。而要設計出不僅滿足當前需求同時也能符合未來需求的類，就很有必要對類中屬性和行為設置合適的訪問
許可權。那些應該為私有的，那些又應該為公有的，還有那些又應該為受保護的等，都應該給予合理的規劃和布局，一來保證程序的功能要求，二來要體現程序的擴展
性能，三來要呈現程序友好性質。總之，程序應該更好地服務用戶。而訪問許可權在這樣宏偉目標里扮演著重要角色。

『陸』 java中類修飾符有哪些

java的修飾符有：許可權修飾符：public、protected、default、private

修飾符：abstract、static、final

public 使用對象：最廣，類、介面、變數、方法

protected使用對象：變數、方法 注意：不能修飾類（外部類）

default 使用對象：類、介面、變數、方法。（即預設，什麼也不寫）

private 使用對象：變數、方法 注意：不能修飾類（外部類）

abstract使用對象：類、介面、方法

static 使用對象：類、變數、方法、初始化函數（注意：修飾類時只能修飾 內部類 ）

final 使用對象：類、變數、方法

transient：告訴編譯器，在類對象序列化的時候，此變數不需要持久保存

volatile：指出可能有多個線程修改此變數，要求編譯器優化以保證對此變數的修改能夠被正確的處理

native：用該修飾符定義的方法在類中沒有實現，而大多數情況下該方法的實現是用C、C++編寫的。

synchronized：修飾方法，多線程的支持

類分外部類和內部類，他們的訪問控制是相同的嗎

外部類是相對於內部類而言的，內部類是定義在類裡面的類。

外部類的修飾符有：

default（預設，不寫）：類定義時前面未加任何修飾符，表示同一個包中可見。

public：修飾類時表示該類能被項目中所有類可見

abstract：表示是抽象類

final：表示類不可以被繼承

scrictpf:(java關鍵字) 當對一個類或介面使用 strictfp 關鍵字時，該類中的所有代碼，包括嵌套類型中的初始設定值和代碼，都將嚴格地進行計算。嚴格約束意味著所有表達式的結果都必須是 IEEE 754 演算法對操作數預期的結果，以單精度和雙精度格式表示

內部類又分：成員內部類、局部內部類、靜態內部類、匿名內部類

成員內部類：作為外部類的一個成員存在，與外部類的屬性、方法並列

局部內部類：定義在外部類的方法體裡面的類

靜態內部類：使用static修飾的內部類

匿名內部類：就是沒有名字的內部類

成員內部類修飾符有：

public：

protected：

private：private不能修飾外部類，

abstract：

final：

static：可以當做普通類使用，而不用先實例化一個外部類。（用他修飾後，就成了靜態內部類了）

strictfp：（java關鍵字） 即 strict float point (精確浮點)。（可修飾類、介面、方法）

(6)java修飾符擴展閱讀：

java中的類修飾符、成員變數修飾符、方法修飾符。

類修飾符：

public（訪問控制符），將一個類聲明為公共類，他可以被任何對象訪問，一個程序的主類必須是公共類。

abstract，將一個類聲明為抽象類，沒有實現的方法，需要子類提供方法實現。

final，將一個類生命為最終（即非繼承類），表示他不能被其他類繼承。

friendly，默認的修飾符，只有在相同包中的對象才能使用這樣的類。

成員變數修飾符：

public（公共訪問控制符），指定該變數為公共的，他可以被任何對象的方法訪問。

private（私有訪問控制符）指定該變數只允許自己的類的方法訪問，其他任何類（包括子類）中的方法均不能訪問。

protected（保護訪問控制符）指定該變數可以別被自己的類和子類訪問。在子類中可以覆蓋此變數。

friendly ，在同一個包中的類可以訪問，其他包中的類不能訪問。

final，最終修飾符，指定此變數的值不能變。

static（靜態修飾符）指定變數被所有對象共享，即所有實例都可以使用該變數。變數屬於這個類。

transient（過度修飾符）指定該變數是系統保留，暫無特別作用的臨時性變數。

volatile（易失修飾符）指定該變數可以同時被幾個線程式控制制和修改。

方法修飾符：

public（公共控制符）

private（私有控制符）指定此方法只能有自己類等方法訪問，其他的類不能訪問（包括子類）

protected（保護訪問控制符）指定該方法可以被它的類和子類進行訪問。

final，指定該方法不能被重載。

static，指定不需要實例化就可以激活的一個方法。

synchronize，同步修飾符，在多個線程中，該修飾符用於在運行前，對他所屬的方法加鎖，以防止其他線程的訪問，運行結束後解鎖。

native，本地修飾符。指定此方法的方法體是用其他語言在程序外部編寫的。

『柒』 java 三種訪問修飾符各如何使用

public 在任何地方都可訪問 protected同包之間可以訪問非同包子類可以訪問 默認友好類:同包可以訪問 private本類可以訪問
下面是三大修飾符,你也順便看看吧

如果一個類中如果有抽象方法,那麼這個類必須是抽象類 , 抽象類中未必有抽象方法
抽象類抽象方法 抽象類中可以有抽象方法,也可以有實例方法 抽象方法只能聲明,不能實現後面用 ; 結尾
抽象類的子類如果不希望成為抽象類,那麼它就必須去實現父類中所有的抽象方法
抽象類允許定義構造方法
抽象類 只能聲明引用 , 不能創建對象
抽象方法不能與static 一起使用 , abstract 類中的方法必須在子類中重寫 ,並實現多態
Static 只能繼承並重寫父類中方法 , 但是不能實現多態 .
抽象方法不能與final 一起使用 , final 修飾的方法不能夠在子類中覆蓋,而抽象方法是必須要求要在子類中覆蓋的.
抽象類不能與private一起使用,抽象類中的方法都必須要在子類中重寫後實現,而private修飾的方法不能繼承,更談不上重寫覆蓋
Static

靜態的 . 可修飾 : 方法, 成員變數(屬性)
靜態屬性全類共有,由類名調用
靜態方法中只能訪問非靜態的成員(屬性+方法);
靜態方法可以被覆蓋,但是沒有多態

靜態初始化代碼塊
在類載入的時候,執行一次

類載入: 1 . 需要的話,先載入父類(可能父類已經載入過 ,這時候就可以不用載入父類了)
2 . 為靜態屬性分配空間並初始化
3 . 按順序執行靜態初始化代碼塊
Final

可修飾: 變數(局部變數和成員變數) : 賦值後不能再發生改變
方法 : final 修飾後的方法不能被覆蓋 ,但可以繼承
類 : final類不能被子類繼承
Final修飾屬性時候 , 屬性此時沒有默認值. 此時可以初始化屬性值,或者構造方法中賦值
一般情況下常量為 public static , 常量名全部大寫

這是我學習時候的筆記,希望對你有所幫助

『捌』 java中有幾種修飾符

java中的修飾符分為類修飾符，欄位修飾符，方法修飾符。根據功能的不同，主要分為以下五種。

1、許可權訪問修飾符

public,protected,default,private,這四種級別的修飾符都可以用來修飾類、方法和欄位。

(8)java修飾符擴展閱讀：

修飾符的特點：

static是一個修飾符，用於修飾成員(成員變數和成員函數)

靜態成員隨著類的載入而載入。靜態成員優先於對象存在。靜態成員被所有對象所共享靜態成員多了一個中調用方式，可以被類名直接調用。

使用的注意事項：

靜態方法只能訪問靜態成員, 非靜態方法既可以訪問靜態又可以訪問非靜態。靜態方法中不可以定義this，super關鍵字。因為this代表是對象。而靜態存在時，有可能沒有對象。所以靜態方法運行時，this是沒有任何對象代表的。

簡單說，先進內存的數據不可以訪問後進內存的數據，可是後進內存數據可以訪問先進內存的數據。主函數是靜態的。

『玖』 java 的訪問修飾符是什麼

Java中的訪問修飾符

Java面向對象的基本思想之一是封裝細節並且公開介面。Java語言採用訪問控制修飾符來控制類及類的方法和變數的訪問許可權，從而向使用者暴露介面，但隱藏實現細節。訪問控制分為四種級別：

（1）public： 用public修飾的類、類屬變數及方法，包內及包外的任何類（包括子類和普通類）均可以訪問；

（2）protected： 用protected修飾的類、類屬變數及方法，包內的任何類及包外那些繼承了該類的子類才能訪問（此處稍後解釋），protected重點突出繼承；

（3）default： 如果一個類、類屬變數及方法沒有用任何修飾符（即沒有用public、protected及private中任何一種修飾），則其訪問許可權為default（默認訪問許可權）。默

認訪問許可權的類、類屬變數及方法，包內的任何類（包括繼承了此類的子類）都可以訪問它，而對於包外的任何類都不能訪問它（包括包外繼承了此類的子類）。default重點突出包；

（4）private： 用private修飾的類、類屬變數及方法，只有本類可以訪問，而包內包外的任何類均不能訪問它。

網上一些資料及一些書上用表格對java訪問修飾符做了清楚的總結，如下表所示：

重要總結：通過上面的分析，我們可以看到：

1.public、private和protected對我們來說沒有任何異議。

2. 頂層類只能用public訪問修飾符和default（默認）訪問修飾符修飾，其中用默認修飾符修飾的類（及沒有任何修飾符的類，如class B{}）不能被其他包中的類繼承，這也說明了default（默認）訪問修飾符突出的是包許可權

3. protected：本人做了一次實驗，發現在不同包的子類中，new一個父類對象，並用該父類對象去訪問父類中的用protected修飾的類屬變數和方法時不能訪問，而new一個子類對象時，子類對象可以訪問（說明protected修飾的類可以被其他包中的類繼承）。也可以在子類重寫父類的方法中使用super關鍵字調用。這豈不是和上面表格中的總結（紅色對勾）沖突了？本人也是百思不得其解。最後在網上找到了一個相對比較認可的解釋，如下：

protected修飾符的修飾的成員變數和方法也稱為受保護的成員變數和方法， 受保護的成員變數和方法可以在本類或同一個包中的其它類（包括子類）中通過類的實例進行訪問，也可以被同一個包中的類或不同包中的類繼承，但是不能在不同包中的其它類（包括子類）中通過類的實例進行訪問。

4. 如果一個類使用public修飾，那該類的類名必須與他所在的源文件名相同。一個.java源文件中有且只有一個public類，頂層類只能用public和默認修飾符（即無修飾符）修飾；

5.final修飾的類不能被繼承，沒有子類。

6.abstract修飾的類不能被實例化，必須被子類繼承。類只要有一個抽象方法就必定是抽象類，但抽象類不一定要有抽象方法。

最終總結，就一句話：protected修飾符所修飾的類（這句話中指父類）屬成員變數和方法，只可以被子類訪問，而不管子類是不是和父類位於同一個包中。default修飾符所修飾的類屬成員變數和方法，只可被同一個包中的其他類訪問，而不管其他類是不是該類的子類。protected屬於子類限制修飾符，而default屬於包限制修飾符。

『拾』 java中修飾符是什麼用來干什麼的

public 是訪問修飾符 就是訪問級別的設置

Public
所有包所有地方都可以訪問

Protected
同包以及子類可以訪問

Friendly(default)
同包可以訪問

Private
除了當前類任何地方都不可以訪問

static 修飾的話就是靜態塊、只會執行一次