java類的修飾符

⑴ java默認方法的修飾符是什麼

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

⑵ 在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介面的修飾符有哪些

1、 介面的修飾符只有：public 2、 類的修飾符分為：可訪問控制符和非訪問控制符兩種。 可訪問控制符是：公共類修飾符 public 非訪問控制符有：抽象類修飾符 abstract ；最終類修飾符 final 1、公共類修飾符public： Java 語言中類 的可訪問控制符只有一個： public 即公共的。每個 Java 程序的主類都必須是 public 類作為公共工具供其它類和程序使用的應定義為 public 類。 2 、抽象類修飾符abstract：凡是用 abstract 修飾符修飾的類，被稱為抽象類。所謂抽象類是指這種類沒有具體對象的一種概念類。這樣的類就是 Java 語言的 abstract 類。 3、最終類修飾符final：當一個類不可能有子類時可用修飾符 final 把它說明為最終類。被定義為 final 的類通常是一些有固定作用、用來完成某種標准功能的類。 4、類預設訪問控制符：如果一個類沒有訪問控制符，說明它具有預設的訪問控制符特性。此時，這個類只能被同一個包中的類訪問或引用。這一訪問特性又稱為包訪問性。 3、屬性的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。 可訪問控制符有 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 虛擬機認定該暫時性變數不屬於永久狀態，以實現不同對象的存檔功能。否則，類中所有變數都是對象的永久狀態的一部分，存儲對象時必須同時保存這些變數。 4、方法的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。 可訪問控制符有 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 ：該修飾符主要用於多線程共存的程序中的協調和同步。

⑷ java中有幾種修飾符

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

1、許可權訪問修飾符

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

(4)java類的修飾符擴展閱讀：

修飾符的特點：

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

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

使用的注意事項：

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

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

⑸ java的介面，類，屬性，方法各有哪些修飾符

1、 介面的修飾符只有：public
2、 類的修飾符分為：可訪問控制符和非訪問控制符兩種。
可訪問控制符是：公共類修飾符 public
非訪問控制符有：抽象類修飾符 abstract ；最終類修飾符 final
3、屬性的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。
可訪問控制符有 4 種：公共訪問控制符： public ；私有訪問控制符： private ；保護訪問控制符： protected ；私有保護訪問控制符： private protected
非訪問控制符有 4 種：靜態域修飾符： static ；最終域修飾符： final ；易失 ( 共享 ) 域修飾符： volatile ；暫時性域修飾符： transient
4、方法的控制修飾符也分為：可訪問控制符和非訪問控制符兩類。
可訪問控制符有 4 種：公共訪問控制符： public ；私有訪問控制符： private ；保護訪問控制符： protected ；私有保護訪問控制符： private protected
非訪問控制符有 5 種：抽象方法控制符： abstract ；靜態方法控制符： static ；最終方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized

⑹ Java中目前學習涉及到的四種許可權修飾符都有什麼並說明各自的許可權范圍

（1）public : 公共許可權

修飾對象： 修飾類、方法、屬性

繼承： 被public所修飾的成員能被該類的所有子類繼承下來。

作用域： 可以被任意類訪問

public能用來修飾類，在一個java源文件中只能有一個類被聲明為public，而且一旦有一個類為public，那這個java源文件的文件名就必須要和這個被public所修飾的類的類名相同，否則編譯不能通過。說到這里，穿插多一點知識。一個類作為外部類的時候只能被public或者默認訪問修飾符所修飾，但是一個類如果作為內部類的時候，則可以被四種訪問修飾符所修飾，因為一個類作為內部類的時候，就作為外部類的一個成員屬性了，因此可以有四種訪問修飾符修飾，這是內部類和外部類的一個區別。

public用來修飾類中成員(變數和方法)，被public所修飾的成員可以在任何類中都能被訪問到。通過操作該類的對象能隨意訪問public成員。

public在類的繼承上的體現，被public所修飾的成員能被所有的子類繼承下來。

（2）protected：受保護的許可權

修飾對象：修飾內部類，介面，屬性，方法

繼承： 被protected所修飾的成員能被該類的所有子類繼承下來。

作用域： 可以被同包類訪問，如果不是同包，必須是該類的子類才能訪問

（3）default : 同包許可權(默認，預設的)

修飾對象：修飾類，屬性，方法。

繼承：被default所修飾的成員只能被該類所在同一個package中的子類所繼承下來。(也就是說只有在同一個package中的子類才能訪問到父類中default修飾的成員)

