⑴ 在Java中用什麼關鍵字修飾的方法可以直接
在java中用static修飾的方法可以直接用（類名.方法名）的方式訪問，因為靜態成員變數和方法是在類載入的時候初始化的，而且只初始化一次，是共享的。只與類相關，與對象無關。
⑵ 怎麼理解這些個關鍵字啊，public;private;protect;final;static;const;我感覺這些
public: 公有屬性或方法
在子類中可以通過self::var 或self::method 來調用,可以通過parent::method來調用父類中的方法,但不能調用公有屬性.
在實例中可以通過$obj->var或self::method 來調用
protected: 受保護類型
在子類中可以通過self::var 或self::method調用,可以通過parent::method來調用父類中的方法
在實例中不能通過$obj->var 來調用 protected類型的方法或屬性
private: 私有類型
該類型的屬性或方法只能在該類中使用，在該類的實例、子類中、子類的實例中都不能調用私有類型的屬性和方法
再來說說final
1.final不能用來修飾成員屬性
2.final只能修飾類和方法
作用：被修飾的類不能被子類所繼承；被修飾的方法不能被子類的方法覆蓋。
然後來說說static
1.static用來修飾成員屬性和成員方法，但不能用來修飾類
2.用static修飾的成員屬性可以被同一個類的所有對象共享
3.靜態的數據是存在 內存中的 數據段中（初始化靜態段）
4.靜態的數據是在類在第一次載入時，分配到內存中的
5.什麼是類被載入？只要在程序中使用到這個類（有這個類名出現）
6.靜態的成員屬性都要用類名去訪問，不用創建對象，不用對象去訪問；在類里邊可以用self代表本類（$this）
7.靜態方法，不能訪問非靜態的成員屬性（但是，在非靜態方法卻能訪問靜態的成員屬性），非靜態的成員屬性，必須用對象訪問，在內部訪問非靜態成員屬性，用$this.
8.如果你確定一個方法中不需使用到非靜態的成員屬性，則可以將這個方法聲明為靜態方法，不需實例化對象，就可以訪問
最後來說說const
1.它只能用來修飾成員屬性
2.在類中聲明常量必須使用const
3.訪問方式和訪問靜態成員屬性一樣（類外使用 類名::成員屬性，類里邊則使用self::成員屬性）
4.常量一定要在聲明的時候就給初始值
⑶ java介面，抽象類，ststic關鍵字，修飾符得運用。求全解。
Abstract(抽象)可以修飾類、方法
如果將一個類設置為abstract，則此類必須被繼承使用。此類不可生成對象，必須被繼承使用。
Abstract可以將子類的共性最大限度的抽取出來，放在父類中，以提高程序的簡潔性。
Abstract雖然不能生成對象，但是可以聲明，作為編譯時類型，但不能作為運行時類型。
Final和abstract永遠不會同時出現。
Abstract和static不能放在一起，否則便會出現錯誤。（這是因為static不可被覆蓋，而abstract為了生效必須被覆蓋。）
當abstract用於修飾方法時，此時該方法為抽象方法，此時方法不需要實現，實現留給子類覆蓋，子類覆蓋該方法之後方法才能夠生效。
JAVA的核心概念：介面（interface）
介面與類屬於同一層次，實際上，介面是一種特殊的抽象類。
如:
interface IA{
}
private void print(){}；此語句表示方法的空實現。
Abstract void print()； 此語句表示方法的抽象，無實現。
public interface：公開介面
與類相似，一個文件只能有一個public介面，且與文件名相同。
在一個文件中不可同時定義一個public介面和一個public類。
一個介面中，所有方法為公開、抽象方法；所有的屬性都是公開、靜態、常量。
一個類實現一個介面的格式：
class IAImple implements IA{
};
類必須實現介面中的方法，否則其為抽象類。
介面中可不寫public，但在子類中實現介面的過程中public不可省。
① 一個類除繼承另外一個類，還可以實現介面；
變相的多繼承。
② 一個類只能繼承另外一個類，但是它可以實現多個介面，中間用逗，地隔開。
Implements IA,IB
所謂實現一個介面，就是指實現介面中的方法。
③ 介面和介面之間可以定義繼承關系，並且介面之間允許實現多繼承。
面向對象高級： 修飾符：
static:①可修飾變數（屬性）；②可修飾方法；③可修飾代碼塊。
Static int data語句說明data為類變數，為一個類的共享變數，屬於整個類。
Int data為實例變數。
例：
static int data;
m1.data=0;
m1.data++的結果為1,此時m2.data的結果也為1。
Static定義的是一塊為整個類共有的一塊存儲區域，其發生變化時訪問到的數據都時經過變化的。
其變數可以通過類名去訪問：類名.變數名。與通過訪問對象的編譯時類型訪問類變數為等價的。
Public static void printData(){}
表明此類方法為類方法（靜態方法）
靜態方法不需要有對象，可以使用類名調用。
靜態方法中不允許訪問類的非靜態成員，包括成員的變數和方法，因為此時是通過類調用的，沒有對象的概念。This.data是不可用的。
一般情況下，主方法是靜態方法，所以可調用靜態方法，主方法為靜態方法是因為它是整個軟體系統的入口，而進入入口時系統中沒有任何對象，只能使用類調用。
覆蓋不適用於靜態方法。
靜態方法不可被覆蓋。（允許在子類中定義同名靜態方法，但是沒有多態，嚴格的講，方法間沒有多態就不能稱為覆蓋）
當static修飾代碼塊時（註：此代碼塊要在此類的任何一個方法之外），那麼這個代碼塊在代碼被裝載進虛擬機生成對象的時候可被裝載一次，以後再也不執行了。
一般靜態代碼塊被用來初始化靜態成員。
⑷ 關於java的static我很暈
首先你得理解什麼是類屬性和對象屬性，加static修飾的屬性是類屬性的充分必要條件，因此不加static的屬性就是對象屬性。
那區別是什麼呢？
靜態變數分配空間是在程序開始運行的時候自動完成的，因此你可以使用類名直接訪問，如：Math.PI。
非靜態變數（對象變數）是在對象初始化以後才分配空間，以後才能使用。如：Testt=newT()；t.shuxing;這個之後shuxing就有內存空間啦，你就可以訪問了。
給你說說圖片上的錯誤你就明白啦
1.22行錯誤時因為主方法裡面訪問的a是對象屬性，此時a還沒有分配空間，因此會有錯誤，只有new之後才能用對象訪問它。但是23行就不會有錯誤啦，因為b是static的，此時已經有了內存空間
2.25行錯誤是因為在f_4()裡面訪問了非靜態屬相a，此時a還是沒有分配空間，所以就出錯啦，這也是樓主遇到的問題。
3.即使方法裡面都是靜態屬性，也不可以直接調用，如：24行所示。這是Java的語法規定，可能是為了簡化語法才這樣做的。
⑸ java類中的方法用那些修飾符修飾可以直接使用類名調用
static，靜態函數可以直接用類名調用
⑹ java 問題
靜態的方法可以直接使用類名.方法名的方式直接調用，但是非靜態的方法必須要先有這個類的對象才可以調用，即dalek d=new dalek();然後d.speak();有時候某些方法我們希望不需要對象就可以調用時，就使用靜態方法，比如工具類，我們在使用工具類的時候，通常將裡面的方法寫成靜態的，那麼調用這些方法的時候就不需要先創建工具類對象了；靜態方法在載入到內存中也與非靜態的方法不一樣，靜態方法在類載入時，就一起載入到內存的靜態方法區中，而非靜態的方法，是在擁有對象調用以後才加進堆內存中。
⑺ java 類中的public屬性修飾
我覺得你想知道的並不僅僅是public修飾符的問題,對於繼承也很模糊可能,繼承的時候為什麼可以引用被繼承類或者說基礎類中的public方法?難道真的是只要繼承就可以,而另一個非繼承的類想用的時候就要先創建對象（在這里不討論方法是static情況）？其實繼承的時候是一樣的,只不過這個過程被隱藏掉了,一旦繼承,必然會在子類中創建一個父類的對象做為子類的成員,必然會調用父類的構造函數,這時你才可以調用super.method()的,這在《think in java》第6章有詳細的解釋和代碼示例可以看一下。
⑻ 在Java中用什麼關鍵字修飾的方法可以直接通過類名來調用
答應該是:A.static B.final C.private D.void
⑼ 在java中，所有的屬性和方法只能通過對象.來調用
不對，靜態的屬性可以直接通過類調用
⑽ Java中的關鍵字static和final的作用
final
根據程序上下文環境，Java關鍵字final有「這是無法改變的」或者「終態的」含義，它可以修飾非抽象類、非抽象類成員方法和變數。你可能出於兩種理解而需要阻止改變：設計或效率。
final類不能被繼承，沒有子類，final類中的方法默認是final的。
final方法不能被子類的方法覆蓋，但可以被繼承。
final成員變數表示常量，只能被賦值一次，賦值後值不再改變。
final不能用於修飾構造方法。
注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。
1、final類
final類不能被繼承，因此final類的成員方法沒有機會被覆蓋
，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現細節不允許改變，並且確信這個類不會載被擴展，那麼就設計為final類。
2、final方法
如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。
使用final方法的原因有二：
第一、把方法鎖定，防止任何繼承類修改它的意義和實現。
第二、高效。編譯器在遇到調用final方法時候會轉入內嵌機制，大大提高執行效率。
例如：
publicclassTest1{
publicstaticvoidmain(String[]args){
//TODO自動生成方法存根
}
publicvoidf1(){
System.out.println("f1");
}
//無法被子類覆蓋的方法
publicfinalvoidf2(){
System.out.println("f2");
}
publicvoidf3(){
System.out.println("f3");
}
privatevoidf4(){
System.out.println("f4");
}
}
publicclassTest2extendsTest1{
publicvoidf1(){
System.out.println("Test1父類方法f1被覆蓋!");
}
publicstaticvoidmain(String[]args){
Test2t=newTest2();
t.f1();
t.f2();//調用從父類繼承過來的final方法
t.f3();//調用從父類繼承過來的方法
//t.f4();//調用失敗，無法從父類繼承獲得
}
}3、final變數（常量）
用final修飾的成員變數表示常量，值一旦給定就無法改變！
final修飾的變數有三種：靜態變數、實例變數和局部變數，分別表示三種類型的常量。
從下面的例子中可以看出，一旦給final變數初值後，值就不能再改變了。
另外，final變數定義的時候，可以先聲明，而不給初值，這中變數也稱為final空白，無論什麼情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關鍵字final的使用上提供了更大的靈活性，為此，一個類中的final數據成員就可以實現依對象而有所不同，卻有保持其恆定不變的特徵。
packageorg.leimin;
publicclassTest3{
privatefinalStringS="final實例變數S";
privatefinalintA=100;
publicfinalintB=90;
publicstaticfinalintC=80;
privatestaticfinalintD=70;
publicfinalintE;//final空白,必須在初始化對象的時候賦初值
publicTest3(intx){
E=x;
}
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
Test3t=newTest3(2);
//t.A=101;//出錯,final變數的值一旦給定就無法改變
//t.B=91;//出錯,final變數的值一旦給定就無法改變
//t.C=81;//出錯,final變數的值一旦給定就無法改變
//t.D=71;//出錯,final變數的值一旦給定就無法改變
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C);//不推薦用對象方式訪問靜態欄位
System.out.println(t.D);//不推薦用對象方式訪問靜態欄位
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E);//出錯,因為E為final空白,依據不同對象值有所不同.
System.out.println(t.E);
Test3t1=newTest3(3);
System.out.println(t1.E);//final空白變數E依據對象的不同而不同
}
privatevoidtest(){
System.out.println(newTest3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
publicvoidtest2(){
finalinta;//final空白,在需要的時候才賦值
finalintb=4;//局部常量--final用於局部變數的情形
finalintc;//final空白,一直沒有給賦值.
a=3;
//a=4;出錯,已經給賦過值了.
//b=2;出錯,已經給賦過值了.
}
}
4、final參數
當函數參數為final類型時，你可以讀取使用該參數，但是無法改變該參數的值。
publicclassTest4{
publicstaticvoidmain(String[]args){
newTest4().f1(2);
}
publicvoidf1(finalinti){
//i++;//i是final類型的,值不允許改變的.
System.out.print(i);
}
}
二、static
static表示「全局」或者「靜態」的意思，用來修飾成員變數和成員方法，也可以形成靜態static代碼塊，但是Java語言中沒有全局變數的概念。
被static修飾的成員變數和成員方法獨立於該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。只要這個類被載入，Java虛擬機就能根據類名在運行時數據區的方法區內定找到他們。因此，static對象可以在它的任何對象創建之前訪問，無需引用任何對象。
用public修飾的static成員變數和成員方法本質是全局變數和全局方法，當聲明它類的對象市，不生成static變數的副本，而是類的所有實例共享同一個static變數。
static變數前可以有private修飾，表示這個變數可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問許可權限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問許可權關鍵字的效果也以此類推。
static修飾的成員變數和成員方法習慣上稱為靜態變數和靜態方法，可以直接通過類名來訪問，訪問語法為：
類名.靜態方法名(參數列表...)
類名.靜態變數名
用static修飾的代碼塊表示靜態代碼塊，當Java虛擬機（JVM）載入類時，就會執行該代碼塊（用處非常大，呵呵）。
1、static變數
按照是否靜態的對類成員變數進行分類可分兩種：一種是被static修飾的變數，叫靜態變數或類變數；另一種是沒有被static修飾的變數，叫實例變數。兩者的區別是：
對於靜態變數在內存中只有一個拷貝（節省內存），JVM只為靜態分配一次內存，在載入類的過程中完成靜態變數的內存分配，可用類名直接訪問（方便），當然也可以通過對象來訪問（但是這是不推薦的）。
對於實例變數，沒創建一個實例，就會為實例變數分配一次內存，實例變數可以在內存中有多個拷貝，互不影響（靈活）。
2、靜態方法
靜態方法可以直接通過類名調用，任何的實例也都可以調用，因此靜態方法中不能用this和super關鍵字，不能直接訪問所屬類的實例變數和實例方法(就是不帶static的成員變數和成員成員方法)，只能訪問所屬類的靜態成員變數和成員方法。因為實例成員與特定的對象關聯！這個需要去理解，想明白其中的道理，不是記憶！！！
因為static方法獨立於任何實例，因此static方法必須被實現，而不能是抽象的abstract。
3、static代碼塊
static代碼塊也叫靜態代碼塊，是在類中獨立於類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內，JVM載入類時會執行這些靜態的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現的先後順序依次執行它們，每個代碼塊只會被執行一次。例如：
publicclassTest5{
privatestaticinta;
privateintb;
static{
Test5.a=3;
System.out.println(a);
Test5t=newTest5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
publicstaticvoidmain(String[]args){
//TODO自動生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
publicvoidf(){
System.out.println("hhahhahah");
}
}
運行結果：
3
hhahhahah
1000
4
5利用靜態代碼塊可以對一些static變數進行賦值，最後再看一眼這些例子，都一個static的main方法，這樣JVM在運行main方法的時候可以直接調用而不用創建實例。
4、static和final一塊用表示什麼
static final用來修飾成員變數和成員方法，可簡單理解為「全局常量」！
對於變數，表示一旦給值就不可修改，並且通過類名可以訪問。
對於方法，表示不可覆蓋，並且可以通過類名直接訪問。
特別要注意一個問題：
對於被static和final修飾過的實例常量，實例本身不能再改變了，但對於一些容器類型（比如，ArrayList、HashMap）的實例變數，不可以改變容器變數本身，但可以修改容器中存放的對象，這一點在編程中用到很多。
也許說了這么多，反倒把你搞暈了，還是看個例子吧：
publicclassTestStaticFinal{
="aaa";
=null;
privatefinalStringstrFinalVar=null;
=0;
=newInteger(8);
privatestaticfinalArrayList<String>alStaticFinalVar=newArrayList<String>();
privatevoidtest(){
System.out.println("-------------值處理前----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
//strStaticFinalVar="哈哈哈哈";//錯誤，final表示終態,不可以改變變數本身.
strStaticVar="哈哈哈哈";//正確，static表示類變數,值可以改變.
//strFinalVar="呵呵呵呵";//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
//intStaticFinalVar=2;//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
//integerStaticFinalVar=newInteger(8);//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
alStaticFinalVar.add("aaa");//正確，容器變數本身沒有變化，但存放內容發生了變化。這個規則是非常常用的，有很多用途。
alStaticFinalVar.add("bbb");//正確，容器變數本身沒有變化，但存放內容發生了變化。這個規則是非常常用的，有很多用途。
System.out.println("-------------值處理後----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
}
publicstaticvoidmain(Stringargs[]){
newTestStaticFinal().test();
}
}看了上面這個例子，就清楚很多了，但必須明白：通過static final修飾的容器類型變數中所「裝」的對象是可改變的。這是和一般基本類型和類類型變數差別很大的地方。