首先问一个问题：

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 的内存分配

    
    
public class Demo {
    static int i;
    int j;
    public static void main(String[] args) {
        Demo obj1 = new Demo();
        obj1.i = 10;
        obj1.j = 20;
       
        Demo obj2 = new Demo();
       
        System.out.println("obj1.i=" + obj1.i + ", obj1.j=" + obj1.j);
        System.out.println("obj2.i=" + obj2.i + ", obj2.j=" + obj2.j);
    }
}

图1  静态变量内存分配

静态方法

• 一个方法不需要访问对象状态，其所需参数都是通过显式参数提供（例如 Math.pow()）。
• 一个方法只需要访问类的静态变量。

关于静态变量和静态方法的总结：

• 一个类的静态方法只能访问静态变量；

• 一个类的静态方法不能够直接调用非静态方法；

• 如访问控制权限允许，静态变量和静态方法也可以通过对象来访问，但是不被推荐；

• 静态方法中不存在当前对象，因而不能使用 this，当然也不能使用 super；

• 静态方法不能被非静态方法覆盖；

• 构造方法不允许声明为 static 的；

• 局部变量不能使用static修饰。

    
    
public class Demo {
    static int sum(int x, int y){
        return x + y;
    }
    public static void main(String[] args) {
        int sum = Demo.sum(10, 10);
        System.out.println("10+10=" + sum);
    }
}

注意：实例变量只能通过对象来访问，不能通过类访问。

关于在静态方法中间接调用非静态方法示例：

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);
	}
}

静态初始器（静态块）

    
    
public class Demo {
    public static int i;
    static{
        i = 10;
        System.out.println("Now in static block.");
    }
    public void test() {
        System.out.println("test method: i=" + i);
    }
    public static void main(String[] args) {
        System.out.println("Demo.i=" + Demo.i);
        new Demo().test();
    }
}

静态导入

    
    
import packageName.className;  // 导入某个特定的类

    
    
import packageName.*;  // 导入包中的所有类

    
    
import static packageName.className.methonName;  // 导入某个特定的静态方法

    
    
import static packageName.className.*;  // 导入类中的所有静态成员

    
    
import static java.lang.System.*;
import static java.lang.Math.random;
public class Demo {
    public static void main(String[] args) {
        out.println("产生的一个随机数：" + random());
    }
}