面向对象编程-高级(二)-代码块

一、代码块

1.1 基本介绍

1.2 基本语法

1.3 代码块的好处和案例演示

1. 下面的三个构造器都有相同的语句
2. 这样代码看起来比较冗余
3. 这时我们可以把相同的语句，放入到一个代码块中，即可
4. 当我们不管调用哪个构造器， 创建对象，都会先调用代码块的内容
5. 代码块调用的顺序优先于构造器…

{
	System.out.println("需要执行的冗余代码1..."); 
	System.out.println("需要执行的冗余代码2..."); 
	System.out.println("需要执行的冗余代码3...");
};

1.4 代码块使用注意事项和细节讨论

class A {
	{ //普通代码块
		System.out.println("A 普通代码块 01"); 
	}
	private int n2 = getN2();//普通属性的初始化

	static { //静态代码块
		System.out.println("A 静态代码块 01");
	}
	private static int n1 = getN1();//静态属性的初始化


	public static int getN1() {//静态方法
		System.out.println("getN1 被调用...");
		return 100; 
	}

	public int getN2() { //普通方法/非静态方法 
		System.out.println("getN2 被调用..."); 
	return 200;
	}

	//无参构造器 
	public A() {
		System.out.println("A() 构造器被调用"); 
	}
}

public class CodeBlockDetail02 {
	public static void main(String[] args) {
		A a = new A();
		/* 
			(1) A静态代码块 
			(2) getN1 被调用...
			(3) A 普通代码块 
			(4) getN2 被调用...
			(5) A() 构造器被调用
		*/
	}
}

class AAA { //父类 Object 
	{
		System.out.println("AAA 的普通代码块"); 
	}

	public AAA() { 
		//(1)super()
		//(2)调用本类的普通代码块
		System.out.println("AAA() 构造器被调用...."); 
	}
}
class BBB extends AAA { 
	{
		System.out.println("BBB 的普通代码块..."); 
	}
	
	public BBB() { 
		//(1)super()
		//(2)调用本类的普通代码块
		System.out.println("BBB() 构造器被调用...."); 
	}
}

public class CodeBlockDetail03 {
	public static void main(String[] args) {
		new BBB();
		/*
			(1)AAA 的普通代码块
			(2)AAA() 构造器被调用
			(3)BBB 的普通代码块
			(4)BBB() 构造器被调用 
		*/
	}
}

二、单例设计模式

2.1 什么是设计模式

2.2 什么是单例模式

2.3 单例模式应用实例

2.3.1 饿汉式—单例模式

/**
* 演示饿汉式的单例模式 
*/
public class SingleTon01 {
	public static void main(String[] args) { 
		//GirlFriend xh = new GirlFriend("小红"); 
		//GirlFriend xb = new GirlFriend("小白");
		
		//通过方法可以获取对象
		GirlFriend instance = GirlFriend.getInstance(); 	
		System.out.println(instance);
		
		GirlFriend instance2 = GirlFriend.getInstance(); 	
		System.out.println(instance2);
		
		System.out.println(instance == instance2);//T //表示是同一个对象	
		
	} 
}

class GirlFriend {
	private String name;
		// 为了能够在静态方法中，返回 gf 对象，需要将其修饰为 static 
		// 饿汉式表示创建对象但是沒有使用. 
		private static GirlFriend gf = new GirlFriend("小红红");
		// 如何保障我们只能创建一个 GirlFriend 对象 
		// 步骤[单例模式-饿汉式]
		//1. 将构造器私有化
		//2. 在类的内部直接创建对象(该对象是 static) 
		//3. 提供一个公共的 static 方法，返回 gf 对象 
		private GirlFriend(String name) {
			System.out.println("构造器被调用.");
			this.name = name; 
		}
		
		//获取构造器的方法
		public static GirlFriend getInstance() { 
			return gf;
		}
	}
}

2.3.2 懒汉式—单例模式

/**
* 演示懒汉式的单例模式 
*/
class Cat {
	private String name;
	public static int n1 = 999;
	
	//步骤
	//1.仍然构造器私有化
	private Cat(String name) {
		System.out.println("构造器调用...");
		this.name = name; 
	}

	//2.定义一個 static 静态属性
	private static Cat cat ;
	
	//3.提供一個 public 的 static 方法，可以返回一個 Cat 對象
	public static Cat getInstance() {
		if(cat == null) {
		//如果还没有创建 cat 对象
		cat = new Cat("小可爱");
	}

	//4.懒汉式，只有當用戶使用 getInstance 时，才返回 cat 对象, 后面再次调用時，会返回上次创建的 cat 對象 ,从而保证了单例
	
	return cat; 
}

public class SingleTon02 {
	public static void main(String[] args) {
		
		Cat instance = Cat.getInstance(); 
		System.out.println(instance);
		
		//再次调用 getInstance
		Cat instance2 = Cat.getInstance(); 
		System.out.println(instance2);
		
		System.out.println(instance == instance2);//T,表示是同一个对象
	} 
}

2.4 饿汉式 VS 懒汉式

本博客引用韩顺平老师Java课程