Java中的static

目录

Static基础知识

Static应用

---

• Static基础知识

Java中的static关键字可以用在变量、方法、类和代码块。

静态变量

• ①Static定义的变量只依赖于类存在（即通过类可以访问，类中可以直接用“类名. 静态变量名”调用，而普通变量不行，得通过实例化对象来调用），不依赖于对象实例存在。
• ②静态变量在内存中和实例变量是共享的。不管有多少对象，内存中只有一份；不管通过哪个实例修改，都是改的同一个。

• 静态变量的应用代码如下：

public class Potato {
	static int price = 5;
	String content = "";
	public Potato(int price, String content)
	{
		this.price = price;
		this.content = content;
	}	
	public static void main(String[] a)
	{
		System.out.println(Potato.price); //Potato.content    wrong
		System.out.println("----------------------------------");
		Potato obj1 = new Potato(10,"青椒土豆丝");//实例对象将改变static值
		System.out.println(Potato.price);//②
		System.out.println(obj1.price);
		Potato obj2 = new Potato(20,"酸辣土豆丝");
		System.out.println(Potato.price);//②
		System.out.println(obj1.price);
	}
}

class tomato{
	public static void main(String[] args) 
	{
	System.out.println(Potato.price);	//①
	//System.out.println(Potato.content);
    }
    
}

静态变量和非静态变量的对比：

	静态变量	非静态变量
内存分配	程序初始化时就产生，直到所在类的程序运行结束才消失	被实例化后才会分配内存
生存周期	应用程序的存在周期	实例化的类的存在周期
调用方式	通过类名.静态变量名或者对象调用	只能通过实例对象调用
共享方式	全局变量，被所有实例对象共享，一个实例的值变都会变，对同一块内存进行操作	局部变量，不共享
访问方式	不能访问非静态成员	可以访问静态成员

静态方法

• ①静态方法可以通过类名直接访问，无需new对象来引用，但也可以。
• ②在静态方法中，只能使用静态变量，不能使用非静态变量。
• ③静态方法禁止调用非静态方法，但反之成立，即非静态方法可以调用静态方法，也可调用静态变量。
• 静态方法的应用代码如下：

  public class StaticMethodTest {
  	int a = 111111;
  	static int b = 222222;
  	public static void hello()
  	{
  		System.out.println("000000");
  		System.out.println(b);//②
  		//System.out.println(a);  //②静态方法不能使用非静态变量
  		//hi()                    //③静态方法不能调用非静态方法
  	}
  	public void hi()
  	{
  		System.out.println("333333");
  		hello();                  //③非静态方法啥都可以调用
  		System.out.println(a);    //③
  		System.out.println(b);    //③
  	}
  	public static void main(String[] a)
  	{
  		StaticMethodTest.hello();//①
  		//StaticMethodTest.hi(); //error, 不能使用类名来引用非静态方法
  		StaticMethodTest foo = new StaticMethodTest();
  		foo.hello();  //①静态方法通过对象调用，也无可厚非
  		foo.hi();     //非静态方法只能通过对象调用
  	}
  }
  

代码块（不建议使用，容易混淆程序，建议将代码块包装成函数后使用）

• Static代码块只在类第一次被加载时调用，只执行一次
• 各种代码块的优先级：Static块>匿名块>构造函数
• 代码块的应用代码如下：

public class StaticBlockTest {

	public static void main(String[] args) {
		System.out.println("000000000000000");
		// TODO Auto-generated method stub
		StaticBlock obj1 = new StaticBlock();//输出结果：2143
		System.out.println("------------------------------------");
		StaticBlock obj2 = new StaticBlock();//第二次加载StaticBlock，static就不会再执行，所以结果：143
	}
}
class StaticBlock
{
	//static块 > 匿名块 >构造函数	
	//static块	
	static
		{
			System.out.println("22222222222222222222");
		}
	//匿名块
		{
			System.out.println("11111111111111111111");
		}
	//构造函数
		public StaticBlock()
		{
			System.out.println("33333333333333333333");
		}
	//匿名块
		{
			System.out.println("44444444444444444444");
		}	
}

运行结果如下：

• Static应用

      用于单例模式：与private结合。Static用来共享对象实例；private用来构造函数，防止外界new操作。保证了一个类在内存空间中只有一个对象，可以有多个实例。

Static在单例模式中的必要性？

Step1：main函数必须为静态。静态方法可以不用实例就能调用，main()程序开始的地方.

Step2:因为单例模式要求内存空间只有一个对象，所以在主函数中不能new每一个实例（每new一个实例相当于创建了一个对象），所以main()中的实例就只能通过调用函数来赋值，而这个函数也只能是静态的（静态方法只能调用静态函数），就导致getInstance功能函数也得是静态的。

Step3:在getInstance中存在实例想要的信息，return obj（obj为一个实例对象），所以obj也得是静态的（因为getInstance是静态的函数，函数里面只能是静态变量）。即实现了共享实例对象obj的要求。

private在单例模式的必要性？

  被private修饰的变量和方法不能被类外的访问，类外的实例就只能通过getInstance方法创建实例和通过Set()和Get()修改和获取（Set()和Get()无所谓静态，因为直接输出了）

代码如下：

public class Singleton {
	private static Singleton obj = new Singleton(); //共享同一个对象
	private String content;
	
	private Singleton()  //确保只能在类内部调用构造函数
	{
		this.content = "abc";
	}
	
	public String getContent() 	{
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}	
	
	public static Singleton getInstance()	{
		//静态方法使用静态变量
		//另外可以使用方法内的临时变量，但是不能引用非静态的成员变量
		return obj;
	}
	
	
	public static void main(String[] args) {
		Singleton obj1 = obj;
		System.out.println(obj1.getContent());  //abc
		
		Singleton obj2 = Singleton.getInstance();
		System.out.println(obj2.getContent());  //abc
		
		obj2.setContent("def");
		System.out.println(obj1.getContent());
		System.out.println(obj2.getContent());
		
		System.out.println(obj1 == obj2); //true, obj1和obj2指向同一个对象
	}
}