Java 面向对象（四）

代码块

什么是代码块

在类中或方法当中 使用 { } 括起来的一段代码，就称它是一个代码块。

在代码块当中定义的变量我们称是局部变量，在外面是没有办法使用的。这里定义的 a 就是一个局部变量。

代码块分类

（1）局部代码块

（2）初始化代码块

（4）静态代码块

局部代码块

直接定义在方法当中的代码块。一般结合 if，while ，for 等关键字一起使用，表示一块代码区域。在调用方法的时候执行。

初始化代码块

直接定义在类当中的代码。每次创建对象的时候，都会执行初始化代码块。

class Run {

	int n = 10;

	{
		System.out.println("执行初始化代码块");
	}

	Run() {
		System.out.println("对象创建中。。。");
	}

	Run(int n) {
		this.n = n;
		System.out.println("对象创建中。。。");
	}
}

public class Test {
	public static void main(String[] args) {
		new Run();
		new Run(2);
	}
}

输出结果：

执行初始化代码块
对象创建中。。。
执行初始化代码块
对象创建中。。。

初始化代码块本质是放到每个构造方法当中执行的，可以通过反编译查看。

反编译后：

class Run
{

	int n;

	Run()
	{
		n = 10;
		System.out.println("执行初始化代码块");
		System.out.println("对象创建中。。。");
	}

	Run(int n)
	{
		this.n = 10;
		System.out.println("执行初始化代码块");
		this.n = n;
		System.out.println("对象创建中。。。");
	}
}

静态代码块

在初始化代码块前面加上一个static，在加载字节码时就会自动调用，在主方法之前执行的。只执行一次。

静态代码块随着字节码加载也加载进了JVM，此时main方法还没有执行，因为方法需要JVM调用。

先把字节码加载进JVM，JVM再去调用main方法，静态代码块用来做一次性初始化操作。

组合

组合关系：自己当中的字段是一个“类”类型 ，依赖其它的类。

class Dog{
	String name;
}

class Person{
	String name;
	int age;
	// 人拥有狗
	Dog pet;
}

public class Test {

	public static void main(String[] args) {
		Person per = new Person();
		per.name = "zs";

		Dog dog = new Dog();
		dog.name = "wc";

		per.pet = dog;
		System.out.println(per.pet.name);			// 输出结果：wc
	}
}

类的加载

类在什么时候去加载？

当第一次使用该类对象的时候，去加载到JVM当中，只加载一次，下一次直接从内存当中使用了。

加载时，会执行 static。

字段的初始化

（1）静态字段初始化：是在静态代码块当中初始化。

（2）非静态的字段初始化：它是在构造器当中初始化。

例题，分析输出结果

public class MyXq {

	private static MyXq xq = new MyXq();
	private SubClass sub = new SubClass();

	static {
		System.out.println(3);
	}

	public MyXq() {
		System.out.println(4);
	}

	public static void main(String[] args) {
		System.out.println("main");
	}
}

class SuperClass {
	SuperClass() {
		System.out.println("构造器SuperClass");
	}
}

class SubClass extends SuperClass {
	static {
		System.out.println(1);
	}

	SubClass() {
		System.out.println(2);
	}
}

分析：

涉及知识点：

（1）类的加载

（2）字段的初始化

（3）子类构造器默认会调用父类的构造器

public class MyXq {

	private static MyXq xq = null;
	private SubClass sub = null;

	static {
		xq = new MyXq();
		System.out.println(3);
	}

	public MyXq() {
		sub = new SubClass();
		System.out.println(4);
	}

	public static void main(String[] args) {
		System.out.println("main");
	}
}

class SuperClass{
	SuperClass(){
		System.out.println("构造器SuperClass");
	}
}

class SubClass extends SuperClass{
	static {
		System.out.println(1);
	}
	SubClass(){
		super();
		System.out.println(2);
	}
}

程序开始，先找mmain入口，在MyXq类中，先加载MyXq类，执行MyXq类中的静态代码……

输出结果：

1
构造器SuperClass
2
4
3
main

final 关键字

什么是 final

final："最终，不可修改的"，保证数据的安全，只能用， 不能修改。

final 可以修饰字段、方法和类。

修饰字段 ： 不能再去修改该字段。

修饰方法 ： 子类就不能再去覆盖该方法 。

修饰类： 该类就不能再去被继承。

final 关键字注意点

（1）final 修饰字段时， 字段是没有默认初始值 ，必须得要自己手动设置初始值。

（2）final 修饰变量，就代表是一个常量 命令规则 ：所有的字母都大写。如：MAX_VALUE

（3）final 可以在局部代码块当中使用。

（4）如果final修饰的是基本数据类型 ，代表值不能再去修改了；如果final修饰的是一个引用类型，地址不能再去修改。

单例设计模式

什么是设计模式？

设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。之前很多程序员经常无数次的尝试，总结出来一套最佳实践。

什么是单例设计模式？

通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例

单例设计模式特点

（1）单例类只能有一个实例。

（2）单例类必须自己创建自己的唯一实例。

（3）单例类必须给所有其他对象提供这一实例。

单例设计模式优点

（1）控制资源的使用。

（2）控制实例的产生数量，达到节省资源目的。

（3）作为通信媒介，数据共享。

单例设计模式Java代码实现

饿汉模式：

（1）必须得要在该类中创建一个对象出来。

（2）私有化自己的构造器。防止外界通过构造器来创建新的对象。

（3）给外界提供一个方法，能够获取已经创建好的对象。

class ToolUtil {

	// 1.必须得要在该 类中创建一个对象出来。
	private static ToolUtil instance = new ToolUtil();

	// 2.私有化自己 的构造器。防止外界通过构造器来创建新的对象。
	private ToolUtil() {
	}

	// 3.给外界提供一个方法，能够 获取已经创建好的对象。
	static public ToolUtil getInstance() {
		return instance;
	}

}

工具类

什么是工具类

把一些经常使用的功能，写在一个类当中，我们称这个类就为工具类。以后使用该功能时， 直接调用。提前写好的一些常用功能。

工具类经常使用的包名

工具类我们都喜欢把它放在名字叫 util/utils 或 tool/tools 等。

大家都喜欢这样干，以后看到这样的包名，要清楚里面放的都是工具类。写好以后， 可以直接拿来使用。

如何设计工具类

（1）工具类当中的方法我们一般都会给它设计成静态的方法，直接使用类名来调用。

（2）如果是一个工具类当中的方法，没有使用static，我们一般都把工具类设计为单例，通过单例获取对象调用工具方法。

（3）如果工具类全部使用static修饰，说明工具方法只需要使用工具类名调用即可。此时必须把工具类的构造器私有化。防止创建对象调用静态方法。