java如何聲明靜態方法

㈠ java中靜態聲明指的是什麼

. 靜態方法 通常，在一個類中定義一個方法為static，那就是說，無需本類的對象即可調用此方法

聲明為static的方法有以下幾條限制：

1. 它們僅能調用其他的static 方法。

2· 它們只能訪問static數據。 · 它們不能以任何方式引用this 或super。

調用一個靜態方法就是「類名.方法名」,靜態方法的使用很簡單如上所示。一般來說，靜態方法常常為應用程序中的其它類提供一些實用工具所用，在Java的類庫中大量的靜態方法正是出於此目的而定義的。此類方法，不需要創建對象。

2. 靜態變數

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

3．靜態類

通常一個普通類不允許聲明為靜態的，只有一個內部類才可以。這時這個聲明為靜態的內部類可以直接作為一個普通類來使用，而不需實例一個外部類。

4．static和final一塊用表示什麼
static final用來修飾成員變數和成員方法，可簡單理解為「全局常量」！
對於變數，表示一旦給值就不可修改，並且通過類名可以訪問。
對於方法，表示不可覆蓋，並且可以通過類名直接訪問。

㈡ java中什麼方法可以定義靜態變數

java中什麼方法可以定義靜態變數
靜態變數
可以將靜態變數理解為類變數（與對象無關），而實例變數則屬於一個特定的對象。
靜態變數有兩種情況：
靜態變數是基本數據類型，這種情況下在類的外部不必創建該類的實例就可以直接使用
靜態變數是一個引用。這種情況比較特殊，主要問題是由於靜態變數是一個對象的引用，那麼必須初始化這個對象之後才能將引用指向它。因此如果要把一個引用定義成static的，就必須在定義的時候就對其對象進行初始化。

靜態方法
與類變數不同，方法（靜態方法與實例方法）在內存中只有一份，無論該類有多少個實例，都共用一個方法。
靜態方法與實例方法的不同主要有：
靜態方法可以直接使用，而實例方法必須在類實例化之後通過對象來調用。
在外部調用靜態方法時，可以使用「類名.方法名」或者「對象名.方法名」的形式。實例方法只能使用後面這種方式。
靜態方法只允許訪問靜態成員。而實例方法中可以訪問靜態成員和實例成員。
靜態方法中不能使用this（因為this是與實例相關的）。

㈢ java靜態方法

靜態方法不可以，但是如果main函數不是靜態函數就可以引用this和super。如果main函數是靜態函數，方法內不能使用super，也不可以使用static。
1。this和super是針對一個類實例，創建一塊內存區域，當條用方法時會獲得實例的數據，而static沒有這樣的實例，所以static方法里不可以有this和super。
2。static方法里不可以有static是因為，要是你在一個類里申明了static方法，裡面的static變數是可以申明成類static成員的，為了規范代碼，Java規定不可以這樣。

㈣ java中，什麼是靜態方法

首先靜態方法是用static來修飾的
靜態方法就是可以不通過生成類的實例直接來調用的
舉個簡單的例子：
class
A
{
public
static
void
a()
{
System.out.println("A被調用");
}
public
void
b()
{
System.out.println("B被調用");
}
}
假設你要調用方法a和方法b
如果調用方法a可以直接A.a();就可以了
不需要先
A
aa
=
new
A();aa.a();
但是調用b則必須A
aa
=
new
A();aa.b();
還有在繼承裡面要注意:
如果B繼承自A
而且B中和A中都包含相同的函數
如果是實例方法則是被B覆蓋掉的
如果是靜態方法則是被B隱藏掉的
這一點
在上溯機制中可能遇到
最後還有一點靜態方法調用的方法一定也要是靜態的

㈤ Java中的靜態方法是什麼

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

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

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

㈥ java靜態變數怎麼聲明

個人的總結
1 靜態變數只有一份被類的所有實例共享
2 靜態變數的聲明在編譯時已經明確了內存的位置
3 延遲初始化是改變靜態變數的值
引用

Java靜態變數的初始化（static塊的本質）

在網上看到了下面的一段代碼：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

上述代碼會列印出什麼結果來呢？10還是20？本文將以此代碼為引子，著重討論一下靜態變數的初始化問題。 樓主可以找組織先記下175再來記下161最後填寫984就會出現扣裙問題1：靜態變數如何初始化

Java類中可以定義一個static塊，用於靜態變數的初始化。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6. }

public class Test { public static int _i; static { _i = 10; } }

當然最常用的初始化靜態變數的操作是在聲明變數時直接進行賦值操作。如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

那麼上述兩例在本質上有什麼區別嗎？回答是沒有區別。兩例代碼編譯之後的位元組碼完全一致，通過 「javap -c」查看到的位元組碼如下：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return

}

