java類修飾符,java類修飾符,訪問修飾符

本文目錄一覽：

• 1、在java中一個類的修飾符有哪些
• 2、Java內部類的修飾符有哪些?
• 3、java中有幾種修飾符？

在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內部類的修飾符有哪些?

一、內部類可以為四種：

⒈ 靜態內部類

⒉ 成員內部類

⒊ 局部內部類

⒋

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

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中的修飾符分為類修飾符，欄位修飾符，方法修飾符。根據功能的不同，主要分為以下五種。

1、許可權訪問修飾符

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

2、final修飾符

final的意思是不可變，他可以修飾類、欄位、方法。修飾類後類不能被擴展（extends），也就是不能被繼承。修飾欄位後欄位的值不能被改變，因此如果有final修飾欄位，應該對欄位進行手動初始化。修飾方法後該方法不能被改變，也就是重寫。

3、abstract修飾符

abstract是抽象的意思，用來修飾類和方法，修飾類後，該類為抽象類，不能被實例化，必需進行擴展。修飾方法後，該方法為抽象方法必須被子類重寫（override）。

4、static修飾符

static用來修飾內部類，方法，欄位。修飾內部類說明該內部類屬於外部類而不屬於外部類的某個實例。修飾欄位說明該欄位屬於類而不屬於類實例。修飾方法說明該方法屬於類而不屬於類實例

5、volatile修飾符

易失 ( 共享 ) 域修飾符 volatile 是用來說明這個成員變數可能被幾個線程所控制和修改。也就是說在程序運行過程中，這個成員變數有可能被其它的程序影響或改變它的取值。

擴展資料：

修飾符的特點：

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

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

使用的注意事項：

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

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