作用域： 只能被同包的類訪問

（4） private : 私有許可權

修飾對象 ： 內部類，屬性，方法

作用域： 只能在本類中使用

注意：

（1）protected不能修飾類。

（2）priavte可以修飾類，但是該類必須是一個內部類。

在定義類時，推薦訪問控制級別從嚴處理：

（1） 如果不允許外部直接通過 new 創建對象，構造方法必須是 private。

（2）工具類不允許有 public 或 default 構造方法。

（3）類非 static 成員變數並且與子類共享，必須是 protected。

（4）類非static成員變數並且僅在本類使用，必須是private。

（5）類 static 成員變數如果僅在本類使用，必須是 private。

（6）若是 static 成員變數，必須考慮是否為 final。

（7）類成員方法只供類內部調用，必須是 private。

（8）類成員方法只對繼承類公開，那麼限制為 protected。

⑺ java的介面、類、屬性、方法各有哪些修飾符

1、
介面的修飾符只有:public
2、
類的修飾符分為:可訪問控制符和非訪問控制符兩種。
可訪問控制符是:公共類修飾符
public
非訪問控制符有:抽象類修飾符
abstract
;最終類修飾符
final
1、公共類修飾符public:
Java
語言中類
的可訪問控制符只有一個:
public
即公共的。每個
Java
程序的主類都必須是
public
類作為公共工具供其它類和程序使用的應定義為
public
類。
2
、抽象類修飾符abstract:凡是用
abstract
修飾符修飾的類，被稱為抽象類。所謂抽象類是指這種類沒有具體對象的一種概念類。這樣的類就是
Java
語言的
abstract
類。
3、最終類修飾符final:當一個類不可能有子類時可用修飾符
final
把它說明為最終類。被定義為
final
的類通常是一些有固定作用、用來完成某種標准功能的類。
4、類預設訪問控制符:如果一個類沒有訪問控制符，說明它具有預設的訪問控制符特性。此時，這個類只能被同一個包中的類訪問或引用。這一訪問特性又稱為包訪問性。
3、屬性的控制修飾符也分為:可訪問控制符和非訪問控制符兩類。
可訪問控制符有
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
虛擬機認定該暫時性變數不屬於永久狀態，以實現不同對象的存檔功能。否則，類中所有變數都是對象的永久狀態的一部分，存儲對象時必須同時保存這些變數。
4、方法的控制修飾符也分為:可訪問控制符和非訪問控制符兩類。
可訪問控制符有
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
:該修飾符主要用於多線程共存的程序中的協調和同步。

⑻ 在java中能用private修飾類嗎

一般的類是不能用private修飾，類的可見性最少是包可見的，也就是默認的，不加任何修飾。
但是有一種特殊的情況，內部類是可以用private修飾的！不讓類以外的其他類訪問！這個問題在《java核心技術》里有講！

Java的外部類為什麼不能使用private、protected進行修飾？

對於頂級類(外部類)來說，只有兩種修飾符：public和默認(default)。因為外部類的上一單元是包，所以外部類只有兩個作用域：同包，任何位置。

因此，只需要兩種控制許可權：包控制許可權和公開訪問許可權，也就對應兩種控制修飾符：public和默認(default)。

如果類使用了private修飾符，說明是個內部類。內部類的上一級是外部類，那麼對應的有四種訪問控制修飾符：本類(private)，同包(default)，父子類(protected)，任何位置(public)。

當一個內部類使用了private修飾後，只能在該類的外部類內部使用。可以想一下，一個java項目是不可能在一個class裡面完成的。

mvc模式中，是把類分為三層，一層層調用類。如果定義為私有的和受保護的就無法調用。換句話說，對於一個java文件，要麼就是自己單獨運行，要麼就是被其他程序作為庫調用。

如果一個java文件的類被private修飾，那麼是不是其他的程序或是類是無法使用它的，那麼他作為一個單獨的文件就沒啥用了。

如果它作為單個文件運行，類載入怎麼找到它呢，因為它對外不可見。同時，也失去了類的存在意義。因此，類只有public和默認修飾符。

⑼ 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中修飾符有哪些

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 (精確浮點)。（可修飾類、介面、方法）

(10)java類的修飾符擴展閱讀：

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

類修飾符：

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

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

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

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

成員變數修飾符：

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

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

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

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

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

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

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

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

方法修飾符：

public（公共控制符）

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

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

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

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

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

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