本篇浅析java中static的用法，主要五个方面：静态成员变量，静态方法，静态块，静态内部类，静态导包。

   首先还是一张表格说一下静态对象和非静态对象的区别：

 

静态对象

非静态对象

归属

类共同具有

类的各个实例独立拥有

内存分配

内存空间上固定的

附属类分配

分配空间顺序

优先分配静态对象空间

优先分配静态对象空间，初始化也一样

   1 静态变量，静态方法，静态块



   静态对象，静态方法都是在原对象和方法上加上static关键字修饰，表示类可以直接调用这些，而不需要实例化后再调用。具有的好处是：



     1--静态对象的数据是全局唯一的，一改都改，可以保证数据的唯一性



     2--引用方便，直接用类名.方法（属性）就可以了，不用再get和set



  当然静态方法(变量，块）也有相应的限制：



    1--不能调用其他非静态方法（只能调用static方法）



    2--只能访问static数据



    3--不能以任何方式引用this或super



  示例代码： 



public class StaticExercise {
	
	public static String sky="jeyson";
    
	public static String getMySky(String sky){
		return sky;
	}
	static {
		System.out.println("这是静态块中的内容--");
		System.out.println("静态块："+getMySky(sky));
	}
	/**
	 * ***静态对象好处：
	 *    1--静态对象的数据是全局唯一的，一改都改，可以保证数据唯一。
	 *    2--引用方便，直接类名.方法就行了，不用set和get
	 * ***分配空间顺序：
	 *    先分配静态对象空间再分配非静态。初始化顺序也是这样
	 * ***static final 修饰的成员变量和成员方法可以理解为全局变量（java中没有全局变量概念）
	 * ***静态对象，方法，块的限制：
	 *    1--只能调用其他的static方法
	 *    2--只能访问static数据
	 *    3--不能以任何方式引用this或super
	 * 静态对象测试
	 */
	@Test
	public void testStatic1(){
		System.out.println(sky);
		System.out.println("-----------------");
		System.out.println(getMySky(sky));
		System.out.println("-----------------");
		System.out.println(StaticTest.getSms());
		
	}
}



　　

   2 静态内部类



     当一个类跟另一个类（外部类）有紧密的联系，一般只有用到外部类的时候才会用该类的话，可以将该类作为静态的内部类。这样就可以随着类的加载而直接产生。不用再可以实例化。



     使用方法：随类一同被加载，调用直接外部类.内部类.静态对象（方法）



    示例代码： 



class StaticTest{
	public static String sms="to my sky";
	public static String getSms(){
		return sms;
	}
	/**
	 * 静态内部类
	 * ***使用场景：
	 *    内部类跟外部类联系紧密，一般只有用到外部类的时候才会用到这个类
	 * ***使用
	 *    随类一同被加载，直接外部类.内部类.静态对象（方法）
	 */
	static  class InnerStatic{
		public static final String MYSKY="MY FINAL SKY";
	}
}



　



@Test
	public  void testStatic2(){
		System.out.println(StaticTest.InnerStatic.MYSKY);
	}



　　

　

 2 静态导包



    如果要用的静态方法所在的类跟当前类不在同一个包下，可以使用静态导包。这样你想要用的静态方法或变量就相当于在该类中直接可见，无需再类名.静态变量的方式调用。



    使用方法：



      import static 包名.类名.静态成员变量（方法）



    好处：



       被导入的静态变量和方法在该类中直接可见，直接用



    坏处：



       一定程度上降低了代码的可读性



    代码示例： 



public class MyStaticImportTest {
    public static final int number=55;
    public static void getMyWords(){
    	System.out.println("hello ,这是一个静态导包的测试");
    }
}



　



import static com.generic.MyStaticImportTest.number;
import static com.generic.MyStaticImportTest.getMyWords;

/**
 * @Description:
 *  静态
 */
public class StaticExercise {
	
	/**
	 * 静态导包
	 * ***使用方法：
	 *   直接静态导入相应的变量和方法：（import static 包名.类名.静态成员变量（方法）
	 *       import static com.generic.MyStaticImportTest.number;
     *       import static com.generic.MyStaticImportTest.getMyWords;
     * *** 好处：
     *     被导入的静态方法和变量在这个类中直接可见，无需再给出类名
     * *** 坏处
     *     一定程度上降低了代码的可读性
	 */
	@Test
	public void testStatic3(){
		//静态导入后可以直接用
		int myNumber=number;
		getMyWords();
	}
	
}