【无标题】

最新推荐文章于 2025-12-19 15:39:34 发布

原创最新推荐文章于 2025-12-19 15:39:34 发布 · 223 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #jvm #servlet

OOP进阶

static

static表示静态，是java中的一个修饰符，可以修饰成员方法，成员变量

被static修饰的成员变量，叫做静态变量

特点：

被该类所有对象共享
静态变量是随着类的加载而加载的，优先于对象出现的
不属于对象，属于类

调用方式：

类名调用（推荐）
对象名调用

被static修饰的成员方法，叫做静态方法

特点：

多用在测试类和工具类中
Javabean类中很少会用

调用方式：

类名调用（推荐）
对象名调用

ArrayUtil:

public class ArrayUtil {
    //私有化构造方法
    // 目的：不让外界创建他的对象
    private ArrayUtil() {
    }

    //printArr,用于返回整数数组的内容，需要定义为静态的方便调用
    public static String printArr(int[] arr) {
        StringJoiner sj = new StringJoiner(",", "[", "]");
        for (int i = 0; i < arr.length; i++) {
            sj.add(String.valueOf(arr[i]));
        }
        return sj.toString();
    }

    //getAverage，用于返回平均分
    public static double getAverage(double[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum / arr.length;
    }

    //获取一个随机元素的数组
    public static int[] getArr(int length) {
        //定义一个随机数
        Random r = new Random();
        int []arr = new int[length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(10);
        }
        return arr;
    }

    public static double getAverage(int[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum / arr.length;
    }
}

Test:

public class TestArray {
    public static void main(String[] args) {
        //获取一个长度为6的随机整型数组
        int [] arr = ArrayUtil.getArr(6);
        String str = ArrayUtil.printArr(arr);
        double average = ArrayUtil.getAverage(arr);
        System.out.println("随机数组为：" + str + "平均数为:" + average);
    }
}

StudentUtil:

public class StudentUtil {
    private StudentUtil() {
    }
    public static int getMaxScore(ArrayList<Student> list){
        int max = (int) list.get(0).getScore();
        for (int i = 0; i < list.size(); i++) {
            if(max < (int)list.get(i).getScore()){
                max = (int) list.get(i).getScore();
            }
        }
        return max;
    }
}

TestStudent:

public class TestStudent {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student s1 = new Student("罗阳",1,100);
        Student s2 = new Student("孙家",2,90);
        Student s3 = new Student("王文轩",3,95);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        int maxScore = StudentUtil.getMaxScore(list);
        System.out.println("最大分数为:" + maxScore);
    }
}

以前使用String[] args键盘接收数据，在程序参数里填入需要录入的信息即可。

现在直接Scanner即可

封装

对象代表什么，就得封装对应的数据，并提供数据对应的行为。

继承

java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系。

public class Student extends Person{}
Student称为子类，Person称为父类

使用继承的好处：

可以把多个子类中重复的代码抽取到父类中，子类可以直接使用，减少代码冗余，提高代码的复用性
子类可以得到父类的属性和行为，子类可以使用。子类可以在父类的基础上，增加其他的功能，使子类更强大

什么时候使用继承？

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码。

继承的特点：

java只支持单继承，不支持多继承，但支持多层继承（子-父-爷）

单继承：一个子类只能继承一个父类

不支持多继承：子类不能同时继承多个父类

多层继承：子类A继承父类B，父类B可以继承父类C
java中所有的类都直接或者间接继承于Object类
子类只能访问父类中非私有的成员

子类到底能继承父类中的哪些内容？

内存图
内存分析工具

成员变量私有时，虽然能被继承，但无法通过get、set调用

构造方法要与类名相同，子类不能继承父类构造方法

继承中成员变量访问特点：就近原则

先在局部位置找，本类成员位置找，父类成员位置找，逐级往上

如果出现了重名的成员变量：使用this，super

继承中成员方法访问特点：

方法的重写：

当父类的方法不能满足子类现在的需求时，需要进行方法重写

书写的格式：

在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

方法重写注意事项和要求：

重写方法的名称、形参列表必须与父类中的一致
子类重写父类时，访问权限子类必须大于等于父类

（null<protected<public）
子类重写父类的方法时，返回值类型子类必须小于等于父类

（比如父类返回值类型为Anmial，子类返回值类型为Dog）
建议：重写的方法尽量和父类保持一致
只有被添加到虚方法表中的方法才能被重写

继承中：构造方法的访问特点

父类中的构造方法不会被子类继承
子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。

为什么？

子类再初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。

怎么调用父类构造方法？

子类构造方法的第一行语句默认都是：super(),不写也存在，且必须在第一行。
如果想用父类有参构造，必须手动写super进行调用。

this、super使用总结

this:理解为一个变量，表示当前方法调用者的地址值
super：代表父类存储空间

多态

定义:同类型的对象，表现出的不同形态(对象的多种形态)

表现形式：父类类型对象名称=子类对象；

前提：

有继承关系
有父类引用指向子类对象
有方法重写

Fu f = new Zi();

**好处：**使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利

多态调用成员的特点

变量调用：编译看左边，运行也看左边

编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有，编译失败。

运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值。
方法调用：编译看左边，运行看右边

编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有，编译失败。

运行看右边：java运行代码的时候，实际运行的是子类中的方法

多态的优势

在多态的形式下，右边对象可以实现解耦合，便于扩展和维护
定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利

多态的弊端

不能使用子类的特有功能

引用数据类型的类型转换

小到大：自动类型转换

大到小：强制类型转化

强制类型转换能解决什么问题？

可以转换成真正的子类类型，从而调用子类独有的功能
转换类型与真实对象类型不一致会报错
转换的时候用instanceof关键字进行判断

包和final

包

包就是文件夹，用来管理各种不同功能的java类，方便后期代码维护。

final

final(最终的）不能被改变

final int a = 10;//常量不可被改变
System.out.println(a)

常量

实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性。

常量的命名规范：

单个单词：全部大写
多个单词：全部大写，单词之间用下划线隔开

细节：

final修饰的变是基本类型：那么变量存储的数据值不能发生改变。

final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，对象内部的可以改变。

权限修饰符

权限修饰符：用来控制一个成员能够被访问的范围的
可以修饰成员变量，方法，构造方法，内部类

实际开发中，一般只用private和public

成员变量私有
方法公开

特例：如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有

代码块：

局部代码块：提前结束变量生命周期，节约内存（渐渐淘汰）

构造代码块：（渐渐淘汰）

写在成员位置的代码块
作用：可以把多个构造方法中重复的代码抽取出来
执行时机：我们在创建本类对象时会先执行构造代码块再执行构造方法

静态代码块：(初始化)

**格式：**static{}

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

使用场景：在类加载的时候，做一些数据初始化的使用

static ArrayList<User> list = new ArrayList<>();

    static {
        list.add(new User("qt", "123456", "15306119540", "533256200101141415"));
    }

抽象类和抽象方法

抽象方法：将共性行为（方法）抽取到父类之后，由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体，该方法就可以定义为抽象方法。
抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类

抽象方法的定义格式：

public abstract 返回值类型方法名（参数列表）;

抽象类的定义格式：

public abstract class 类名{}

注意事项：

抽象类不能实例化（创建对象）：
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
可以有构造方法
抽象类的子类

要么重写抽象类中的所有抽象方法

要么是抽象类

**抽象类和抽象方法的意义：**规范代码，调用方法时，只需查看父类即可

接口

就是一个规则，对行为的抽象

接口中成员的特点

成员变量

只能是常量

默认修饰符：public static final
没有构造方法
成员方法

只能是抽象方法

默认修饰符：public abstract
JDK7以前：接口中只能定义抽象方法
JDK8的新特性：接口中可以定义有方法体的方法
JDK9的新特性：接口中可以定义私有方法

接口和类之间的关系

类和类的关系

继承关系，只能单继承，不能多继承，但是可以多层继承
类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口和接口的关系

继承关系，可以单继承，也可以多继承（如果实现类实现了最下面的子接口，就要重写所有方法）

内部类

在一个类的里面再定义一个类

在A类的内部定义B类，B类就被称为内部类

内部类的分类

成员内部类
静态内部类
局部内部类
匿名内部类

成员内部类

写在成员位置的，属于外部类的成员

静态内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象

局部内部类

将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量
外界是无法直接使用，需要在方法内部创建对象并使用
该类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类

匿名内部类本质上就是隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置。

格式的细节：包含了继承或实现，方法重写，创建对象。整体就是一个类的子类对象或者接口的实现类对象。

使用场景：当方法的参数是接口或者类时，以接口为例，可以传递这个接口的实现类对象，如果实现类只要使用一次，就可以用匿名内部类简化代码

拼图小游戏

参考黑马程序员
**

KeyAdapter

public abstract class KeyAdapter extends JFrame implements KeyListener, ActionListener {
    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {

    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    @Override
    public void actionPerformed(ActionEvent e) {

    }
}

MouseAdapter

public abstract class MouseAdapter extends JFrame implements MouseListener{

    @Override
    public void mouseClicked(MouseEvent e) {

    }

    @Override
    public void mousePressed(MouseEvent e) {

    }

    @Override
    public void mouseReleased(MouseEvent e) {

    }

    @Override
    public void mouseEntered(MouseEvent e) {

    }

    @Override
    public void mouseExited(MouseEvent e) {

    }
}

User

public class User {
    private String userName;
    private String userPassword;

    public User() {
    }

    public User(String userName, String userPassword) {
        this.userName = userName;
        this.userPassword = userPassword;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPassword() {
        return userPassword;
    }

    public void setUserPassword(String userPassword) {
        this.userPassword = userPassword;
    }
}

CodeUtil

public class CodeUtil {
    public static String getCode() {
        StringBuilder sb = new StringBuilder();
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            //添加大写小写字母到集合中
            list.add((char) ('a' + i));
            list.add((char) ('A' + i));
        }
        Random r = new Random();
//        System.out.println(list);
        for (int i = 0; i < 5; i++) {
            //获取随机索引
            int index = r.nextInt(list.size());
            char c = list.get(index);
            //添加随机字母
            sb.append(c);

        }
        //获取一个随机数字
        int number = r.nextInt(10);
        //获取随机验证码任意位置的索引
        int index = r.nextInt(5);
        //将sb转化为一个字符数组
        char[] arr = sb.toString().toCharArray();
        //将某一个位置的字母修改为随机数字
        char c = arr[index];
        arr[index] = (char) ('0' + number);
        String code = new String(arr);
        return code;
    }
}

GameJFrame

public class GameJFrame extends KeyAdapter {
    //创建一个二维数组
    int[][] arr = new int[4][4];
    //创建一个胜利的数组
    int[][] win = new int[][]{
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12},
            {13, 14, 15, 0}
    };
    //定义一个随机数
    Random r = new Random();
    //记录空白图片在二维数组中的位置
    int x = 0;
    int y = 0;
    //记录操作步数
    int step = 0;
    //定义图片路径
    String path;
    //随机产生图片
    int start = r.nextInt(3);

    //创建选项项目下面的条目信息
    JMenuItem rePlayItem = new JMenuItem("重新游戏");
    JMenuItem reLoginItem = new JMenuItem("重新登录");
    JMenuItem closeItem = new JMenuItem("关闭游戏");
    JMenuItem accountItem = new JMenuItem("公众号");

    JMenuItem girlItem = new JMenuItem("美女");
    JMenuItem animalItem = new JMenuItem("动物");
    JMenuItem sportItem = new JMenuItem("运动");
    //加入胜利图片
    JLabel winJLabel = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\win.png"));

    //对象初始化
    public GameJFrame() {

        //初始化界面
        initJFrame();

        //初始化菜单
        initMenuBar();

        //初始化数据
        initData();
        //初始化图片
        if (start == 0) {
            randomAnimal(r);
        } else if (start == 1) {
            randomGirl(r);
        } else if (start == 2) {
            randomSport(r);
        }
        //初始化图片
        initImage();


        //设置界面显示
        this.setVisible(true);
    }

    private void initData() {

        //含有16个数字的一维随机数组
        int[] arrTemp = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
        Random r = new Random();
        for (int i = 0; i < arrTemp.length; i++) {
            int t = r.nextInt(arrTemp.length);
            int temp = arrTemp[t];
            arrTemp[t] = arrTemp[i];
            arrTemp[i] = temp;
        }
        //将一维数组中的随机元素添加到二维数组中
        for (int i = 0; i < arrTemp.length; i++) {
            if (arrTemp[i] == 0) {
                //空白图片在二维数组的行  /
                x = i / 4;
                //空白图片在二维数组的列  %
                y = i % 4;
            }
            arr[i / 4][i % 4] = arrTemp[i];
        }
    }

    private void initImage() {
        //删除所有图片
        this.getContentPane().removeAll();
        JLabel stepJLabel = new JLabel("操作步数：  " + step);
        stepJLabel.setBounds(50, 20, 100, 30);
        this.getContentPane().add(stepJLabel);
        //判断是否胜利
        if (victory()) {
            winJLabel.setBounds(200, 200, 197, 73);
            this.getContentPane().add(winJLabel);
            winJLabel.setVisible(true);
        }
        //遍历二维数组
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                //获取当前要加载图片的序号
                int num = arr[i][j];
                //创建一个图片ImageIcon的对象
                ImageIcon icon = new ImageIcon(path + num + ".jpg");
                //创建一个JLabel的对象（管理容器）
                JLabel jLabel = new JLabel(icon);

                //指定图片位置
                jLabel.setBounds(105 * j + 83, 105 * i + 134, 105, 105);
                //添加图片边框
                jLabel.setBorder(new BevelBorder(BevelBorder.LOWERED));
                //把管理容器添加到界面中
                this.getContentPane().add(jLabel);
            }
        }
        //添加背景图片
        JLabel background = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\background.png"));
        background.setBounds(40, 40, 508, 560);
        this.getContentPane().add(background);
        //刷新
        this.getContentPane().repaint();
    }

