static

static静态关键字
可以用在

变量：类的共有成员——静态变量
1：static变量只依赖与类存在（可以通过类访问），不依赖与对象实例化存在。
2：所有的对象实例，如例子中的obj1和obj2关于price变量的值都共享存储在一个共同的空间（栈）；不过通过对象修改函数类修改，都是对同一个price(变量)访问。
3:一句话就static变量来说，就是一个变量同一个内存空间。突出一个共同成员

package Static_final;

public class Potato {
	static int price=5;
	//静态变量，依赖类的存在，可以直接用。内存里面只有一个price
	 String content="";
	public Potato() {}
	public Potato(int price,String content) {
		this.price=price;
		this.content=content;
	}
	public static void main(String[] args) {
		System.out.println(Potato.price);
		System.out.println("静态变量的调用方法");
//		System.out.println(Potato.content);
//		通过结果显示调用了两次price，而且结果也是一样的。
//		都是用同一个内存，内存里面只有一个price。这个price即可以通过类直接访问，也可以通过对象访问
		Potato obj1=new Potato(10,"青椒土豆丝");
		System.out.println(Potato.price);
		System.out.println(obj1.price);
		System.out.println("------------");
		Potato obj2=new Potato(20,"酸辣土豆丝");
		System.out.println(Potato.price);
		System.out.println(obj2.price);
	}
}
5
静态变量的调用方法
10
10
------------
20
20

方法——static方法——静态方法
1：静态方法也是无需通过对象来引用，是通过类名可以直接引用
2：在静态方法中，只能使用静态变量，不能使用非静态变量
3：静态方法禁止引用非静态方法
由下面的代码可知，静态的方法由对象直接访问，并且静态方法只能调用静态与非静态方法或者变量。

package Static_final;

import first.mainfile;

public class StaticMethodTest {
	int a=1111;
	static  int b=2222;
	public static void hello() {
		System.out.println("000000");
		System.out.println(b);
//		System.out.println(a);//报错，静态方法不能调用非静态变量；
	}
	public void hi() {
		System.out.println("33333");
		hello();
//		非静态方法可以调用静态与非静态变量/方法；但是静态方法不能调用非静态方法/变量
		System.out.println(a);
		System.out.println(b);
	}
	
	public static void main(String[] args) {
		StaticMethodTest.hello();
//		StaticMethodTest.hi();//不能使用类名引用非静态方法；
		StaticMethodTest foo = new StaticMethodTest();
		foo.hello();//警告
		foo.hi();
	
	}
}

类匿名方法块：没有名字的方法`{system.out.println(“1111111”)}`
-最后两种用的比较少，所以就不展开了 单例模式

单例模式是限定某一个类在整个程序运行过程中，只保留一个实例对象在内存空间这个类只能被new一次，只能在内存中出现一次单例模式是GoF的23种设计模式中经典的一种，属于创建型模式类型
- 模式

单例模式：保证一个类有且只有一个对象采用static来共享对象实例采用private构造函数，防止外界new *** 作

package Static_final;

public class Singleton {
//	静态变量就是自身，不能被外部实例化，规定了一个类只能由一个对象。
	private static Singleton obj=new Singleton();
//	静态变量
	private String content;
//	构造函数，为了防止外部定义，确保不能被外部访问只能在内部访问（private）
	private Singleton() {
		this.content="abc";
	}
//	获取内部的content值
	public String getContent() {
		return content;
	}
//	修改内部的content值
	public void setContent(String content) {
		this.content=content;
	}
//	
	public static Singleton getInstance() {
//		静态方法使用静态变量
//		另外可以使用方法内部的临时变量，但是不能引用非静态的成员变量
		return obj;
		//这里使用的对象实际上还是同一个内存中的obj，不管外界调用多少getInstance方法，所拿的实例多少obj。
//		而该方法又是类内部定义好的，因此外部每次定义都是用同一个内存
	}
	public static void main(String[] args) {
		Singleton obj1=Singleton.getInstance();
		Singleton obj2=Singleton.getInstance();
//		obj1与obj2都是同一个指针,obj3又是一个重新new出来的对象。
//		前面一种强调，单例不能在外部所调用，此时的main函数是在类的内部，因此可以new出来。
//		我们所说的外部是重新一个类里面所调用这个对象。
//		这里重新调用这个类，也就重新分配了一个内存，与obj不一样。所有修改值会出现不一样的结果
		Singleton obj3=new Singleton();
		System.out.println(obj1.getContent());
		System.out.println(obj2.getContent());
		System.out.println(obj3.getContent());
		obj1.setContent("qwe");
		System.out.println(obj1.getContent());
		System.out.println(obj2.getContent());
		System.out.println(obj3.getContent());
	
	}
}
abc
abc
abc
qwe
qwe
abc

Finall关键字
1：fiall的使用：

类方法字段（变量）（1）：finall修饰一个类，表示这个类不能被继承了。（2）：finall修饰一个方法，表示该方法不能被重写，这个方法就定死了（3）:finall修饰一个变量，

 			——基本类型变量（int double.......）则这些变量的值不能被改变

 			——对象实例，那么只能修改指针的值，不能修改该指针。

 				例如：finall FinallObj obj1=new FinallObj ;已经定义一个obj1对象，即分配了一个空间给obj1.

 							obj1=new FianllObj;这里再分配一个空间，相当于又开辟一个obj1空间，就会报错，这样是不允许的