通過位元組碼還可以看出，當類的定義中不含有static塊時，編譯器會為該類提供一個默認的static塊。當然這是在含有靜態變數初始化操作的前 提下。如果靜態變數沒有初始化操作，則編譯器不會為之提供默認的static塊。如：

1. public class Test {
2. public static int _i;
3. }

public class Test { public static int _i; }

其位元組碼的表現形式為：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

}

由於靜態變數是通過賦值操作進行初始化的，因此可以通過靜態函數返回值的方式為其初始化。如：

1. public class Test {
2. public static int _i = init();
3.
4. private static int init() {
5. return 10;
6. }
7. }

public class Test { public static int _i = init(); private static int init() { return 10; } }

其本質與下面的代碼相同：

1. public class Test {
2. public static int _i;
3. static {
4. _i = init();
5. }
6.
7. private static int init() {
8. return 10;
9. }
10. }

public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }

問題2：JDK如何處理static塊

類定義中可以存在多個static塊嗎？回答是可以。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6.
7. public static void main(String[] args) {
8. }
9.
10. static {
11. _i = 20;
12. }
13. }

public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }

此類編譯之後的位元組碼為：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
Code:
0: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return

}

觀察static{}部分可以看出，上例的代碼與下面的代碼效果一致：

1. public class Test {
2. public static int _i;
3.
4. public static void main(String[] args) {
5. }
6.
7. static {
8. _i = 10;
9. _i = 20;
10. }
11. }

public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }

此例可以證明，不僅類定義中可以有多個static塊，而且在編譯時編譯器會將多個static塊按照代碼的前後位置重新組合成一個static 塊。
問題3：如何看待靜態變數的聲明

靜態變數存放在常量池之中。如何證明呢？如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

使用「javap -c -verbose」查看其位元組碼的內容如下：

public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."<init>":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "<init>":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;

{
public static int _i;

public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 2: 0

static {};
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable:
line 3: 0

}

我們看到，常量池中const #2指向的就是Test._i，也就是靜態變數。靜態變數被保存到常量池中的工作原理這里不深入討論。在此需要注意的是：

* 靜態變數的聲明與初始化是兩個不同的操作；
* 靜態變數的聲明在編譯時已經明確了內存的位置。

如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

上述代碼的本質可以視為：

1. public class Test {
2. // 靜態變數的聲明
3. public static int _i;
4.
5. // 靜態變數的初始化
6. static {
7. _i = 10;
8. }
9. }

public class Test { // 靜態變數的聲明 public static int _i; // 靜態變數的初始化 static { _i = 10; } }

由於靜態變數的聲明在編譯時已經明確，所以靜態變數的聲明與初始化在編碼順序上可以顛倒。也就是說可以先編寫初始化的代碼，再編寫聲明代碼。如：

1. public class Test {
2. // 靜態變數的初始化
3. static {
4. _i = 10;
5. }
6.
7. // 靜態變數的聲明
8. public static int _i;
9. }

public class Test { // 靜態變數的初始化 static { _i = 10; } // 靜態變數的聲明 public static int _i; }

對初始問題的解答

解答了上述三個問題，讓我們再來看看開篇提到的問題。代碼如下：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

其本質可以用下面的代碼表示：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i;
6. static {
7. _i = 10;
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(_i);
12. }
13. }

public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

再簡化一下，可以表示為：

1. public class Test {
2. public static int _i;
3.
4. static {
5. _i = 20;
6. _i = 10;
7. }
8.
9. public static void main(String[] args) {
10. System.out.println(_i);
11. }
12. }

public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

至此，代碼已經明確告訴我們列印結果是什麼了！

㈦ java靜態方法怎麼寫

舉例：

publicclassXXX{
publicstaticvoidhelp(){
System.out.println("Welcome!");
}
}

其中的help方法就是靜態的。主要是加了「static」關鍵字。

㈧ 北大青鳥設計培訓：JAVA構造方法靜態方法

構造方法作用:對對象的屬性(成員變數)進行初始化寫法:1.構造方法的方法名與類名完全相同2.沒有返回值類型(連void都不寫)3.沒有返回值注意事項:1.沒寫構造方法系統則會提供一個無參的構造方法2.寫了有參的構造方法系統不會提供無參的構造方法所以在寫有參的構造方法時最好把無參的也寫上內存表現步驟1.類載入到方法區2.載入到方法區的同時。
IT培訓http://www.kmbdqn.cn/認為靜態變數被載入到方法區的靜態區3.main入棧4.在堆內存中創建對象5.把地址賦值給main函數的對象保存6.main函數出棧7.程序結束靜態變數與成員變數的區別:1.所屬不同:成員變數:屬於對象的又叫對象變數(實例變數)靜態變數:屬於類又叫類變數2.內存中的存儲位置:成員變數:存儲在堆內存靜態變數:存處在方法區的靜態區3.載入到內存中的時機(生命周期的不同):成員變數:隨著對象的創建而創建靜態變數:隨著類的載入而存在

㈨ java中的static如何使用

有時你希望定義一個類成員，使它的使用完全獨立於該類的任何對象。通常情況下，類成員必須通過它的類的對象訪問，但是可以創建這樣一個成員，它能夠被它自己使用，而不必引用特定的實例。在成員的聲明前面加上關鍵字static(靜態的)就能創建這樣的成員。如果一個成員被聲明為static，它就能夠在它的類的任何對象創建之前被訪問，而不必引用任何對象。你可以將方法和變數都聲明為static。static成員的最常見的例子是main( )。因為在程序開始執行時必須調用main()，所以它被聲明為static。聲明為static的變數實質上就是全局變數。當聲明一個對象時，並不產生static變數的拷貝，而是該類所有的實例變數共用同一個static變數。
聲明為static的方法有以下幾條限制：
· 它們僅能調用其他的static方法。
· 它們只能訪問static數據。
· 它們不能以任何方式引用this或super（關鍵字super與繼承有關，在下一章中描述）。
如果你需要通過計算來初始化你的static變數，你可以聲明一個static塊，Static塊僅在該類被載入時執行一次。
下面的例子顯示的類有一個static方法，一些static變數，以及一個static 初始化塊：
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}