    private boolean victory() {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != win[i][j]) {
                    return false;
                }
            }
        }
        return true;
    }

    private void initJFrame() {
        //设置界面的宽高
        setSize(603, 680);
        //设置界面标题
        this.setTitle("拼图单机版v1.0");
        //设置界面置顶
        this.setAlwaysOnTop(true);
        //设置界面居中
        this.setLocationRelativeTo(null);
        //设置关闭模式
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        //取消默认的居中放置，只有取消了才会按照XY轴的形式添加组件
        this.setLayout(null);
        //添加键盘监听
        this.addKeyListener(this);
    }

    private void initMenuBar() {
        //创建整个菜单对象
        JMenuBar jMenuBar = new JMenuBar();

        //创建整个菜单上面的两个选项的对象
        JMenu functionJMenu = new JMenu("功能");
        JMenu aboutJMenu = new JMenu("关于我们");
        JMenu changeJMenu = new JMenu("更换图片");


        //将菜单里面的两个选项添加到菜单当中
        jMenuBar.add(functionJMenu);
        jMenuBar.add(aboutJMenu);

        //将菜单项添加到菜单栏中
        functionJMenu.add(rePlayItem);
        functionJMenu.add(reLoginItem);
        functionJMenu.add(closeItem);
        functionJMenu.add(changeJMenu);
        aboutJMenu.add(accountItem);
        //嵌套更换图片菜单
        changeJMenu.add(girlItem);
        changeJMenu.add(animalItem);
        changeJMenu.add(sportItem);
        //给条目绑定监听事件
        rePlayItem.addActionListener(this);
        reLoginItem.addActionListener(this);
        closeItem.addActionListener(this);
        accountItem.addActionListener(this);
        girlItem.addActionListener(this);
        animalItem.addActionListener(this);
        sportItem.addActionListener(this);
        //给整个界面设置菜单
        this.setJMenuBar(jMenuBar);
    }

    //按下不松时会调用这个方法
    @Override
    public void keyPressed(KeyEvent e) {
        int code = e.getKeyCode();
        if (code == 65) {
            this.getContentPane().removeAll();
            //创建一个图片ImageIcon的对象
            ImageIcon icon = new ImageIcon(path + "all.jpg");
            //创建一个JLabel的对象（管理容器）
            JLabel jLabel = new JLabel(icon);
            //指定图片位置
            jLabel.setBounds(83, 134, 420, 420);
            //添加图片边框
            jLabel.setBorder(new BevelBorder(BevelBorder.LOWERED));
            //把管理容器添加到界面中
            this.getContentPane().add(jLabel);
            //添加背景图片
            JLabel background = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\background.png"));
            background.setBounds(40, 40, 508, 560);
            this.getContentPane().add(background);
            //刷新
            this.getContentPane().repaint();
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        //判断是否胜利
//        if (victory()) {
//            return;
//        }
        //记录按下按键值
        int code = e.getKeyCode();
        System.out.println(code);

        //左 上 右 下为37 38 39 40
        switch (code) {

            case 37 -> {
                if (y == 3) {
                    return;
                }
                arr[x][y] = arr[x][y + 1];
                arr[x][y + 1] = 0;
                y++;
                //操作步数加一
                step++;
                initImage();
                System.out.println("向左移动");
            }
            case 38 -> {
                if (x == 3) {
                    return;
                }
                arr[x][y] = arr[x + 1][y];
                arr[x + 1][y] = 0;
                x++;
                //操作步数加一
                step++;
                initImage();
                System.out.println("向上移动");


            }
            case 39 -> {
                if (y == 0) {
                    return;
                }
                arr[x][y] = arr[x][y - 1];
                arr[x][y - 1] = 0;
                y--;
                //操作步数加一
                step++;
                initImage();
                System.out.println("向右移动");

            }
            case 40 -> {
                if (x == 0) {
                    return;
                }
                arr[x][y] = arr[x - 1][y];
                arr[x - 1][y] = 0;
                x--;
                //操作步数加一
                step++;
                initImage();
                System.out.println("向下移动");
            }
            //松开A健
            case 65 -> {
                initImage();
            }
            //回车10，一键复原
            case 10 -> {
                //不能直接把win[][]赋值给arr，如果这样，赋值的是win的地址，arr后面的一系列操作会改变win地址下的元素
                arr = new int[][]{
                        {1, 2, 3, 4},
                        {5, 6, 7, 8},
                        {9, 10, 11, 12},
                        {13, 14, 15, 0}};
                initImage();
                System.out.println("一键复原");
//                //记录空图片位置
//                x = 3;
//                y = 3;
            }
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //获取当前被点击的条目对象
        Object obj = e.getSource();
        if (rePlayItem == obj) {
            System.out.println("重新游戏");
            //清除胜利标志
            if (victory()) {
                winJLabel.setVisible(false);
            }
            //计数清零
            step = 0;
            //重新打乱图片
            initData();
            //重新加载图片
            initImage();
        } else if (reLoginItem == obj) {
            System.out.println("重新登陆");
            //关闭当前的界面
            this.setVisible(false);
            //打开登录界面
            new LoginJFrame();
        } else if (closeItem == obj) {
            System.out.println("关闭游戏");
            //直接关闭虚拟机
            System.exit(0);
        } else if (accountItem == obj) {
            System.out.println("关于");
            //创建一个弹窗对象
            JDialog jDialog = new JDialog();
            //创建一个管理图片的容器对象
            JLabel jLabel = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\about.png"));
            //设置位置和宽高
            jLabel.setBounds(0, 0, 258, 258);
            //将图片添加到弹框
            jDialog.getContentPane().add(jLabel);
            //给弹框设置大小
            jDialog.setSize(344, 344);
            //让弹框置顶
            jDialog.setAlwaysOnTop(true);
            //让弹框居中
            jDialog.setLocationRelativeTo(null);
            //设置弹框不关闭无法操作下面的界面
            jDialog.setModal(true);
            //让弹框显示出来
            jDialog.setVisible(true);
        } else if (girlItem == obj) {
            randomGirl(r);
        } else if (animalItem == obj) {
            randomAnimal(r);
        } else if (sportItem == obj) {
            randomSport(r);
        }
    }

    private void randomSport(Random r) {
        int s = r.nextInt(10) + 1;
        path = "S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\sport\\sport" + s + "\\";
        //清除胜利标志
        if (victory()) {
            winJLabel.setVisible(false);
        }
        //计数清零
        step = 0;
        //重新打乱图片
        initData();
        //重新加载图片
        initImage();
    }

    private void randomAnimal(Random r) {
        int a = r.nextInt(8) + 1;
        path = "S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\animal\\animal" + a + "\\";
        //清除胜利标志
        if (victory()) {
            winJLabel.setVisible(false);
        }
        //计数清零
        step = 0;
        //重新打乱图片
        initData();
        //重新加载图片
        initImage();
    }

    private void randomGirl(Random r) {
        int g = r.nextInt(13) + 1;
        path = "S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\girl\\girl" + g + "\\";
        //清除胜利标志
        if (victory()) {
            winJLabel.setVisible(false);
        }
        //计数清零
        step = 0;
        //重新打乱图片
        initData();
        //重新加载图片
        initImage();
    }
}

LoginJFrame

public class LoginJFrame extends MouseAdapter {
    //创建一个集合存储正确的用户名和密码
    static ArrayList<User> allUsers = new ArrayList<>();
    //添加登录按钮
    JButton login = new JButton();
    //6.添加注册按钮
    JButton register = new JButton();
    //2.添加用户名输入框
    JTextField username = new JTextField();
    //4.密码输入框
    JTextField password = new JTextField();
    //验证码的输入框
    JTextField code = new JTextField();
    //获取正确验证码
    JLabel rightCode = new JLabel();

    //静态代码块初始化数据
    static {
        allUsers.add(new User("zhangsan", "123"));
        allUsers.add(new User("lisi", "123"));
    }

    //对象初始化
    public LoginJFrame() {
        //初始化界面
        initJFrame();
        //在这个界面中添加内容
        initView();
        this.setVisible(true);
    }

    private void initView() {
        //1. 添加用户名文字
        JLabel usernameText = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\用户名.png"));
        usernameText.setBounds(116, 135, 47, 17);
        this.getContentPane().add(usernameText);

        username.setBounds(195, 134, 200, 30);
        this.getContentPane().add(username);
        //3.添加密码文字
        JLabel passwordText = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\密码.png"));
        passwordText.setBounds(130, 195, 32, 16);
        this.getContentPane().add(passwordText);

        password.setBounds(195, 195, 200, 30);
        this.getContentPane().add(password);
        //验证码提示
        JLabel codeText = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\验证码.png"));
        codeText.setBounds(133, 256, 50, 30);
        this.getContentPane().add(codeText);

        code.setBounds(195, 256, 100, 30);
        this.getContentPane().add(code);
        //获取5位验证码
        String codeStr = CodeUtil.getCode();

        //设置内容
        rightCode.setText(codeStr);
        //位置和宽高
        rightCode.setBounds(300, 256, 50, 30);
        //添加到界面
        this.getContentPane().add(rightCode);
        //设置登录按钮属性
        login.setBounds(123, 310, 128, 47);
        login.setIcon(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\登录按钮.png"));
        //给登录按钮绑定监听
        login.addMouseListener(this);
        //去除按钮的默认边框
        login.setBorderPainted(false);
        //去除按钮的默认背景
        login.setContentAreaFilled(false);
        this.getContentPane().add(login);
        //设置注册属性
        register.setBounds(256, 310, 128, 47);
        register.setIcon(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\注册按钮.png"));
        //给注册按钮绑定监听
        register.addMouseListener(this);
        //去除按钮的默认边框
        register.setBorderPainted(false);
        //去除按钮的默认背景
        register.setContentAreaFilled(false);
        this.getContentPane().add(register);
        //7.添加背景图片
        JLabel background = new JLabel(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\background.png"));
        background.setBounds(0, 0, 470, 390);
        this.getContentPane().add(background);
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        if (e.getSource() == login) {
            System.out.println("点击了登录按钮");
            //获取两个文本输入框中的内容
            String usernameInput = username.getText();
            String passwordInput = password.getText();
            //获取用户输入的验证码
            String codeInput = code.getText();

            //创建一个User对象
            User userInfo = new User(usernameInput, passwordInput);
            System.out.println("用户输入的用户名为" + usernameInput);
            System.out.println("用户输入的密码为" + passwordInput);

            if (codeInput.length() == 0) {
                showJDialog("验证码不能为空");
            } else if (usernameInput.length() == 0 || passwordInput.length() == 0) {
                //校验用户名和密码是否为空
                System.out.println("用户名或者密码为空");

                //调用showJDialog方法并展示弹框
                showJDialog("用户名或者密码为空");


            } else if (!codeInput.equalsIgnoreCase(rightCode.getText())) {
                showJDialog("验证码输入错误");
            } else if (contains(userInfo)) {
                System.out.println("用户名和密码正确可以开始玩游戏了");
                //关闭当前登录界面
                this.setVisible(false);
                //打开游戏的主界面
                //需要把当前登录的用户名传递给游戏界面
                new GameJFrame();
            } else {
                System.out.println("用户名或密码错误");
                showJDialog("用户名或密码错误");
            }
        } else if (e.getSource() == register) {
            System.out.println("点击了注册按钮");
            //获取两个文本输入框中的内容
            String usernameInput = username.getText();
            String passwordInput = password.getText();
            //获取用户输入的验证码
            String codeInput = code.getText();
            //创建一个User对象
            User userInfo = new User(usernameInput, passwordInput);
            if (contains(userInfo)) {
                //调用showJDialog方法并展示弹框
                showJDialog("已经包含该用户，请重新注册！");
            } else if (usernameInput.length() == 0 || passwordInput.length() == 0) {
                //调用showJDialog方法并展示弹框
                showJDialog("用户名或者密码为空");
            } else {
                allUsers.add(new User(usernameInput, passwordInput));
                //调用showJDialog方法并展示弹框
                showJDialog("注册成功");
            }
        } else if (e.getSource() == rightCode) {
            System.out.println("更换验证码");
            //获取一个新的验证码
            String code = CodeUtil.getCode();
            rightCode.setText(code);
        }
    }

    @Override
    public void mousePressed(MouseEvent e) {
        if (e.getSource() == login) {
            login.setIcon(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\登录按下.png"));
        } else if (e.getSource() == register) {
            register.setIcon(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\注册按下.png"));
        }
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        if (e.getSource() == login) {
            login.setIcon(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\登录按钮.png"));
        } else if (e.getSource() == register) {
            register.setIcon(new ImageIcon("S:\\IdeaProjects\\javaSE\\基础语法\\src\\com\\puzzlegame\\njupt\\image\\login\\注册按钮.png"));
        }
    }

    private void initJFrame() {
        this.setSize(488, 430);
        //设置界面标题
        this.setTitle("拼图登陆界面");
        //设置界面置顶
        this.setAlwaysOnTop(true);
        //设置界面居中
        this.setLocationRelativeTo(null);
        //设置关闭模式
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        //取消内部默认布局
        this.setLayout(null);
    }

    //要展示用户名或密码错误
    public void showJDialog(String content) {
        //创建一个弹框对象
        JDialog jDialog = new JDialog();
        //给弹框设置大小
        jDialog.setSize(200, 150);
        //让弹框置顶
        jDialog.setAlwaysOnTop(true);
        //让弹框居中
        jDialog.setLocationRelativeTo(null);
        //弹框不关闭永远无法操作下面的界面
        jDialog.setModal(true);

        //创建Jlabel对象管理文字并添加到弹框当中
        JLabel warning = new JLabel(content);
        warning.setBounds(0, 0, 200, 150);
        jDialog.getContentPane().add(warning);

        //让弹框展示出来
        jDialog.setVisible(true);
    }

    //判断用户在集合中是否存在
    public boolean contains(User userInput) {
        for (int i = 0; i < allUsers.size(); i++) {
            User rightUser = allUsers.get(i);
            if (userInput.getUserName().equals(rightUser.getUserName()) && userInput.getUserPassword().equals(rightUser.getUserPassword())) {
                //有相同的代表存在，返回true，后面的不需要再比了
                return true;
            }
        }
        //循环结束之后还没有找到就表示不存在
        return false;
    }
}

RegisterJFrame

public class RegisterJFrame extends JFrame {
    //对象初始化
    public RegisterJFrame(){
        this.setSize(488,500);
        //设置界面标题
        this.setTitle("拼图注册界面");
        //设置界面置顶
        this.setAlwaysOnTop(true);
        //设置界面剧中
        this.setLocationRelativeTo(null);
        //设置关闭模式
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        //设置界面显示
        this.setVisible(true);
    }
}

App

public class App {
    public static void main(String[] args) {
//        new LoginJFrame();
//        new RegisterJFrame();
        new LoginJFrame();
    }
}