Java--二维数组，单例模式，工厂模式

一、二维数组

1.1 概述

• 存储数组的数组【数组嵌套】
• 数组中的元素还是数组

1.2 创建二维数组

​
public class Demo02 {
    public static void main(String[] args) {
        /**
         * 创建二维数组
         *  二维数组的长度是3：能存储3个一维数组
         *  一维数组长度不确定，数据类型是int
         */
        int[][] arr01 = new int[3][];
        // 二维数组中第一个一维数组长度是5
        arr01[0] = new int[5];
        // 二维数组中第二个一维数组长度是7
        arr01[1] = new int[7];
        // 二维数组中第三个一维数组
        arr01[2] = new int[] {1,2,3,4,5};
        
        // 二维数组中一维数组的静态初始化不能使用简写形式
        // arr01[2] = {};
        
        /**
         * 创建二维数组
         *  二维数组的长度是2：能存储2个一维数组
         *  每一个一维数组的长度都是5
         */
        int[][] arr02 = new int[2][5];
        
        /**
         * 创建二维数组
         *  二维数组的长度是2：有两个一维数组
         *  每个一维数组都已经存储了数据
         */
        int[][] arr03 = new int[][] {{1,2,3,4,5},{11,22,33}};
        
        /**
         * 创建二维数组
         *  二维数组的长度是2：有两个一维数组
         *  每个一维数组都已经存储了数据
         */
        int[][] arr04 = {{1,2,3,4,5},{11,22,33}};
    }
}

1.3 访问和遍历

​
public class Demo03 {
    public static void main(String[] args) {
        // 创建二维数组
        String[][] names = {
                {"曹操","曹植","典韦","许褚"},
                {"刘备","诸葛亮","魏延","赵云","关羽"},
                {"孙策","孙权","孙坚"}
        };
        
        // 访问每一个一维数组
        String[] nameWei = names[0];
        String[] nameShu = names[1];
        String[] nameWu = names[2];
        
        System.out.println(nameWei[0]);
        System.out.println(names[0][0]);
        
        for (int i = 0; i < names.length; i++) {
            for (int j = 0; j < names[i].length; j++) {
                System.out.println(names[i][j]);
            }
            System.out.println("-------------------");
        }
    }
}

二、单例模式

2.1 概述

• 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。
• 这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
• 确保只有单个对象被创建。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

2.2 代码实现【考题】

​
public class Demo02 {
    public static void main(String[] args) {
        
    }
}
​
/**
 * 懒汉式
 *  1、私有化构造器
 *  2、声明此类的私有静态变量
 *  3、公开静态的方法，在方法中判定是否第一次访问，如果是则创建此类实例，返回此类实例
 */
class LazySingleTon{
    private static LazySingleTon instance = null;
    
    private LazySingleTon() {}
    
    public static LazySingleTon getInstance() {
        // 第一访问方法instance是null,创建对象
        if (instance == null) {
            instance = new LazySingleTon();
        }
        return instance;
    }
}
​
/**
 * 单例模式--饿汉式
 *  1、私有化构造器
 *  2、创建私有静态此类实例
 *  3、公开静态方法返回此类实例
 */
class HungrySingleTon{
    // 类加载的时候直接创建此类的对象
    private static HungrySingleTon instance = new HungrySingleTon();
    
    // 私有化构造方法
    private HungrySingleTon() {}
    
    // 公开静态方法,返回此类的实例
    public static HungrySingleTon getInstance() {
        return instance;
    }
}

三、工厂模式

3.1 概述

• 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。
• 这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

3.2 代码实现

Auto

​
public abstract class Auto {
    public abstract void show();
}

Car

​
public class Car extends Auto {
    @Override
    public void show() {
        System.out.println("Car");
    }
}

AutoFactory

​
public class AutoFactory {
    
    /**
     *  生成汽车的方法
     * @param autoType  汽车类型编号
     * @return          汽车对象
     */
    public static Auto productAuto(int autoType) {
        Auto auto = null;
        
        switch (autoType) {
            case 1:
                auto = new Car();
                break;
            case 2:
                auto = new Bus();
                break;
            case 3:
                auto = new Tractor();
                break;
        }
        return auto;
    }
}

Demo01

​
import java.util.Scanner;
​
public class Demo01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入您需要的车型【1=Car,2=Bus,3=Tractor.】:");
        int autoType = sc.nextInt();
        
        // 调用工厂中的方法创建对象
        Auto auto = AutoFactory.productAuto(autoType);
        if (auto != null) {
            auto.show();
        } else {
            System.out.println("车型不存在");
        }
    }
}