javastatic方法

A. java中方法前寫static方法的作用

用static修飾的，它會在內存中單獨放在一塊內存中，跟變數，對象不是在一塊內存中。在程序運行的時候就載入好，當程序結束的時候才會釋放內存。所以用static修飾的，就可以直接用
類名.方法名
就出來了，因為程序運行的時候就載入好這個方法了就不用再new一個對象去訪問這個方法了。

B. java中什麼是靜態方法

若類的方法前加了static關鍵字，則該方法稱為靜態方法，反之為實例方法。靜態方法為類所有，可以通過對象來使用，也可以通過類來使用。但一般提倡通過類名來使用，因為靜態方法只要定義了類，不必建立類的實例就可使用。靜態方法只能調用靜態變數。

C. java 靜態方法static

返回是1雖然在getInstance() ;里設置了a.i = 2 ;但是 a和a1並不是一個對象，i也不是靜態變數，所以getInstance() 並沒有對a1的i進行修改。
靜態方法可以不用new對象就可以執行，常用語創建單例對象。
靜態方法不是靜態變數，但是靜態方法要用的全局變數必須為靜態的。

D. java中關於static方法

是靜態修飾符，什麼叫靜態修飾符呢？大家都知道，在程序中任何變數或者代碼都是在編譯時由系統自動分配內存來存儲的，而所謂靜態就是指在編譯後所分配的內存會一直存在，直到程序退出內存才會釋放這個空間，也就是只要程序在運行，那麼這塊內存就會一直存在。這樣做有什麼意義呢？ 在Java程序裡面，所有的東西都是對象，而對象的抽象就是類，對於一個類而言，如果要使用他的成員，那麼普通情況下必須先實例化對象後，通過對象的引用才能夠訪問這些成員，但是有種情況例外，就是該成員是用static聲明的（在這里所講排除了類的訪問控制），例如： 未聲明為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用來修飾類成員的主要作用了，在java類庫當中有很多類成員都聲明為static，可以讓用戶不需要實例化對象就可以引用成員，最基本的有Integer.parseInt()，Float.parseFloat()等等用來把對象轉換為所需要的基本數據類型。這樣的變數和方法我們又叫做類變數和類方法。 接下來講一下被static修飾後的變數的值的問題，剛才在前面講過，被static修飾後的成員，在編譯時由內存分配一塊內存空間，直到程序停止運行才會釋放，那麼就是說該類的所有對象都會共享這塊內存空間，看一下下面這個例子： class TStatic{ static int i; public TStatic(){ i = 4; } public TStatic(int j){ i = j; } public static void main(String args[]){ TStatic t = new TStatic(5); //聲明對象引用，並實例化 TStatic tt = new TStatic(); //同上 System.out.println(t.i); System.out.println(tt.i); System.out.println(t.i); } } 這段代碼裡面Tstatic類有一個static的int變數I，有兩個構造函數，第一個用於初始化I為4，第二個用於初始化i為傳進函數的值，在main中所傳的值是5，程序首先聲明對象的引用t，然後調用帶參數的構造函數實例化對象，此時對象t的成員變數I的值為5，接著聲明對象tt，調用無參數的構造函數，那麼就把對象tt的成員變數i的值初始化為4了，注意了，在這里i是static，那就是說該類的所有對象都共享該內存，那也就是說在實例化對象tt的時候改變了i的值，那麼實際上對象t的i值也變了，因為實際上他們引用的是同一個成員變數。最後列印的結果是三個4。呵呵，寫到這里大家是否明白了呢？不明白就再看看書或者多寫幾個例子印證一下，呵呵。

E. Java中的靜態方法是什麼

靜態方法是在類中使用staitc修飾的方法，在類定義的時候已經被裝載和分配。

靜態方法為類所有，可以通過對象來使用，也可以通過類來使用。

我們之前一直寫的mian方法仔細看看，它就是一個靜態方法，靜態方法使用如下：

F. java中static怎麼用

static 屬於全局，也就是類的屬性 和方法，換句話說 一個類，不管有多少個實例，卻只有一個全局變數
class B {static int a=0;}
B b1=new B();..................；B bn=new B();
b1~bn 都是類B的實例，每個實例都共享 變數a，a是全局變數，屬於類B的屬性，每個實例都能引用變數a,
加入執行b1.a=1;後 那麼b2.a,b3.a,b4.a......bn.a 都等於1了，

static 方法也是類似的

需要注意的是 靜態屬性和方法屬於類方法，載入類後，就已經存在靜態屬性和方法，實例是需要用new構造出來後 才會有引用
根據先後順序，就有以下兩條規則
1、非靜態的方法可以調用靜態的或者非靜態的屬性和方法；
2、靜態的方法不可以調用非靜態的屬性和方法，因為非靜態的還不一定存在，只能先構造出來後，再通過實例引用
例如 在main方法中 可以直接調用static 的方法，調用非static方法 需要先構造出類的實例，通過實例才能調用方法

G. java中的方法，static代表什麼啥時候用

通常來說，當創建類時，除非用new創建那個類的對象，否則，實際上並沒有獲得任何對象。執行new來創建對象時，才分配數據存儲空間，其方法才能供外界調用。
但是如果想要即使沒有創建對象，也能調用這個方法。也就是說，希望某個方法不與它所在的類的任何對象關聯在一起。則要通過static來實現。如下:
class A{

public static void staticMethod(){}
public void nonStaticMethod(){}

}

1.當要調用staticMethod()，可以有兩種方式
第一：A.staticMethod();
第二：A a =new A() ;

a.staticMethod();

2. 對nonStaticMethod(){}，只有一種方式
A a =new A() ; //必須用new創建對象

a.nonStaticMethod() ;

其實學編程這東西，只要多敲代碼，查看執行結果。後面就會明白了。
如果還不明白的話，就看看別人寫的博客，有很多通俗易懂的例子。

H. java中static的用法

1.靜態方法
通常，在一個類中定義一個方法為static，那就是說，無需本類的對象即可調用此方法
聲明為static的方法有以下幾條限制：
·它們僅能調用其他的static 方法。
·它們只能訪問static數據。
·它們不能以任何方式引用this 或super。
class Simple {
staticvoid go() {
System.out.println("Welcome");
}
}

publicclass Cal {
publicstaticvoid main(String[] args) {
Simple.go();
}
}
調用一個靜態方法就是「類名.方法名」,靜態方法的使用很簡單如上所示。一般來說，靜態方法常常為應用程序中的其它類提供一些實用工具所用，在Java的類庫中大量的靜態方法正是出於此目的而定義的。

2.靜態變數
聲明為static的變數實質上就是全局變數。當聲明一個對象時，並不產生static變數的拷貝，而是該類所有的實例變數共用同一個static變數。靜態變數與靜態方法類似。所有此類實例共享此靜態變數，也就是說在類裝載時，只分配一塊存儲空間，所有此類的對象都可以操控此塊存儲空間，當然對於final則另當別論了
class Value {
staticintc = 0;

staticvoid inc() {
c++;
}
}

publicclass Count2 {
publicstaticvoid prt(String s) {
System.out.print(s);
}

publicstaticvoid main(String[] args) {
Value v1, v2;
v1 = new Value();
v2 = new Value();
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1.inc();
prt(" v1.c=" + v1.c + " v2.c=" + v2.c);
}
}
結果為：v1.c=0 v2.c=0 v1.c=1 v2.c=1
由此可以證明它們共享一塊存儲區。static變數有點類似於C中的全局變數的概念。

值得探討的是靜態變數的初始化問題。
如果你需要通過計算來初始化你的static變數，你可以聲明一個static塊，Static 塊僅在該類被載入時執行一次。下面的例子顯示的類有一個static方法，一些static變數，以及一個static 初始化塊：
class Value3 {
staticintc = 0;

Value3() {
c = 15;
}

Value3(int i) {
c = i;
}

staticvoid inc() {
c++;
}
}

publicclass Count {
publicstaticvoid prt(String s) {
System.out.println(s);
}

Value3 v = new Value3(10);
static Value3 v1, v2;
static {//此即為static塊
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1 = new Value3(27);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v2 = new Value3(15);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
}

publicstaticvoid main(String[] args) {
Count ct = new Count();
prt("ct.c=" + ct.v.c);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1.inc();
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
prt("ct.c=" + ct.v.c);
}
}

結果為：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11
這個程序展示了靜態初始化的各種特性。如果你初次接觸Java，結果可能令你吃驚。可能會對static後加大括弧感到困惑。首先要告訴你的是，static定義的變數會優先於任何其它非static變數，不論其出現的順序如何。正如在程序中所表現的，雖然v出現在v1和v2的前面，但是結果卻是v1和v2的初始化在v的前面。在static{後面跟著一段代碼，這是用來進行顯式的靜態變數初始化，這段代碼只會初始化一次，且在類被第一次裝載時。如果你能讀懂並理解這段代碼，會幫助你對static關鍵字的認識。在涉及到繼承的時候，會先初始化父類的static變數，然後是子類的，依次類推。

3．靜態類
通常一個普通類不允許聲明為靜態的，只有一個內部類才可以。這時這個聲明為靜態的內部類可以直接作為一個普通類來使用，而不需實例一個外部類。
publicclass StaticCls {
publicstaticvoid main(String[] args) {
OuterCls.InnerCls oi = newOuterCls.InnerCls();
}
}

classOuterCls {
publicstaticclass InnerCls {
InnerCls() {
System.out.println("InnerCls");
}
}
}
結果為：InnerCls

I. Java中static方法和普通方法的區別

static方法就是靜態方法。
靜態方法是類方法，類名即可引用。
普通方法是對象方法，需要實例化對象才可以引用

J. java 中static用法

static表示「全局」或者「靜態」的意思，用來修飾成員變數和成員方法，也可以形成靜態static代碼塊，但是Java語言中沒有全局變數的概念。
被static修飾的成員變數和成員方法獨立於該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。
只要這個類被載入，Java虛擬機就能根據類名在運行時數據區的方法區內定找到他們。因此，static對象可以在它的任何對象創建之前訪問，無需引用任何對象。
用public修飾的static成員變數和成員方法本質是全局變數和全局方法，當聲明它類的對象市，不生成static變數的副本，而是類的所有實例共享同一個static變數。
static變數前可以有private修飾，表示這個變數可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問許可權限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問許可權關鍵字的效果也以此類推。