首先問一個問題：

public static void main(String[] args)程式碼代表了什麼含義？以及思考為什麼java程式一開始就會進入main()函式，其實c、c++也是如此？後面一個問題有static的基礎就非常容易。（後一個問題的答案提前公佈：用static修飾的程式碼塊表示靜態程式碼塊，當Java虛擬機器（JVM）載入類時，就會執行該程式碼塊）

  現在回到第一個問題：

  下面分別解釋這些關鍵字的作用：

（1）public關鍵字，這個好理解，宣告主函式為public就是告訴其他的類可以訪問這個函式。

（2）static關鍵字，告知編譯器main函式是一個靜態函式。也就是說main函式中的程式碼是儲存在靜態儲存區的，即當定義了類以後這段程式碼就已經存在了。如果main()方法沒有使用static修飾符，那麼編譯不會出錯，但是如果你試圖執行該程式將會報錯，提示main()方法不存在。因為包含main()的類並沒有例項化（即沒有這個類的物件），所以其main()方法也不會存。而使用static修飾符則表示該方法是靜態的，不需要例項化即可使用。

（3）void關鍵字表明main()的返回值是無型別。

（4）引數String[] args

public class Testargs {
    public static void main(String[] args) {
        String str = new String();
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
            str += args[i];
        }
        System.out.println(str);
    }
}
 

如果不使用編譯器，使用命令列進行編譯。你可以在準備編譯class的時候傳入abc，那麼上面程式執行的結果就是abc，也就是引數args的主要作用是為程式使用者在命令列狀態下與程式互動提供了一種手段。

另外一種作用就是像正常函式方法一樣呼叫其函式，但是需要注意的一點就是static宣告的變數或者方法，是類方法或者說是類變數，不需要例項化就可以直接使用

具體實現步驟：

首先宣告一個類A：

public classA {
  public static void main(String[] args)
  {
     for (int i = 0; i < args.length; i++) {
       System.out.println(args[i]);
     }
  }
}
 

接著再寫一個B類：

public classB {
  public static void main(String[] args)

  {
 
  //A c = new A();
 
  String[] b = {"111","222","333"};
 
  //c.main(b); //輸出111 222 333
 
  //因為main()函式是靜態函式，因此不需要例項化就可以使用
  A.main(b);//輸出結果和上面的是一樣的
 
  }
}

static 修飾符能夠與變數、方法一起使用，表示是“靜態”的。

靜態變數和靜態方法能夠通過類名來訪問，不需要建立一個類的物件來訪問該類的靜態成員，所以static修飾的成員又稱作類變數和類方法。靜態變數與例項變數不同，例項變數總是通過物件來訪問，因為它們的值在物件和物件之間有所不同。

請看下面的例子：

public class Demo {
    static int i = 10;
    int j;
    Demo() {
        this.j = 20;
    }
    public static void main(String[] args) {
        System.out.println("類變數 i=" + Demo.i);
        Demo obj = new Demo();
        System.out.println("例項變數 j=" + obj.j);
    }
}

static 的記憶體分配

1. public classDemo {
2. static int i;
3. int j;
4. public static void main(String[] args) {
5. Demoobj1 = new Demo();
6. obj1.i = 10;
7. obj1.j = 20;
8. Demoobj2 = new Demo();
9. System.out.println("obj1.i=" + obj1.i + ", obj1.j=" + obj1.j);
10. System.out.println("obj2.i=" + obj2.i + ", obj2.j=" + obj2.j);
11. }
12. }

靜態方法

• 一個方法不需要訪問物件狀態，其所需引數都是通過顯式引數提供（例如 Math.pow()）。
• 一個方法只需要訪問類的靜態變數。

關於靜態變數和靜態方法的總結：

• 一個類的靜態方法只能訪問靜態變數；

• 一個類的靜態方法不能夠直接呼叫非靜態方法；

• 如訪問控制權限允許，靜態變數和靜態方法也可以通過物件來訪問，但是不被推薦；

• 靜態方法中不存在當前物件，因而不能使用 this，當然也不能使用 super；

• 靜態方法不能被非靜態方法覆蓋；

• 構造方法不允許宣告為 static 的；

• 區域性變數不能使用static修飾。

1. public classDemo {
2. static int sum(int x, int y){
3. return x + y;
4. }
5. public static void main(String[] args) {
6. int sum = Demo.sum(10, 10);
7. System.out.println("10+10=" + sum);
8. }
9. }

注意：例項變數只能通過物件來訪問，不能通過類訪問。

關於在靜態方法中間接呼叫非靜態方法示例：

package com.imooc.testargs;

public class StaticInvokeNonStaticMethod {

	private String name;

	public StaticInvokeNonStaticMethod(String name) {
		this.name = name;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StaticInvokeNonStaticMethod s = new StaticInvokeNonStaticMethod(
				"zhangsan");
		StaticInvokeNonStaticMethod s2 = new StaticInvokeNonStaticMethod(
				"wangwu");
		StaticInvokeNonStaticMethod.ask(s);
		StaticInvokeNonStaticMethod.ask(s2);
		//s.ask(s2); // 物件呼叫靜態方法的方式不推薦使用
	}

	/**
	 * 通過傳入一個例項物件的方法引用，達到靜態方法內部呼叫非靜態方法
	 * */
	public static void ask(StaticInvokeNonStaticMethod s) {
		System.out.println("靜態方法內部呼叫非靜態方法");
		//System.out.println(s);  //這是在類中訪問類物件，不是例項變數
		//Cannot make a static reference to the non-static field name, 說明不能在靜態方法中訪問例項變數
		//System.out.println(name);  
		
		s.say();   
	}

	public void say() {
		System.out.println("hello my name is " + name);
	}
}

靜態初始器（靜態塊）

1. public classDemo {
2. public static int i;
3. static{
4. i = 10;
5. System.out.println("Now in static block.");
6. }
7. public void test() {
8. System.out.println("test method: i=" + i);
9. }
10. public static void main(String[] args) {
11. System.out.println("Demo.i=" + Demo.i);
12. new Demo().test();
13. }
14. }

靜態匯入

1. import packageName.className; // 匯入某個特定的類

1. import packageName.*; // 匯入包中的所有類

1. import static packageName.className.methonName; // 匯入某個特定的靜態方法

1. import static packageName.className.*; // 匯入類中的所有靜態成員

1. import static java.lang.System.*;
2. import static java.lang.Math.random;
3. public classDemo {
4. public static void main(String[] args) {
5. out.println("產生的一個隨機數：" + random());
6. }
7. }