Java学习笔记(九)——代码块和单例设计模式

Posted on Edited on In Word count in article: 5.2k Reading time ≈ 5 mins.

代码块

基本介绍

代码化块又称为初始化块，属于类中的成员【即是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示调用，而是加载类时，或创建对象时隐式调用。

基本语法

[修饰符] {代码};

说明注意：

  • 1、修饰符可选，要写的话，也只能写static
  • 2、代码块氛围两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。
  • 3、逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）

代码块的好处和案例演示

  • 1、相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作
  • 2、场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的复用性。
  • 3、代码块的快速入门
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
package com.learn.static_.codeblock_;

public class codeblock1 {
    public static void main(String[] args) {
        //下面三个构造器都有相同的语句
        //这样代码就会看起来比较冗余
        //这是我们可以把相同的语句，放入一个代码块中，即可
        //这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
        //代码块调用的顺序优先于构造器...
        test jack = new test("jack");
        test alan = new test("alan", 20);
        test smith = new test("smith", 20, 3000);

    }
}

 class test{
    private String name;
    private int age;
    private double salary;

    {
        System.out.println("我是一个人");
    }
    public test(String name) {
        this.name = name;
    }

    public test(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public test(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
}

使用细节、注意事项

  • 1、static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
  • 2、类什么时候被加载
    • （1）创建对象实例时（new）
    • （2）创建子类对象实例，父类也会被加载
    • （3）使用类的静态成员时（静态属性，静态方法）
  • 3、普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行。
  • 4、创建一个对象时，在一个类的调用顺序是（重点、难点！）
    • （1）调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按它们定义的顺序调用）
    • （2）调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用）
    • （3）调用构造方法。
  • 5、构造器的最前面其实隐含了super()和调用普通代码块（super优先于普通代码块），静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此事优先于构造器和普通代码块执行的。
  • 6、我们看一下创建一个子类对象时（继承关系），它们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：
    • （1）父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
    • （2）子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
    • （3）父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
    • （4）父类的构造方法
    • （5）子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
    • （6）子类的构造方法
  • 7、静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。

代码块应用——单例设计模式

什么是设计模式

  • 1、静态方法和属性的经典使用
  • 2、设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己思考和摸索。

什么是单例模式

  • 1、所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
  • 2、单例模式有两种方式：1）饿汉式 2）懒汉式

单例模式应用实例

饿汉式单例模式实现：

步骤如下：

  • 1、构造器私有化 => 防止用户直接new
  • 2、类的内部创建对象
  • 3、向外暴露一个静态的公共方法。getInstance
  • 4、代码实现
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
package com.learn.static_.Single_;

import java.util.GregorianCalendar;

public class SingleTon {
    public static void main(String[] args) {
        //直接通过方法获取对象
        GirlFriend instance = GirlFriend.getInstance();
        System.out.println(instance);
        //虽然这里获取了两次，但是它们是同一个对象，因为gf这个对象是静态的，它在类加载的时候只会创建一次
        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance2);

        System.out.println(instance == instance2);//true，说明是同一个对象
    }
}

//有一个类，GirlFriend
class GirlFriend{
    private String name;
    //如何保证我们只能创建一个girlfriend对象
    //步骤
    private static GirlFriend gf = new GirlFriend("alan");
    //1、将构造器私有化
    //2、类的内部创建对象,为了能够在静态方法中返回对象，需要将其修饰为static
    //3、提供一个公共的静态方法
    private GirlFriend(String name) {
        this.name = name;
    }

    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式单例模式实现：

饿汉式和懒汉式的区别在于：

  • 饿汉：可能没有使用这个实例，但他还是创建了。因此可能会存在一个情况：创建了但没有用，可能造成资源浪费
  • 懒汉：不用它，它就不创建对象，只有使用的时候才创建实例。

步骤：

  • 1、构造器私有化 => 防止用户直接new
  • 2、类的内部创建对象
  • 3、向外暴露一个静态的公共方法。getInstance
  • 4、代码实现
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
package com.learn.static_.Single_;

/**
 *
 * 演示懒汉式的单例模式
 */
public class SingleTon1 {
    public static void main(String[] args) {
        //System.out.println(Cat.n1);//懒汉式代码中，访问Cat.n1时不会执行到构造器，因为对象还没被创建,只会输出n1 = 100;
        Cat instance = Cat.getInstance();
        System.out.println(instance);
    }
}

class Cat{
    private String name;
    public static int n1 = 999;
    private static Cat cat;//不直接new了，采用懒汉式
    //步骤
    //1、仍然将构造器私有化
    //2、定义一个静态属性对象
    //3、提供一个public的static方法，可以返回一个cat对象
    //4、懒汉式，只有当用户使用getInstance时，才会返回cat对象，后面再次调用时，会返回上次创建的cat对象，从而保证了单例
    private Cat(String name) {
        System.out.println("构造器被调用");//懒汉式代码中，访问Cat.n1时不会执行到构造器，因为对象还没被创建。
        this.name = name;
    }
    public static Cat getInstance(){
        if(cat == null){//如果还没有创建Cat对象
            cat = new Cat("tom");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

饿汉式 VS 懒汉式

  • 1、二者最主要的区别在于创建对象的机制不同：饿汉式是在类加载的时候就创建了对象实例，而懒汉式是在使用时才创建。
  • 2、饿汉式不存在线程安全问题，懒汉式存在线程安全问题（后面学习线程后详细展开）
  • 3、饿汉式存在资源浪费的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
  • 4、在JavaSE标准类中，java.lang.Runtime就是经典的单例模式。