JAVA面向对象进阶2---static应用知识：工具类

一、static应用知识：工具类

1、工具类是什么？

• 工具类都是一些静态方法，每个方法都是以完成一个公用的功能为目的，这个类用来给系统开发人员共同使用的。

2、为什么工具类中的方法不用实例来写？

• 因为工具类的这些方法只是为了完成一个公用功能，所以用静态来定义。
• 实例方法需要创建对象调用，此时用的对象知识为了调用方法，这样只会浪费内存。

3、工具类定义的其他要求

• 由于工具类里面都是静态方法，直接用类名即可访问，因此工具类无需创建对象，建议将工具类的构造器进行私有。

二、static应用知识：代码块

1、练习：定义数组工具类
需求:在实际开发中，经常会遇到一-些数组使用的工具类。请按照如下要求编写一个数组的工具类: ArraysUtils
①:我们知道数组对象直接输出的时候是输出对象的地址的，而项目中很多地方都需要返回数组的内容，请在
ArraysUtils中提供一个工具类方法toString,用于返回整数数组的内容,返回的字符串格式如: [10, 20, 50, 34,
100] (只考虑整数数组,且只考虑一维数组）

public class TextDemo {
    public static void main(String[] args) {
        int[] arr = {};
        int[] arr1 = null;
        int[] aar2 = {12,15,749,46,78};
        System.out.println(ArrayUtil.toString(arr));
        System.out.println(ArrayUtil.toString(arr1));
        System.out.println(ArrayUtil.toString(aar2));
    }
}


public class ArrayUtil {


    public ArrayUtil() {
        //私有化构造器
    }

    public static String toString(int[] arr) {

        if (arr == null) {
            return null;
        }
        String result = "[";

        for (int i = 0; i < arr.length; i++) {

            result += (i == arr.length - 1 ? arr[i] : arr[i] + ", ");

        }
        result += "]";
        return  result;
    }

}

2、代码块的分类、作用

代码块概述

• 代码块是类的5大成分之一(成员变量、构造器,方法，代码块,内部类) , 定义在类中方法外。

• 在Java类下，使用{}括起来的代码被称为代码块。

  代码块分为：

• 静态代码块:

• 格式: static{}

• 特点:需要通过static关键字修饰，随着类的加载而加载,并且自动触发、只执行- -次

• 使用场景:在类加载的时候做一些静 态数据初始化的操作，以便后续使用。

public class StaticDemo1 {
    
    public static String schoolName = "黑马";    //静态资源
    /**
     * 静态代码块：有static修饰，属于类。与类一起优先加载一次。自动触发执行
     * 作用：可以用于初始化静态资源。
     */
    static{
        System.out.println("静态代码块被执行了");
    };

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

• 构造代码块(了解，见的少) :
  • 格式:{}
  • 特点:每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
  • 使用场景:初始化实例资源。

public class StaticDemo2 {


    public StaticDemo2(){
        System.out.println("无参构造器被触发执行");
    }

    /**
     * 实例代码块：无static修饰，属于对象，每次构建对象时，都会出发一次
     */

    {
        System.out.println("实例代码块被触发执行");
    }

    public static void main(String[] args) {
        StaticDemo2 staticDemo2 = new StaticDemo2();
        StaticDemo2 staticDemo3 = new StaticDemo2();
        //输出
//        实例代码块被触发执行
//                无参构造器被触发执行
//        实例代码块被触发执行
//                无参构造器被触发执行

    }
}

3、静态代码块的应用案例

案例：斗地主游戏

需求:
在启动游戏房间的时候，应该提前准备好54张牌，后续才可以直接使用这些牌数据。
分析:
①该房间只需要一副牌。
②定义- -个静态的ArrayList集合存储54张牌对象，静态的集合只会加载一 -份。

③在启动游戏房间前，应该将54张牌初始化好
④当系统启动的同时需要准备好54张牌数据，此时可以用静态代码块完成。

package com.heima.heima.d3_static_code;

import java.util.ArrayList;

public class StaticText3 {

    /**
     * 1、定义一个静态集合；静态集合只加载一个，因为当前房间只需要一副牌
     */
    public static ArrayList<String> cards = new ArrayList<>();
    /**
     * 2、在程序真正运行main方法前，把54张牌放进去，后续游戏可以直接使用
     */
    static{
        //3.正式做牌放到集合中去
        //a、定义一个数组存储全部点数：；类型确定了  个数确定了
        String[] sizes = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //b、定义一个数组存储全部的花色：类型确定   个数确定
        String[] colors={"♥","♠","♣","♦"};

        //c、遍历点数
        for (int i = 0; i < sizes.length; i++) {

            for (int j = 0; j < colors.length; j++) {

                String  card = sizes[i]+colors[j];
                cards.add(card);
            }
        }
        //d、加入大小王
        cards.add("小罓");
        cards.add("大罓");
    }

    public static void main(String[] args) {
        System.out.println("新牌"+cards);

    }

}

总结：1、静态代码块的作用是什么?

• 如果要在启动系统时对静态资源进行初始化，则建议使用静态
• 代码块完成数据的初始化操作。

三、static应用知识：单例设计模式

1、什么是设计模式？

• 开发中经常遇到一些问题，一个问题通常有n种解法；但其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。

• 设计模式有20多种，对应20多种软件开发中会遇到的问题。

• 学习设计模式主要学两点：

  • 第一：这种设计模式用来解决什么问题。
  • 第二：遇到这种问题了，该模式是怎么写的。它是如何解决这个问题的。

2、单例模式：

• 可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象

• 例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

单例的实现方式很多

• 饿汉单例模式
• 懒汉单例模式
• …

3、饿汉单例模式

• 在用类获取对象的时候，对象已经提前为你创建好了。

设计步骤：

①定义一个构造器，把对象私有

②定义一个静态的变量存储一个对象

public class Text1 {
    public static void main(String[] args) {
        //目标：理解饿汉单例的设计模式
        SingleInstance s1 = SingleInstance.instance;
        SingleInstance s2 = SingleInstance.instance;
        System.out.println(s1   ==   s2);  //true

    }
}



/**
 * 使用饿汉单例实现单例类
 */
public class SingleInstance {
    /**
     * 1.把构造器私有化
     */
    public SingleInstance() {
    }
    /**
     * 2、饿汉单例是在获取对象前。对象已经提前准备好了一个；因为这个对象只能够是一个；所以定义定义静态成员变量记住。
     */
    public static SingleInstance instance = new SingleInstance();
}

4、懒汉单例模式

• 在真正需要对象的时候，才去创建一个对象(延迟加载对象)。

设计步骤：

• 定义一个类，把构造器私有。
• 定义一个静态变量存储一个对象
• 提供一个返回单例对象的方法

public class Text2 {
    public static void main(String[] args) {
        //目标：掌握懒汉单例的设计模式。理解其思想
        SingleInstance2 s1 = SingleInstance2.getInstance();
        SingleInstance2 s2 = SingleInstance2.getInstance();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 == s2);
    }
}


/**
 * 懒汉单例类
 */
public class SingleInstance2 {


    /**
     * 3、提供一个方法，对外返回单例对象
     * 注意：最好私有化，避免给别人
     */
    public static SingleInstance2 getInstance(){
        if (instance == null){
            //第一次来拿对象  此时需要创建对象
            instance = new SingleInstance2();
        }
        return instance;
    }

    /**
     * 2、定义一个静态成员变量负责存储一个对象
     * 只加载一次。在内存中只有一份
     */
    private static SingleInstance2 instance;

    /**
     * 1、私有化构造器
     */
    private SingleInstance2() {
    }
    
}