Java学习-面向对象下

一、static关键字

1. static：静态的
2. static可以用来修饰：属性、方法、代码块、内部类
3. 使用static修饰属性：静态变量
   3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性 （实例变量）
   实例变量： 我们创建了类的多个对象，每个对象都独立的拥有一套类中非静态属性。当修改其中一个对象中的非静态属性，不会导致其它对象中同样的属性值修改。
   静态变量： 我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其它对象该属性值也被修改。
   3.2 static修饰属性的其它说明
   ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式调用
   ② 静态变量加载要早于对象的创建
   ③ 由于类只会加载一次，则静态变量在内存中也只会存一份：存在方法区的静态域中。

3.3 静态属性举例：System.out、Math.PI …
4. 使用static修饰方法：静态方法
① 随着类的记载而加载，可以通过"类.静态方法"的方式调用
② 静态方法中，只能调用静态的方法和属性，
非静态的方法中，可以调用静态和非静态的方法和属性。

5. static注意点：
   ① 在静态的方法内，不能使用this、super关键字
   ② 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
6. 开发中如何确定一个属性是否要声明为static的？
   ① 属性可以是被多个对象所共享的，不会随着对象不同而改不同
   ② 类中常量也通常声明为static
7. 开发中，如何确定一个方法是否要声明为static的？
   ① 操作静态属性的方法，通常设置为static的
   ② 工具类中的方法，习惯声明为static的。比如：Math、Arrays、Collections

代码示例：

public class StaticTest {
	public static void main(String[] args) {
		Chinese.nation = "中国";
		
		Chinese c1 = new Chinese();
		c1.name = "小明";
		c1.age = 20;
		
		Chinese c2 = new Chinese();
		c1.name = "小红";
		c1.age = 22;
		
		c1.nation = "CHN";
		System.out.println(c2.nation);
	}
}

class Chinese{
	String name;
	int age;
	static String nation;
	
	public void eat() {
		System.out.println("吃饭");
		show();
	}
	
	public static void show() {
		System.out.println("我是一个中国人");
//		eat();
//		name = "hh";
		nation = "hh";
	}
}
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
34

二、单例设计模式

1. 所谓单例设计模式，就是采取一定的方法保证整个的软件系统中，对某个类只能存在一个对象实例
2. 如何实现？
   饿汉式的实现：
   ① 私有化构造器
   ② 内部创建类的对象，且此对象是静态的
   ③ 提供公共的方法，返回类的对象

//饿汉式的实现
class Bank{
	//1. 私有化构造器
	private Bank() {
		
	}
	
	//2. 内部创建类的对象，且此对象是静态的
	private static Bank instance = new Bank();
	
	//3. 提供公共的方法，返回类的对象
	public static Bank getInstance() {
		return instance;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

懒汉式的实现：
① 私有化构造器
② 声明当前对象，没有初始化，此对象必须声明为static
③ 提供公共的方法，返回类的对象

//懒汉式的实现
class Order{
	// 1. 私有化构造器
	private Order() {
		
	}
	
	//2. 声明当前对象，没有初始化，此对象必须声明为static
	private static Order instance = null;
	
	//3. 提供公共的方法，返回类的对象
	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

3. 区分饿汉式和懒汉式

• 饿汉式：
  坏处：对象加载时间过长
  好处：饿汉式的线程是安全的
• 懒汉式：
  好处：延迟对象的创建
  目前写法的坏处：线程不安全。---->到多线程在细说

三、类的成员之四：代码块

1. 代码块的作用：用来初始化类、对象
2. 代码块如果要一修饰，只能使用static
3. 分类：静态代码块、非静态代码块
4. 静态代码块：
   ① 内部可以有输出语句
   ② 随着类的加载而执行，而且只执行一次
   ③ 作用：初始化类的信息
   ④ 如果一个类定义了多个静态代码块，按声明的先后顺序执行
   ⑤ 静态代码的执行要先于非静态代码块
   ⑥ 静态代码块内部只能调用静态的属性、静态的方法、不能掉用非静态的结构
5. 非静态代码块：
   ① 内部可以有输出语句
   ② 随着对象的创建而执行，且每创建一个对象，就执行一次
   ③ 作用：可以在创建对象时，对对象的属性等进行初始化
   ④ 如果一个类定义了多个非静态代码块，按声明的先后顺序执行
   ⑤ 非静态代码块可以调用非静态的结构和静态的结构

拓展：

• 对属性可以赋值的位置
  ① 默认初始化
  ② 显示初始化
  ③ 构造器初始化
  ④ 有了对象以后，可以通过"对象.属性"或"对象.方法"进行赋值
  ⑤ 在代码块中赋值

执行的先后顺序：① - ② / ⑤ - ③ - ④

代码示例：

public class BlockTest {
	public static void main(String[] args) {
		String desc = Person.desc;
		Person p1 = new Person();
		Person p2 = new Person();
	}
}

class Person{
	String name;
	int age;
	static String desc = "我时一个人";
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Person() {
		super();
	}
	
	//静态代码块
	static {
		System.out.println("static block");
	}
	
	//非静态代码块
	{
		System.out.println("block");
	}
	
	public void eat() {
		System.out.println("吃饭");
	}
	
	public static void info() {
		System.out.println("我是一个快乐的人");
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47