static关键字

static关键字

当我们编写一个类时，其实就是在描述对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统会给对象分配内存空间，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生多少对象的情况下，某些特定的数据在内存空间里只有一份。例如所有的中国人都有个国家名称，不必在每一个中国人的实例对象中都单独分配一个代表国家名称的变量

static：静态的

static可以用来修饰属性、方法、代码块、内部类

使用static修饰属性

属性按是否使用static修饰又分为静态属性和非静态属性（实例变量）

• 实例变量：当我们创建了类的对象，每个对象都独立的有一套类的非静态属性，当修改其中一个对象中的非静态属性时，不会导致其他对象属性的修改
• 静态变量：我们创建了类的多个对象，每个对象共享同一个静态变量，当通过某一个对象去修改静态变量时，会导致其他对象调用此静态变量时，是修改过的

public class StaticTest {
	public static void main(String[] args) {
		Chinese c1 = new Chinese();
		c1.name = "王子璇";
		c1.age = 20;
	
		Chinese c2 = new Chinese();
		c2.name = "李昊";
		c2.age = 25;
	
		c1.nation = "CHN";
		System.out.println(c2.nation); // CHN
	
		c2.nation = "CHINA";
		System.out.println(c1.nation); // CHINA
	
	}
}

class Chinese{
	String name;
	int age;
	static String nation;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

静态变量的补充

1.静态变量的加载要早于对象的创建
2.可以直接类.属性的方式，去调用咱们的静态变量

chinese.nation = "中国";
1

3.由于类只加载一次，则静态变量在类中只存在一份，存在方法区的静态域中

类变量vs实例变量内存解析

static修饰方法

• 随着类的加载而加载，可以通过类.静态方法来调用
• 静态方法中，只能调用静态的方法或属性
• 非静态方法中，既可以调用非静态的方法和属性，也可以调用静态的方法和属性

在静态的方法内，不能使用this、super关键字

关于静态属性和静态方法，都从生命周期的角度去理解

开发中，如何确定一个属性要不要设置为static？

属性是可以被多个对象共享的，不会随着对象的不同而不同

开发中，如何确定一个方法要不要设置为static？

操作静态属性的方法，通常设置为静态的
工具类中的方法，习惯上声明为静态

单例（Singleton）设计模式

如何实现？

用饿汉式和懒汉式

饿汉式

package baozhuang;

public class singleton {
	public static void main(String[] args) {
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
	
		System.out.println(bank1 == bank2);
	}

}

//饿汉式
class Bank{
	//1.私有化类的构造器
	private Bank(){
	
	}
	// 2.内部创建类的对象
	// 4 静态的方法要求对象也必须为静态.
	private static Bank instance = new Bank();

	//3.提供公共的方法，返回类的对象,外面要想调用，必须先创建一个对象，但由于是private创建不了对象，所以得用static外部才能在不创建新对象的情况下去调用

	public static Bank getInstance(){
		return instance;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

懒汉式

package baozhuang;

public class SingleTest2 {
	public static void main(String[] args) {
		Order ord1 = Order.getInstance();
		Order ord2 = Order.getInstance();
		System.out.println(ord1 == ord2);
	}

}

class Order{

	// 1. 私有化类的构造器
	private Order(){
	
	}

	// 2.声明当前类的对象
	// 4.此对象也必须声明为static
	private static Order instance = null;

	// 3.声明public,static的返回当前类对象的方法
	public static Order getInstance(){
		if (instance == null){
			instance = new Order();
		}
	
		return instance;
	
	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

注：饿汉式上来就给你造好对象了，懒汉式用到才造

饿汉式：
好处：对象加载时间过长
坏处：线程安全的
懒汉式
好处：延迟对象的创建
坏处：目前的写法是线程不安全的 ----到多线程的时候再修改

单例模式的优点：

由于单例模式只生成了一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式解决