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