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修饰，说明工具方法只需要使用工具类名调用即可。此时必须把工具类的构造器私有化。防止创建对象调用静态方法。

巴特西