static {
System.out.println("Static block initialized.");
b = a * 4;
}

public static void main(String args[]) {
meth(42);
}
}
一旦UseStatic類被裝載，所有的static語句被運行。首先，a被設置為3，接著static塊執行(列印一條消息)，最後，b被初始化為a*4或12。然後調用main()，main()調用meth()，把值42傳遞給x。3個println ( )語句引用兩個static變數a和b，以及局部變數x 。
注意：在一個static方法中引用任何實例變數都是非法的。
下面是該程序的輸出：
Static block initialized.
x = 42
a = 3
b = 12
在定義它們的類的外面，static方法和變數能獨立於任何對象而被使用。這樣，你只要在類的名字後面加點號運算符即可。例如，如果你希望從類外面調用一個static方法，你可以使用下面通用的格式：
classname.method( )
這里，classname 是類的名字，在該類中定義static方法。可以看到，這種格式與通過對象引用變數調用非static方法的格式類似。一static變數可以以同樣的格式來訪問——類名加點號運算符。這就是Java如何實現全局功能和全局變數的一個控製版本。
下面是一個例子。在main()中，static方法callme()和static變數b在它們的類之外被訪問。
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
下面是該程序的輸出：
a = 42
b = 99

static成員是不能被其所在class創建的實例訪問的。

如果不加static修飾的成員是對象成員，也就是歸每個對象所有的。

加static修飾的成員是類成員，就是可以由一個類直接調用，為所有對象共有的

㈩ JAVA中使用靜態方法

編程時我們心裡一定要清楚靜態方法和類的非靜態方法方法的區別：
最根本區別從編譯角度來說吧：
1）靜態（static）方法是編譯時直接載入載入到內存中（離cpu最近的一塊內存區域也稱為堆棧）,比如程序的public static main(args []){}方法,你能實例話嗎？
靜態方法不能被實例化，也不允許被實例化！
現在很多Java集成工具邊寫邊編譯的
因此 你可以通過「類名」+「.」+「靜態方法的名（）」來調用
2）非靜態方法（類的非靜態方法）通過關鍵字 「new」 字來實例化一個對象（object），這個對象放在 內存的另一塊區域 堆（heap）中。
也就是說編譯時，非靜態方法必須先實例化類的一個對象，通過「對象名」+「非靜態方法名（）」來調用；
public class Student
{
private String name;
/************************************************************
*下面兩個方法是類的非靜態方法封裝 屬性name，看一下在 main（）
*如何調用
************************************************************/
public set(string init_name)
{
this.name = init_name;
}
publc String get()
{
return this.name;
}
//構造函數
public Student(){}
public Student(String init_name)
{
this.name = init_name;
}

//下面是一個靜態方法，看一下它在main()中如何調用
public static void PrintClassName()
{
System.out.print("該類的名字：Student");
}
}
//MainClass類
pubic class MainClass
{
public static void main(args[])
{
//先調用靜態方法,不需要實例化對象
Student.PrintClassName();
//現在調用非靜態方法，一定要實例化對象
Student stu1 = new Student();
stu1.set("Join");
String stu1_name = stu1.get();
}

}