首页 > 编程语言> > java学习之旅（day.17）

java学习之旅（day.17）

2021-01-27 20:01:22 作者：互联网

GUI编程

GUI：图形用户界面编程

GUI快淘汰了

GUI的核心技术：Swing 、 AWT 这是类

做一个场景页面涉及的组件

窗口、弹窗、面板、文本框、列表框、按钮、图片、监听事件、鼠标、键盘、破解工具

AWT

抽象的窗口工具，String的前身

组件和容器

框架Frame

package com.zhang.GUI.Lesson01;

import java.awt.*;

//展示多个窗口，new多个Frame即可，要用到，继承封装
public class TestFrame2 {
    public static void main(String[] args) {
        MyFrame myFrame1=new MyFrame(100,100,200,200,Color.blue);
        MyFrame myFrame2=new MyFrame(300,100,200,200,Color.yellow);
        MyFrame myFrame3=new MyFrame(100,300,200,200,Color.green);
        MyFrame myFrame4=new MyFrame(300,300,200,200,Color.red);

    }
}
class MyFrame extends Frame{//继承了父类中的所有方法，还可以在下面写一些自己的方法
    static int id=0;//展示多个窗口，需要用到计数器
    //写一个构造器，因为要实例化
    public MyFrame(int x,int y,int w,int h,Color color){//参数为初始化位置
        super("MyFrame"+(++id));//调用父类的构造器，new Frame
        setBackground(color);
        setBounds(x,y,w,h);
        setVisible(true);//可直接调用方法
    }
}
/*
package com.zhang.GUI.Lesson01;

import java.awt.*;

//制作简单的页面
public class TestFrame {
    public static void main(String[] args) {
        Frame frame=new Frame("我的第一个java图形界面");
        //此时的界面在内存中是不可见的
        //需要设置可见性
        frame.setVisible(true);
        //设置窗口大小
        frame.setSize(400,400);
        //设置背景颜色
        frame.setBackground(new Color(67, 217, 25));
        //设置窗口弹出的初始位置  （0，0）在左上角
        frame.setLocation(200,200);
        //此时的窗口可以拉伸，设置大小固定
        frame.setResizable(false);
    }
}

 */

231

面板 Panel

package com.zhang.GUI.Lesson01;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

//panel  可以看成一个空间，但不能单独存在，选哟放在frame上
public class TestPanel {
    public static void main(String[] args) {
        Frame frame=new Frame();//窗口
        Panel panel=new Panel();//面板
        //设置布局
        frame.setLayout(null);//先设为默认的，不然会置顶
        //设置坐标
        frame.setBounds(300,200,500,500);
        frame.setBackground(new Color(64, 248, 13));
        //使用Panel设置坐标，Panel的坐标会相对于Frame的坐标，就是在Frame范围内再划分区域
        //即把Panel放在Frame里面
        panel.setBounds(50,50,400,400);
        panel.setBackground(new Color(252, 219, 8));
        //frame.add(panel)
        frame.add(panel);
        //上面就布局完了，但是还是显现不出来，需要可视化
        //设置可见性
        frame.setVisible(true);
        //监听事件  监听窗口关闭事件（System.exit(0)），上面写的点×的时候都是关闭不了的
        //适配器模式
        frame.addWindowListener(new WindowAdapter() {//需要什么就new什么
            //窗口关闭时需要做的事情
            @Override
            public void windowClosing(WindowEvent e) {
                //结束程序
                System.exit(0);//若写1则是以异常情况退出
            }
        });


    }
}

232

布局管理器

流式布局（从左到右）

package com.zhang.GUI.Lesson01;

import java.awt.*;

public class TestFlowLayout {
    public static void main(String[] args) {
        Frame frame=new Frame();
        //组件  按钮（button）
        Button button1=new Button("button1");
        Button button2=new Button("button2");
        Button button3=new Button("button3");

        //设置流式布局
        //frame.setLayout(new FlowLayout());//默认是按钮居中
        frame.setLayout(new FlowLayout(FlowLayout.LEFT));//往左

        frame.setSize(200,200);
        //添加按钮
        frame.add(button1);
        frame.add(button2);
        frame.add(button3);
        frame.setVisible(true);
    }
}

东西南北中（从上到下）

package com.zhang.GUI.Lesson01;

import java.awt.*;

public class TestBorderLayout {
    public static void main(String[] args) {
        Frame frame=new Frame("TestBorderLayout");

        Button east=new Button("East");
        Button west=new Button("West");
        Button south=new Button("South");
        Button north=new Button("North");
        Button center=new Button("Center");

        frame.add(east,BorderLayout.EAST);//通过frame把按钮添加到BorderLayout中
        frame.add(west,BorderLayout.WEST);
        frame.add(east,BorderLayout.SOUTH);
        frame.add(south,BorderLayout.SOUTH);
        frame.add(north,BorderLayout.NORTH);
        frame.add(center,BorderLayout.CENTER);

        frame.setSize(200,20);
        frame.setVisible(true);
    }
}

表格布局（3行2列那种）

package com.zhang.GUI.Lesson01;

import java.awt.*;

public class TestGridLayout {
    public static void main(String[] args) {
        Frame frame = new Frame("TestGridLayout");
        Button btn1 = new Button("btn1");
        Button btn2 = new Button("btn2");
        Button btn3 = new Button("btn3");
        Button btn4 = new Button("btn4");
        Button btn5 = new Button("btn5");
        Button btn6 = new Button("btn6");
        frame.setLayout(new GridLayout(3,2));
        frame.add(btn1);
        frame.add(btn2);
        frame.add(btn3);
        frame.add(btn4);
        frame.add(btn5);
        frame.add(btn6);
        frame.pack();//java函数，自动布局，自动选择最好的布局
        frame.setVisible(true);
        //监听
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}

小结

Frame是一个顶级（一级）窗口
Panel无法单独显示，必须添加到某个容器中（如：farme）
布局管理器

流式
东西南北中
表格

练习

package com.zhang.GUI.Lesson01;
//练习讲解
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestGridLayout {
    public static void main(String[] args) {
        Frame frame = new Frame();
        frame.setSize(400,300);
        frame.setLocation(300,400);
        frame.setBackground(Color.blue);
        frame.setVisible(true);
        frame.setLayout(new GridLayout(2,1));


        //4个面板
        Panel p1=new Panel(new BorderLayout());
        Panel p2=new Panel(new GridLayout(2,1));
        Panel p3=new Panel(new BorderLayout());
        Panel p4=new Panel(new GridLayout(2,2));
        //上面部分
        p1.add(new Button("East-1"),BorderLayout.EAST);
        p1.add(new Button("West-1"),BorderLayout.WEST);
        p2.add(new Button("p2-btn-1"));
        p2.add(new Button("p2-btn-2"));
        //p2需要添加到p1里
        p1.add(p2,BorderLayout.CENTER);
        //下面部分
        p3.add(new Button("East-2"),BorderLayout.EAST);
        p3.add(new Button("West-2"),BorderLayout.WEST);
        p4.add(new Button("p4-btn-1"));
        p4.add(new Button("p4-btn-2"));
        p4.add(new Button("p4-btn-3"));
        p4.add(new Button("p4-btn-4"));
        //上面四行也可以用一个循环
        /*for (int i = 0; i < 4; i++) {
            p4.add(new Button("for-"+i));
        }*/
        p3.add(p4,BorderLayout.CENTER);
        //再将panel放到frame中
        frame.add(p1);
        frame.add(p3);
        //监听
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}

233

大小、定位、背景颜色、可见性、监听

事件监听

事件监听：当某个事件发生的时候，干什么？有鼠标监听，键盘监听等

package com.zhang.GUI.Lesson02;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

//事件监听
public class TestActionEvent {
    public static void main(String[] args) {
        //按下按钮的时候，触发事件
        Frame frame=new Frame();
        Button button=new Button();
        //因为addActionListener()需要一个ActionListener，所以需要构造一个ActionListener()
        //接口就写实现类，父类就写继承
        MyActionListener myActionListener=new MyActionListener();
        button.addActionListener(myActionListener);
        frame.add(button,BorderLayout.CENTER);
        frame.pack();

        windowsClose(frame);//调用方法关闭窗口
        frame.setVisible(true);
    }
    //把关闭窗体的事件写成一个方法
    private static void windowsClose(Frame frame){
    frame.addWindowListener(new WindowAdapter() {
        @Override
        public void windowClosing(WindowEvent e) {
            System.exit(0);
        }
    });
    }

}
//事件监听
class MyActionListener implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("aaa");


    }
}

package com.zhang.GUI.Lesson02;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TestActionEvent02 {
    public static void main(String[] args) {
        //两个按钮实现一个监听
        //一个开始按钮，一个停止按钮，
        //可以显示的定义出发会返回的命令，如果不显示定义，则会走默认的值
        //可以多个按钮只写一个监听类
        Frame frame=new Frame("开始-停止");
        Button button1=new Button("start");
        Button button2=new Button("stop");

        button2.setActionCommand("button2-stop");

        MyMonitor myMonitor=new MyMonitor();
        button1.addActionListener(myMonitor);
        button2.addActionListener(myMonitor);

        frame.add(button1,BorderLayout.NORTH);
        frame.add(button2,BorderLayout.SOUTH);

        frame.pack();
        frame.setVisible(true);
    }
}
//事件监听
class MyMonitor implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按钮被点击了：msg"+e.getActionCommand());//getActionCommand()获取按钮上的一些信息
    }
}

输入框TextField事件监听

package com.zhang.GUI.Lesson02;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TestText01 {
    public static void main(String[] args) {
        //逐步过渡，main方法中只写启动代码
        new MyFrame();
    }
}
class MyFrame extends Frame{
    public MyFrame(){//构造器
        TextField textField=new TextField();//单行文本
        add(textField);
        //监听这个文本框输入的文字
        MyActionListener2 myActionListener2=new MyActionListener2();
        //按下enter就会触发这个输入框的事件
        textField.addActionListener(myActionListener2);//这里需要一个ActionListener，所以要写一个接口

        //设置替换代码（隐藏）
        textField.setEchoChar('*');
        setVisible(true);
        pack();
    }
}
class MyActionListener2 implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        TextField field=(TextField)e.getSource();//获得一些资源,返回一个对象
        System.out.println(field.getText());//获得输入框的文本
        field.setText("");//点enter就清空
    }
}

简易计算器

package com.zhang.GUI.Lesson02;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//简易计算器
public class TestCal {
    public static void main(String[] args) {
new Calculator();
    }
}
//计算器类
class Calculator extends Frame{
    public Calculator()  {
        //3个文本框
        TextField num1=new TextField(10);//10代表文本框能加10个字符
        TextField num2=new TextField(10);//10代表文本框能加10个字符
        TextField num3=new TextField(20);//10代表文本框能加10个字符
        //1个按钮
        Button button=new Button("=");
        button.addActionListener(new MyCalculatorListener(num1,num2,num3));
        //1个标签+
        Label label=new Label("+");
        //布局
        setLayout(new FlowLayout());//流式布局
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);

    }
}
//监听器类
class MyCalculatorListener implements ActionListener{
    //获取三个变量 使用构造器
    private TextField num1,num2,num3;
    public MyCalculatorListener(TextField num1,TextField num2,TextField num3) {
        this.num1=num1;
        this.num2=num2;
        this.num3=num3;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //1.获得家数和被加数  num.getText()  其返回值为String类型，要转为数
        int n1=Integer.parseInt(num1.getText());
        int n2=Integer.parseInt(num2.getText());
        
        //2.将这个值加法运算后，放到第3个框
        num3.setText(""+(n1+n2));

        //3.清除前两个框
        num1.setText("");
        num2.setText("");

    }
}

============================================================
    
 计算器优化
    package com.zhang.GUI.Lesson02;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//简易计算器优化
public class TestCalsimplify1 {
    public static void main(String[] args) {
        new Calculator1().loadFrame();
    }
}
//计算器类
class Calculator1 extends Frame{
        //属性
        TextField num1, num2, num3;
        //方法
        public void loadFrame () {
            //组件
            //3个文本框
            num1 = new TextField(10);//10代表文本框能加10个字符
            num2 = new TextField(10);//10代表文本框能加10个字符
            num3 = new TextField(20);//10代表文本框能加10个字符
            //1个按钮
            Button button = new Button("=");
            //1个标签+
            Label label = new Label("+");
            //组件需要的监听器
            button.addActionListener(new MyCalculatorListener1(this));
            //布局
            setLayout(new FlowLayout());//流式布局
            add(num1);
            add(label);
            add(num2);
            add(button);
            add(num3);

            pack();
            setVisible(true);
        }
    }

    //监听器类
    class MyCalculatorListener1 implements ActionListener {
        //获取计算器这个对象，在一个类中组合另外一个类
        Calculator1 calculator = null;

        public MyCalculatorListener1(Calculator1 calculator) {
            this.calculator = calculator;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            //1.获得加数和被加数  num.getText()  其返回值为String类型，要转为数
            int n1 = Integer.parseInt(calculator.num1.getText());
            int n2 = Integer.parseInt(calculator.num2.getText());
            //2.将这个值加法运算后，放到第3个框
            calculator.num3.setText("" + (n1 + n2));
            //3.清除前两个框
            calculator.num1.setText("");
            calculator.num2.setText("");
        }
    }
=========================================================
    使用内部类继续优化
    package com.zhang.GUI.Lesson02;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
//简易计算器优化
public class TestCalSimplified2 {
    public static void main(String[] args) {
        new Calculator2().loadFrame();
    }
}
//计算器类
class Calculator2 extends Frame{
    //属性
    TextField num1, num2, num3;
    //方法
    public void loadFrame () {
        //组件
        //3个文本框
        num1 = new TextField(10);//10代表文本框能加10个字符
        num2 = new TextField(10);//10代表文本框能加10个字符
        num3 = new TextField(20);//10代表文本框能加10个字符
        //1个按钮
        Button button = new Button("=");
        //1个标签+
        Label label = new Label("+");
        //组件需要的监听器
        button.addActionListener(new MyCalculatorListener2());
        //布局
        setLayout(new FlowLayout());//流式布局
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);

        pack();
        setVisible(true);
    }
    //监听器类    放在类里面，使用内部类  内部类最大的好处就是可以畅通无阻的访问外部的属性和方法
  private  class MyCalculatorListener2 implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            //1.获得加数和被加数  num.getText()  其返回值为String类型，要转为数
            int n1 = Integer.parseInt(num1.getText());
            int n2 = Integer.parseInt(num2.getText());
            //2.将这个值加法运算后，放到第3个框
            num3.setText("" + (n1 + n2));
            //3.清除前两个框
            num1.setText("");
            num2.setText("");
        }
    }
}

234

画笔

//仅仅是个画板，还不能画
package com.zhang.GUI.Lesson03;

import java.awt.*;

public class TestPaint {
    public static void main(String[] args) {
        new MyPaint().loadFrame();

    }
}
class MyPaint extends Frame {
    public void loadFrame(){//加载弹窗
        //设置大小
        setBounds(200,200,600,500);
        setVisible(true);

    }
    //画笔
    @Override
    public void paint(Graphics g) {
        super.paint(g);
    }
}



//简单画几何图形
package com.zhang.GUI.Lesson03;

import java.awt.*;

public class TestPaint {
    public static void main(String[] args) {
        new MyPaint().loadFrame();

    }
}
class MyPaint extends Frame {
    public void loadFrame(){//加载弹窗
        //设置大小
        setBounds(200,200,600,500);
        setVisible(true);

    }
    //画笔
    @Override
    public void paint(Graphics g) {
        //画笔需要颜色，画笔可以画画
        g.setColor(Color.red);//设置画笔颜色
        //g.drawOval(100,100,100,100);//画空心圆
        g.fillOval(100,100,100,100);//画一个实心的圆

    }
}

鼠标监听

目的：想要实现简单的鼠标点击画画

package com.zhang.GUI.Lesson03;

import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.Iterator;

//测试鼠标监听事件
public class TestMouseListener {
    public static void main(String[] args) {
        new MyFrame("画图");
    }
}
//自己的类
class MyFrame extends Frame {
    //画画需要画笔，需要监听鼠标当前的位置，需要集合来存储你画的点
    ArrayList points;
    public MyFrame(String title) {
        super(title);
        //设置一下窗口自己的属性
        setBounds(200, 200, 400, 300);//设置画板大小

        //存鼠标点击的点
        points = new ArrayList<>();

        setVisible(true);
        //鼠标监听器，针对这个窗口来说的
        this.addMouseListener(new MyMouseListener());//this就代表当前这个窗口


    }
    //有了画板，画画就要重写画笔

    @Override
    public void paint(Graphics g) {
        //画画需要监听鼠标的事件，不能直接去画，画的每一笔都需要跟鼠标绑定
        Iterator iterator = points.iterator();
        //通过while循环把里面的东西拿出来
        while (iterator.hasNext()) {
            Point point = (Point) iterator.next();//指向下一个点，返回当前的点
            g.setColor(Color.BLUE);
            g.fillOval(point.x, point.y, 10, 10);//画在当前鼠标点击的位置
        }
    }

    //添加一个点到界面上（怎么添加？用point把点画上去）
    public void addPoint(Point point) {
        points.add(point);//把当前穿过来的点放进去
    }


    //内部类
    //private class MyMouseListener implements MouseListener{} 这样写的话要重写大量的方法，
    //应采用适配器模式
    private class MyMouseListener extends MouseAdapter {
        //鼠标三个动作：按下、弹起、按住不放
        @Override
        public void mousePressed(MouseEvent e) {//e 获取鼠标的资源
            MyFrame frame = (MyFrame) e.getSource();//返回当前对象,就是拿到frame窗口了
            //此时拿到窗口了，然后就是画了,点击的时候就会在界面上产生一个点
            //这个点就是当前鼠标的这个点
            frame.addPoint(new Point(e.getX(), e.getY()));//此事点传到集合中遍历去了
            //new Point(e.getX(),e.getY());//这样就画了一个点

            //每次点击鼠标都让他重新画一遍
            frame.repaint();//执行画一次就刷新一次页面
        }
    }
}

窗口监听

package com.zhang.GUI.Lesson03;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

//窗口监听
public class TestWindows {
    public static void main(String[] args) {
        new WindowFrame();

    }

}

class WindowFrame extends Frame {
    public WindowFrame() {
        setBackground(Color.blue);
        setBounds(100,100,200,200);
        setVisible(true);
        addWindowListener(new MyWindowListener());

    }
    //写内部类
    class MyWindowListener extends WindowAdapter{
        //内部类想写什么方法就重写什么方法


        @Override
        public void windowClosing(WindowEvent e) {
            setVisible(false);//隐藏窗口
            System.exit(0);
        }
    }
}

//优化
package com.zhang.GUI.Lesson03;
        import java.awt.*;
        import java.awt.event.WindowAdapter;
        import java.awt.event.WindowEvent;
//窗口监听
public class TestWindowsSimplify {
    public static void main(String[] args) {
        new WindowFrame1();
    }
}
class WindowFrame1 extends Frame {
    public WindowFrame1() {
        setBackground(Color.blue);
        setBounds(100,100,200,200);
        setVisible(true);
        //addWindowListener(new MyWindowListener());
        this.addWindowListener(
                //直接用匿名内部类
                new WindowAdapter() {//new出来未生成对象，所以这个类没名字
                    @Override
                    public void windowClosing(WindowEvent e) {
                        System.out.println("你点击了×");
                    }
                }
        );
    }
}

===========================================================
    //稍作修改
    package com.zhang.GUI.Lesson03;
        import java.awt.*;
        import java.awt.event.WindowAdapter;
        import java.awt.event.WindowEvent;
//窗口监听
public class TestWindowsSimplify {
    public static void main(String[] args) {
        new WindowFrame1();
    }
}
class WindowFrame1 extends Frame {
    public WindowFrame1() {
        setBackground(Color.blue);
        setBounds(100,100,200,200);
        setVisible(true);
        //addWindowListener(new MyWindowListener());
        this.addWindowListener(
                //直接用匿名内部类
                new WindowAdapter() {//new出来未生成对象，所以这个类没名字
                    @Override
                    public void windowClosing(WindowEvent e) {
                        System.out.println("你点击了×");
                        System.out.println("windowsclosing");
                        System.exit(0);
                    }
                    //激活窗口

                    @Override
                    public void windowActivated(WindowEvent e) {
                        WindowFrame1 source=(WindowFrame1)e.getSource();
                        source.setTitle("被激活了");
                    }
                }
        );
    }
}

键盘监听

package com.zhang.GUI.Lesson03;

import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

//键盘监听
public class TestKeyListener {
    public static void main(String[] args) {
        new KeyFrame();
    }
}
class KeyFrame extends Frame{
    //构造器
    public KeyFrame() {
        setBounds(1,2,300,400);
        setVisible(true);
        //监听键盘
        this.addKeyListener(new KeyAdapter() {
            //键盘按下出现一些事件
            @Override
            public void keyPressed(KeyEvent e) {
                //获得键盘按下的是哪一个键
                int keycode=e.getKeyCode();//获取当前键盘按键的码，每一个键都对应一个码
                System.out.println(keycode);
                if(keycode==KeyEvent.VK_UP){
                    System.out.println("你按下了上键");

                }
            }
        });
    }
}

Swing

窗口（Jframe）、面板

package com.zhang.GUI.Lesson04;

import javax.swing.*;
import java.awt.*;

public class JFrameDemo {
    //init():初始化窗口
    public void init(){
        JFrame jf=new JFrame("这是一个JFrame窗口");
        jf.setVisible(true);
        jf.setBounds(100,100,200,200);
        jf.setBackground(Color.blue);
        //设置文字Jlabel
        JLabel label=new JLabel("学java");
        //label要放到JFrame上
        jf.add(label);
        //关闭事件，这里不需要再设计监听器了，里面已经设计好了
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        //建立一个窗口，此处窗口用初始化出来，不再建类
        new JFrameDemo().init();
    }

}

标题居中

package com.zhang.GUI.Lesson04;

import javax.swing.*;
import java.awt.*;

public class jframeDemo02 {
    public static void main(String[] args) {
        new MyJframe2().init();
    }
}
class MyJframe2 extends JFrame{
    public void init(){
        this.setVisible(true);
        this.setBounds(10,10,200,300);
        //设置文字Jlabel
        JLabel label=new JLabel("学java");
        //label要放到JFrame上
        this.add(label);
        //让文本标签居中
        label.setHorizontalAlignment(SwingConstants.CENTER);


        //获得一个容器，容器里的颜色才是真正的颜色，这是与AWT的区别之一
        Container container=this.getContentPane();
        container.setBackground(Color.BLUE);
    }
}

弹窗

JDialog，用来被弹出，默认就有关闭事件

package com.zhang.GUI.Lesson04;
//弹窗


import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//主窗口
public class DialogDemo extends JFrame {
    //构造器
    public DialogDemo() {
       this.setVisible(true);
       this.setSize(700,500);
       //关闭
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        //JFrame放东西需要一个容器
         Container container =this.getContentPane();
         //绝对布局
        container.setLayout(null);
        //按钮
        JButton button=new JButton("点击弹出一个对话框");//创建
        button.setBounds(30,30,200,50);
        //点击按钮的时候弹出一个弹窗，此时需要一个监听事件
        button.addActionListener(new ActionListener() {//监听器，让他调用另外一个方法，让他弹窗
            @Override
            public void actionPerformed(ActionEvent e) {
                //弹窗
                new MyDialogDemo();


            }
        });

        //再把按钮加到容器中
        container.add(button);

    }

    public static void main(String[] args) {
new DialogDemo();
    }
}
//弹窗的窗口
class MyDialogDemo extends JDialog{
    //构造器
    public MyDialogDemo() {
        this.setVisible(true);
        this.setBounds(100,100,500,500);
        //关闭的默认操作
        //this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);JDialog，用来被弹出，默认就有关闭事件
        Container container=this.getContentPane();
        //设置为绝对定位
        container.setLayout(null);
        container.add(new Label("java学习"));
    }
}

package com.zhang.GUI.Lesson04;

import javax.swing.*;
import java.awt.*;

//图标是一个接口，不能new，需要实现类， Frame继承
public class IconDemo extends JFrame implements Icon {
    //会返回宽高，设计个宽高,如何传递过去呢，用一个有参构造
    private int width;
    private int height;
//无参构造
    public IconDemo()  {
    }
//当然还要来个有参构造

    public IconDemo(int width, int height)  {
        this.width = width;
        this.height = height;
    }
    //初始化
    public void init(){
        //首先初始化这个类
        IconDemo iconDemo=new IconDemo(15,15);//把图标的大小传递过去,会返回图标iconDemo，图标放在标签上，也可以放在按钮上
        JLabel label=new JLabel("icontest",iconDemo,SwingConstants.CENTER);//图标  放哪个哪个图标  位置
        Container container=getContentPane();
        container.add(label);

        this.setVisible(true);
        //关闭
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
    //画个圆吧
        g.fillOval(x,y,width,height);
    }

    @Override
    public int getIconWidth() {
        return this.width;
    }

    @Override
    public int getIconHeight() {
        return this.height;
    }

    public static void main(String[] args) {
        new IconDemo().init();

    }

}

加图片标签

package com.zhang.GUI.Lesson04;
//把图片当图标放上去
import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class ImageIconDemo extends JFrame {
    //构造器


    public ImageIconDemo()  {
        //图片要放到标签里，再new个label
        JLabel label=new JLabel("ImageIcon");
        //获取图片地址
        URL url=ImageIconDemo.class.getResource("报名.png");//获取当前这个class这个类下面同级资源,返回一个url，url是一个具体的地址
        //现在把图放到标签上
        ImageIcon imageIcon=new ImageIcon(url);
        label.setIcon(imageIcon);//把图片放上去
        label.setHorizontalAlignment(SwingConstants.CENTER);//让图片居中
        Container container=getContentPane();
        container.add(label);

        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(100,100,200,200);
    }

    public static void main(String[] args) {
        new ImageIconDemo();
    }
}

面板

JPanel

package com.zhang.GUI.Lesson05;

import javax.swing.*;
import java.awt.*;

public class JPanelDemo extends JFrame {
    //构造器

    public JPanelDemo() {
        //所有东西是放在容器中所以
        Container container=this.getContentPane();
        //设置容器的样子
        container.setLayout(new GridLayout(2,1,10,10));//后面两个参数是指上下间距
        //开始在容器中放JPanel
        JPanel panel1=new JPanel(new GridLayout(1,3));//面板的布局状态
        
        panel1.add(new JButton("1"));
        panel1.add(new JButton("1"));
        panel1.add(new JButton("1"));

        container.add(panel1);

        this.setVisible(true);
        this.setSize(500,500);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        
    }

    public static void main(String[] args) {
        new JPanelDemo();
    }
}

JScrollPanel 滚动条

package com.zhang.GUI.Lesson05;
//滚动条
import javax.swing.*;
import java.awt.*;

public class JScrollDemo extends JFrame {
    public JScrollDemo()  {
        Container container=this.getContentPane();

        //文本域
        JTextArea textArea=new JTextArea(20,20);//可以设置下文本域的大小
        textArea.setText("学java");

        //Scroll面板
        JScrollPane scrollPane=new JScrollPane(textArea);//边框可以跟着滚动条滚动
        //又是要放到容器里
        container.add(scrollPane);

        this.setVisible(true);
        this.setBounds(100,100,300,350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new JScrollDemo();
    }
}

按钮

图片按钮

package com.zhang.GUI.Lesson05;
//带滚动条的面板
import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class JButtonDemo01 extends JFrame {
    public JButtonDemo01() {
        //和之前的一样，用JFrame的话首先要获得容器,所有东西可以在container上操作
        Container container=this.getContentPane();
        //将一个图片变成一个图标
          //获取图片的地址
        URL resource=JButtonDemo01.class.getResource("报名.png");//获得一个URL路径
          //URL变成一个图标（icon）
        Icon icon=new ImageIcon(resource);

        //把图标放在(变成)按钮
        JButton button=new JButton();
        button.setIcon(icon);
        button.setToolTipText("图片按钮");//提示按钮

        //把图加到容器
        container.add(button);

        this.setVisible(true);
        this.setSize(500,300);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new JButtonDemo01();

    }
}

单选按钮(radioButton)

package com.zhang.GUI.Lesson05;
//单选框
import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class JButtonDemo02 extends JFrame {
    public JButtonDemo02() {
        //和之前的一样，用JFrame的话首先要获得容器,所有东西可以在container上操作
        Container container=this.getContentPane();
        //将一个图片变成一个图标
        //获取图片的地址
        URL resource=JButtonDemo01.class.getResource("报名.png");//获得一个URL路径
        //URL变成一个图标（icon）
        Icon icon=new ImageIcon(resource);

        //单选框
          //3个按钮
        JRadioButton radioButton1=new JRadioButton("JRadioButton01");
        JRadioButton radioButton2=new JRadioButton("JRadioButton02");
        JRadioButton radioButton3=new JRadioButton("JRadioButton03");
        //由于单选框只能选择一个，故需要分组，如上面三个button在一个组里，只能选择其中一个
        //如果不分组的话，三个都会被点到，所以需要new个组
        ButtonGroup group=new ButtonGroup();//把按钮分组
        //再把按钮添加到组里，3个按钮到一个组，一个组中只能选择一个
        group.add(radioButton1);
        group.add(radioButton2);
        group.add(radioButton3);//如果没有上面4行代码，就可以多选了，多选框原理类似，但名字不叫radiobutton

        container.add(radioButton1,BorderLayout.CENTER);
        container.add(radioButton2,BorderLayout.NORTH);
        container.add(radioButton3,BorderLayout.SOUTH);


        this.setVisible(true);
        this.setSize(500,300);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new JButtonDemo02();

    }
}

复选按钮 qq登录界面

package com.zhang.GUI.Lesson05;

import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class JButtonDemo03 extends JFrame {
    public JButtonDemo03() {
        //和之前的一样，用JFrame的话首先要获得容器,所有东西可以在container上操作
        Container container=this.getContentPane();
        //将一个图片变成一个图标
        //获取图片的地址
        URL resource=JButtonDemo01.class.getResource("报名.png");//获得一个URL路径
        //URL变成一个图标（icon）
        Icon icon=new ImageIcon(resource);

        //多选框,多选就不用再去分组了
        JCheckBox checkbox01=new JCheckBox("checkbox1");
        JCheckBox checkbox02=new JCheckBox("checkbox2");

        //加到容器
        container.add(checkbox01,BorderLayout.NORTH);
        container.add(checkbox02,BorderLayout.SOUTH);



        this.setVisible(true);
        this.setSize(500,300);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    public static void main(String[] args) {
        new JButtonDemo03();

    }
}

列表

下拉框

package com.zhang.GUI.Lesson05;

import javafx.scene.control.ComboBox;

import javax.swing.*;
import java.awt.*;

//下拉框
public class TestComboboxDemo01 extends JFrame {
    public TestComboboxDemo01() {
        Container container=this.getContentPane();

        //new ComboBox<>();//泛型，但可以直接将泛型去掉，如下
        JComboBox status=new JComboBox();

        status.addItem(null);
        status.addItem("正在热映");
        status.addItem("下架");
        status.addItem("即将上映");

        container.add(status);


        this.setVisible(true);
        this.setSize(500,350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new TestComboboxDemo01();
    }
}

列表

package com.zhang.GUI.Lesson05;

import javax.swing.*;
import java.awt.*;
import java.util.Vector;

public class TestComboboxDemo02 extends JFrame {
    public TestComboboxDemo02() {
        Container container=this.getContentPane();

        //生成列表的内容
        String[] contents={"1","2","3"};//数组静态初始化

        /*数组还可以放其他数据类型如：vector
                Vector contents1=new Vector();
        contents1.add("z");
        contents1.add("x");
        contents1.add("t");
         */
        //列表中需要放内容，怎么放，直接丢到构造器中就可以
        JList list=new JList(contents);//列表

        container.add(list);

        this.setVisible(true);
        this.setSize(500,350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new TestComboboxDemo02();
    }
}

应用场景

下拉框一般用于选择地区（如选择中国，只弹出中国的国家），或者一些单个选项
列表用来展示一些信息，一般是动态扩容的

文本框

文本框

package com.zhang.GUI.Lesson05;
//文本框
import javax.swing.*;
import java.awt.*;

public class TestTextDemo01 extends JFrame {
    public TestTextDemo01() {
        Container container=this.getContentPane();

        //文本框
        JTextField textField=new JTextField("hello");
        JTextField textField2=new JTextField("world",20);//20 文本框的大小

        container.add(textField,BorderLayout.NORTH);
        container.add(textField2,BorderLayout.SOUTH);

        this.setVisible(true);
        this.setSize(500,350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new TestTextDemo01();
    }
}

密码框

package com.zhang.GUI.Lesson05;

import javax.swing.*;
import java.awt.*;

//密码框
public class TestTextDemo02 extends JFrame {
    public TestTextDemo02() {
        Container container=this.getContentPane();

        //密码框
        JPasswordField passwordField=new JPasswordField();
        passwordField.setEchoChar('*');//输入的东西都是以*显示

        container.add(passwordField);

        this.setVisible(true);
        this.setSize(500,350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new TestTextDemo02();
    }
}

文本域

配合面板使用

package com.zhang.GUI.Lesson05;
//滚动条
import javax.swing.*;
import java.awt.*;

public class JScrollDemo extends JFrame {
    public JScrollDemo()  {
        Container container=this.getContentPane();

        //文本域
        JTextArea textArea=new JTextArea(20,20);//可以设置下文本域的大小
        textArea.setText("学java");

        //Scroll面板
        JScrollPane scrollPane=new JScrollPane(textArea);//边框可以跟着滚动条滚动
        //又是要放到容器里
        container.add(scrollPane);

        this.setVisible(true);
        this.setBounds(100,100,300,350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new JScrollDemo();
    }
}

贪吃蛇

帧：如果时间片足够小，就是动画了。连起来是动画，拆开就是静态的图片

键盘监听

定时器Timer

四部曲：

定义数据
画上去
监听事件

如果事件监听的就放到事件监听里

如果键盘监听的就放到键盘监听里

绘制静态的小蛇

package com.zhang.GUI.Lesson06.snake;

import com.zhang.GUI.Lesson06.Data;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

//游戏的面板
public class GamePanel extends JPanel {//这样继承后就自带面板了，再在里面写一些方法就好了，当然你也可以自己写一个类创建面板
    //定义蛇的数据结构  脑袋，身体 节数
    int length;//蛇的长度
    int[] snakex=new int[600];//蛇的x坐标   数组
    int[] snakey=new int[500];//蛇的y坐标   数组
    String fx;//小蛇的脑袋不是一直向右，来个初始方向向右

    //new的时候要放到构造器里去初始化
    public GamePanel() {
       //在构造器中调用init方法即可
        init();
    }

    //1.用构造器或者init方法初始化   初始化小蛇的位置
    public void init(){
        length=3;//小蛇初始化长度为3，3个身体
        snakex[0]=100;snakey[0]=100;//头部的位置
        snakex[1]=75;snakey[1]=100;//第一截身体的位置
        snakex[2]=50;snakey[2]=100;//第二截身体的位置
          fx="R";//初始方向向右
        //4游戏当前的状态  开始  停止
    boolean isStart=false;//默认是不开始

    //绘制面板,游戏中的所有东西都是用这个画笔来画
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        super.paintComponents(g);//清屏，不要的话屏幕会闪烁
        //面板建好了，数据也弄好了，开始绘制静态的面板
        this.setBackground(Color.WHITE);
        Data.header.paintIcon(this,g,25,11);//this代表当前这个panel   //把头部header话上去
        //现在将面板放入游戏就可以了
        g.fillRect(25,75,850,600);//默认的游戏界面

        //2.把小蛇画上去
        if(fx.equals("R")){
            Data.right.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("L")){
            Data.left.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("U")){
            Data.up.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("D")){
            Data.down.paintIcon(this,g,snakex[0],snakey[0]);
        }

        for (int i = 1; i < length; i++) {//头肯定不能变，所以从第一节身体开始
            Data.body.paintIcon(this,g,snakex[i],snakey[i]);
        }
        //4.游戏的状态 开始  结束
        if(isStart==false) {
            g.setColor(Color.WHITE);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("按下空格开始游戏", 300, 300);//未开始，要在界面画点文字(画在300，300这个位置)，画前指定画笔的颜色
    }

让小蛇动起来

package com.zhang.GUI.Lesson06.snake;

import com.zhang.GUI.Lesson06.Data;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

//游戏的面板
public class GamePanel extends JPanel implements KeyListener  {//这样继承后就自带面板了，再在里面写一些方法就好了，当然你也可以自己写一个类创建面板
    //定义蛇的数据结构  脑袋，身体 节数
    int length;//蛇的长度
    int[] snakex=new int[600];//蛇的x坐标   数组
    int[] snakey=new int[500];//蛇的y坐标   数组
    String fx;//小蛇的脑袋不是一直向右，来个初始方向向右

    //new的时候要放到构造器里去初始化
    public GamePanel() {
       //在构造器中调用init方法即可
        init();
        //获得焦点和键盘事件
        this.setFocusable(true);//获取焦点事件
        this.addKeyListener(this);//获取键盘的监听事件  由于是写在当前这个类，故不用new，用this，若写在其他类要new监听器
    }

    //1.用构造器或者init方法初始化   初始化小蛇的位置
    public void init(){
        length=3;//小蛇初始化长度为3，3个身体
        snakex[0]=100;snakey[0]=100;//头部的位置
        snakex[1]=75;snakey[1]=100;//第一截身体的位置
        snakex[2]=50;snakey[2]=100;//第二截身体的位置
          fx="R";//初始方向向右
        //4游戏当前的状态  开始  停止
    boolean isStart=false;//默认是不开始

    //绘制面板,游戏中的所有东西都是用这个画笔来画
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        super.paintComponents(g);//清屏，不要的话屏幕会闪烁
        //面板建好了，数据也弄好了，开始绘制静态的面板
        this.setBackground(Color.WHITE);
        Data.header.paintIcon(this,g,25,11);//this代表当前这个panel   //把头部header话上去
        //现在将面板放入游戏就可以了
        g.fillRect(25,75,850,600);//默认的游戏界面

        //2.把小蛇画上去
        if(fx.equals("R")){
            Data.right.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("L")){
            Data.left.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("U")){
            Data.up.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("D")){
            Data.down.paintIcon(this,g,snakex[0],snakey[0]);
        }

        for (int i = 1; i < length; i++) {//头肯定不能变，所以从第一节身体开始
            Data.body.paintIcon(this,g,snakex[i],snakey[i]);
        }
        //4.游戏的状态 开始  结束
        if(isStart==false) {
            g.setColor(Color.WHITE);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("按下空格开始游戏", 300, 300);//未开始，要在界面画点文字(画在300，300这个位置)，画前指定画笔的颜色
    }

      //键盘监听事件
    @Override
    public void keyPressed(KeyEvent e) {//按下空格开始，所以要监听键盘，首先要监听空格（那就先获得当前键盘的keycode）
        int keycode=e.getKeyCode();//获得键盘的按键是哪一个
        if (keycode==KeyEvent.VK_SPACE){//如果按下的是空格
            isStart=!isStart;//取反
            repaint();//说是值变化了，需要重新paint，不懂
//完了后让小蛇动起来，5就要用到定时器了，使用定时器就要实现一个定时器的接口ActionListener,然后再重写定时的方法
        }     
    }
        
        
        
    @Override
    public void keyReleased(KeyEvent e) {
    }
    @Override
    public void keyTyped(KeyEvent e) {//下面这两个没用，放着就行
    }
}       //5.键盘监听器，写一个监听的类 可以写内部类，也可以写外部类。或者单独写也可以。本次使用内部类，使用内部类的话，要去实现一个接口implements keyListener,然后重写方法即可


   //重复：定义一个数据    初始化 画上去  监听它

键盘控制小蛇移动

package com.zhang.GUI.Lesson06.snake;

import javax.swing.*;

//游戏的主启动类
public class StartGame {
    public static void main(String[] args) {
        JFrame frame=new JFrame();

        //设置窗口的属性
        frame.setBounds(10,10,900,720);//大小先不管
        frame.setResizable(false);//设置窗口大小不可变
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        //正常情况下界面应该在面板上
        //将面板放入游戏
        frame.add(new GamePanel());

        frame.setVisible(true);
    }
}



package com.zhang.GUI.Lesson06.snake;

import com.zhang.GUI.Lesson06.Data;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

//游戏的面板
public class GamePanel extends JPanel implements KeyListener , ActionListener {//这样继承后就自带面板了，再在里面写一些方法就好了，当然你也可以自己写一个类创建面板
    //定义蛇的数据结构  脑袋，身体 节数
    int length;//蛇的长度
    int[] snakex=new int[600];//蛇的x坐标   数组
    int[] snakey=new int[600];//蛇的y坐标   数组
    String fx;//小蛇的脑袋不是一直向右，来个初始方向向右
      //4游戏当前的状态  开始  停止
    boolean isStart=false;//默认是不开始
    //5定时器Timer  以毫秒为单位
    Timer timer=new Timer(100,this);//100毫秒刷新一次，监听当前这个事件

    //new的时候要放到构造器里去初始化
    public GamePanel() {
       //在构造器中调用init方法即可
        init();
        //获得焦点和键盘事件
        this.setFocusable(true);//获取焦点事件
        this.addKeyListener(this);//获取键盘的监听事件  由于是写在当前这个类，故不用new，用this，若写在其他类要new监听器
        timer.start();//游戏一开始定时器就启动
    }

    //1.用构造器或者init方法初始化   初始化小蛇的位置
    public void init(){
        length=3;//小蛇初始化长度为3，3个身体
        snakex[0]=100;snakey[0]=100;//头部的位置
        snakex[1]=75;snakey[1]=100;//第一截身体的位置
        snakex[2]=50;snakey[2]=100;//第二截身体的位置
        fx="R";//初始方向向右
    }

    //绘制面板,游戏中的所有东西都是用这个画笔来画
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        super.paintComponents(g);//清屏，不要的话屏幕会闪烁
        //面板建好了，数据也弄好了，开始绘制静态的面板
        this.setBackground(Color.WHITE);
        Data.header.paintIcon(this,g,25,11);//this代表当前这个panel   //把头部header话上去
        //现在将面板放入游戏就可以了
        g.fillRect(25,75,850,600);//默认的游戏界面

        //2.把小蛇画上去
        //默认初始小蛇向右，需要通过方向来判断
        /*Data.right.paintIcon(this,g,snakex[0],snakey[0]);//  舌头初始化默认向右this  画到当前面板
        Data.body.paintIcon(this,g,snakex[1],snakey[1]);
        Data.body.paintIcon(this,g,snakex[2],snakey[2]);
        body是动态的，后面需要随length的变大而变大长大，用for循环
         */
        if(fx.equals("R")){
            Data.right.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("L")){
            Data.left.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("U")){
            Data.up.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("D")){
            Data.down.paintIcon(this,g,snakex[0],snakey[0]);
        }

        for (int i = 1; i < length; i++) {//头肯定不能变，所以从第一节身体开始
            Data.body.paintIcon(this,g,snakex[i],snakey[i]);
        }
        //4.游戏的状态 开始  结束
        if(isStart==false) {
            g.setColor(Color.WHITE);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("按下空格开始游戏", 300, 300);//未开始，要在界面画点文字(画在300，300这个位置)，画前指定画笔的颜色
            //现在小蛇有了，字有了，现在需要变得动态起来（即实现监听）
        }
    }


      //键盘监听事件
    @Override
    public void keyPressed(KeyEvent e) {//按下空格开始，所以要监听键盘，首先要监听空格（那就先获得当前键盘的keycode）
        int keycode=e.getKeyCode();//获得键盘的按键是哪一个
        if (keycode==KeyEvent.VK_SPACE){//如果按下的是空格
            isStart=!isStart;//取反
            repaint();//说是值变化了，需要重新paint，不懂
//完了后让小蛇动起来，5就要用到定时器了，使用定时器就要实现一个定时器的接口ActionListener,然后再重写定时的方法
        }

        //6现在小蛇只能朝右移动，需要继续优化，使其能上下左右都能移动
        //另外，小蛇方向改变后，记得还要改变脑袋的方向
        if (keycode==KeyEvent.VK_UP){
            fx="U";

        }else if (keycode==KeyEvent.VK_DOWN){
            fx="D";
        }else if (keycode==KeyEvent.VK_LEFT){
            fx="L";
        }else if (keycode==KeyEvent.VK_RIGHT){
            fx="R";
        }//此时只是通过键盘的上下左右控制脑袋在转，并没有是实现小蛇上下左右跑
        //我们要在此时让小蛇往上下左右走，需要去事件监听中继续写
    }
    @Override
    public void keyReleased(KeyEvent e) {
    }
    @Override
    public void keyTyped(KeyEvent e) {//下面这两个没用，放着就行
    }

    //事件监听（定时器），需要通过固定的事件来刷新，如1秒10次
    @Override
    public void actionPerformed(ActionEvent e) {
        if (isStart){//如果游戏是开始状态，就让小蛇动起来，如何动？就是坐标变化
          /* //右移
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i]=snakex[i-1];//身体向右移动一节
                snakey[i]=snakey[i-1];
            }
            snakex[0]=snakex[0]+25;//向右移动一节
            if (snakex[0]>850){
                snakex[0]=25;
            }
           */
            //7上面注释掉的只是向右移动，现在要通过判断使小蛇上下左右移动
              //移动  身体部分不用变，变头即可
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i] = snakex[i - 1];//身体向右移动一节
                snakey[i] = snakey[i - 1];
            }
                //走向   此时把边界判断也一起加进去
                if (fx.equals("R")) {
                    snakex[0] = snakex[0] + 25;
                    if (snakex[0] > 850) {//边界判断
                        snakex[0] = 25;
                    }
                } else if (fx.equals("L")) {
                    snakex[0] = snakex[0] - 25;
                    if (snakex[0] < 25) {
                        snakex[0] = 850;
                    }
                } else if (fx.equals("U")) {
                    snakey[0] = snakey[0] - 25;
                    if (snakey[0] < 75) {
                        snakey[0] = 650;
                    }
                } else if (fx.equals("D")) {
                    snakey[0] = snakey[0] + 25;
                    if (snakey[0] > 650) {
                        snakey[0] = 75;
                    }
                }
    
            repaint();//变完后重画页面
        }
        //重画页面后，开启定时器
        timer.start();//此处的启动只是在监听器启动了

    }
}       //5.键盘监听器，写一个监听的类 可以写内部类，也可以写外部类。或者单独写也可以。本次使用内部类，使用内部类的话，要去实现一个接口implements keyListener,然后重写方法即可





package com.zhang.GUI.Lesson06;

import javax.swing.*;
import java.net.URL;

//数据中心：只有数据
public class Data {
    //相对路径  如 报名.png
    //绝对路径  只需在前面加/   /相当于当前项目下
    public static URL headerURL=Data.class.getResource("statics/header.png");
    //最后会变成一个Icon图标
    public static ImageIcon header=new ImageIcon(headerURL);//图片变Icon
    //剩下的几张图片也是一样的代码
    public static URL upURL=Data.class.getResource("statics/up.png");
    public static URL downURL=Data.class.getResource("statics/down.png");
    public static URL leftURL=Data.class.getResource("statics/left.png");
    public static URL rightURL=Data.class.getResource("statics/right.png");

    public static ImageIcon up=new ImageIcon(upURL);//图片变Icon
    public static ImageIcon down=new ImageIcon(downURL);//图片变Icon
    public static ImageIcon left=new ImageIcon(leftURL);//图片变Icon
    public static ImageIcon right=new ImageIcon(rightURL);//图片变Icon

    public static URL bodyURL=Data.class.getResource("statics/body.png");
    public static ImageIcon body=new ImageIcon(bodyURL);//图片变Icon

    public static URL foodURL=Data.class.getResource("statics/food.png");
    public static ImageIcon food=new ImageIcon(foodURL);//图片变Icon
}

小蛇吃食物长大

Data和StartGame与上面的部分是一样的
    package com.zhang.GUI.Lesson06.snake;

import com.zhang.GUI.Lesson06.Data;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

//游戏的面板
public class GamePanel extends JPanel implements KeyListener , ActionListener {//这样继承后就自带面板了，再在里面写一些方法就好了，当然你也可以自己写一个类创建面板
    //定义蛇的数据结构  脑袋，身体 节数
    int length;//蛇的长度
    int[] snakex=new int[600];//蛇的x坐标   数组
    int[] snakey=new int[600];//蛇的y坐标   数组
    String fx;//小蛇的脑袋不是一直向右，来个初始方向向右

    //7现在小蛇已经能够上下左右动了，需要开始吃食物长大
    int foodx;
    int foody;
      //还要个随机数组
    Random random=new Random();//这样就有了一个默认的随机数组，然后在初始化中初始化食物的数据

      //4游戏当前的状态  开始  停止
    boolean isStart=false;//默认是不开始
    //5定时器Timer  以毫秒为单位
    Timer timer=new Timer(75,this);//100毫秒刷新一次，监听当前这个事件

    //new的时候要放到构造器里去初始化
    public GamePanel() {
       //在构造器中调用init方法即可
        init();
        //获得焦点和键盘事件
        this.setFocusable(true);//获取焦点事件
        this.addKeyListener(this);//获取键盘的监听事件  由于是写在当前这个类，故不用new，用this，若写在其他类要new监听器
        timer.start();//游戏一开始定时器就启动
    }

    //1.用构造器或者init方法初始化   初始化小蛇的位置
    public void init(){
        length=3;//小蛇初始化长度为3，3个身体
        snakex[0]=100;snakey[0]=100;//头部的位置
        snakex[1]=75;snakey[1]=100;//第一截身体的位置
        snakex[2]=50;snakey[2]=100;//第二截身体的位置
        fx="R";//初始方向向右

        //8把食物随机的分布在游戏的界面上,然后再把食物画到面板上
        foodx=25+25*random.nextInt(34);//850/25=34  random.nextInt随机的一个数字   这样就得到界面内随机的x坐标
        foody=75+75*random.nextInt(24);
    }

    //绘制面板,游戏中的所有东西都是用这个画笔来画
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        super.paintComponents(g);//清屏，不要的话屏幕会闪烁
        //面板建好了，数据也弄好了，开始绘制静态的面板
        this.setBackground(Color.WHITE);
        Data.header.paintIcon(this,g,25,11);//this代表当前这个panel   //把头部header话上去
        //现在将面板放入游戏就可以了
        g.fillRect(25,75,850,600);//默认的游戏界面

        //2.把小蛇画上去
        //默认初始小蛇向右，需要通过方向来判断
        /*Data.right.paintIcon(this,g,snakex[0],snakey[0]);//  舌头初始化默认向右this  画到当前面板
        Data.body.paintIcon(this,g,snakex[1],snakey[1]);
        Data.body.paintIcon(this,g,snakex[2],snakey[2]);
        body是动态的，后面需要随length的变大而变大长大，用for循环
         */
        if(fx.equals("R")){
            Data.right.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("L")){
            Data.left.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("U")){
            Data.up.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("D")){
            Data.down.paintIcon(this,g,snakex[0],snakey[0]);
        }

        for (int i = 1; i < length; i++) {//头肯定不能变，所以从第一节身体开始
            Data.body.paintIcon(this,g,snakex[i],snakey[i]);
        }
        //8.画食物,然后再事件监听中判断食物的状态
        Data.food.paintIcon(this,g,foodx,foody);
        //4.游戏的状态 开始  结束
        if(isStart==false) {
            g.setColor(Color.WHITE);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("按下空格开始游戏", 300, 300);//未开始，要在界面画点文字(画在300，300这个位置)，画前指定画笔的颜色
            //现在小蛇有了，字有了，现在需要变得动态起来（即实现监听）
        }
    }


      //键盘监听事件
    @Override
    public void keyPressed(KeyEvent e) {//按下空格开始，所以要监听键盘，首先要监听空格（那就先获得当前键盘的keycode）
        int keycode=e.getKeyCode();//获得键盘的按键是哪一个
        if (keycode==KeyEvent.VK_SPACE){//如果按下的是空格
            isStart=!isStart;//取反
            repaint();//说是值变化了，需要重新paint，不懂
//完了后让小蛇动起来，5就要用到定时器了，使用定时器就要实现一个定时器的接口ActionListener,然后再重写定时的方法
        }

        //6现在小蛇只能朝右移动，需要继续优化，使其能上下左右都能移动
        //另外，小蛇方向改变后，记得还要改变脑袋的方向
        if (keycode==KeyEvent.VK_UP){
            fx="U";

        }else if (keycode==KeyEvent.VK_DOWN){
            fx="D";
        }else if (keycode==KeyEvent.VK_LEFT){
            fx="L";
        }else if (keycode==KeyEvent.VK_RIGHT){
            fx="R";
        }//此时只是通过键盘的上下左右控制脑袋在转，并没有是实现小蛇上下左右跑
        //我们要在此时让小蛇往上下左右走，需要去事件监听中继续写
    }
    @Override
    public void keyReleased(KeyEvent e) {
    }
    @Override
    public void keyTyped(KeyEvent e) {//下面这两个没用，放着就行
    }

    //事件监听（定时器），需要通过固定的事件来刷新，如1秒10次
    @Override
    public void actionPerformed(ActionEvent e) {
        if (isStart){//如果游戏是开始状态，就让小蛇动起来，如何动？就是坐标变化
          /* //右移
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i]=snakex[i-1];//身体向右移动一节
                snakey[i]=snakey[i-1];
            }
            snakex[0]=snakex[0]+25;//向右移动一节
            if (snakex[0]>850){
                snakex[0]=25;
            }
           */
            //9.判断食物的状态
              //吃食物
            if (snakex[0]==foodx&&snakey[0]==foody){//蛇头和食物的坐标重合意味着吃到了，小蛇开始长大，吃完再产生随机食物
                length++;//长度加1
                //吃完后再重新生成随机食物，不用再去写身体了
                foodx=25+25*random.nextInt(34);//850/25=34  random.nextInt随机的一个数字   这样就得到界面内随机的x坐标
                foody=75+75*random.nextInt(24);
            }

            //7上面注释掉的只是向右移动，现在要通过判断使小蛇上下左右移动
              //移动  身体部分不用变，变头即可
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i] = snakex[i - 1];//身体向右移动一节
                snakey[i] = snakey[i - 1];
                //走向   此时把边界判断也一起加进去
                if (fx.equals("R")) {
                    snakex[0] = snakex[0] + 25;
                    if (snakex[0] > 850) {//边界判断
                        snakex[0] = 25;
                    }
                } else if (fx.equals("L")) {
                    snakex[0] = snakex[0] - 25;
                    if (snakex[0] < 25) {
                        snakex[0] = 850;
                    }
                } else if (fx.equals("U")) {
                    snakey[0] = snakey[0] - 25;
                    if (snakey[0] < 75) {
                        snakey[0] = 650;
                    }
                } else if (fx.equals("D")) {
                    snakey[0] = snakey[0] + 25;
                    if (snakey[0] > 650) {
                        snakey[0] = 75;
                    }
                }
            }

            //还需要加边界判断，不然小蛇就跑出界面回不来了（出了界面再让他回原来的位置即可）


            repaint();//变完后重画页面
        }
        //重画页面后，开启定时器
        timer.start();//此处的启动只是在监听器启动了

    }
}       //5.键盘监听器，写一个监听的类 可以写内部类，也可以写外部类。或者单独写也可以。本次使用内部类，使用内部类的话，要去实现一个接口implements keyListener,然后重写方法即可


   //重复：定义一个数据    初始化 画上去  监听它

失败判定与积分系统

失败判定

package com.zhang.GUI.Lesson06.snake;

import com.zhang.GUI.Lesson06.Data;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

//游戏的面板
public class GamePanel extends JPanel implements KeyListener , ActionListener {//这样继承后就自带面板了，再在里面写一些方法就好了，当然你也可以自己写一个类创建面板
    //定义蛇的数据结构  脑袋，身体 节数
    int length;//蛇的长度
    int[] snakex=new int[600];//蛇的x坐标   数组
    int[] snakey=new int[500];//蛇的y坐标   数组
    String fx;//小蛇的脑袋不是一直向右，来个初始方向向右

    //7现在小蛇已经能够上下左右动了，需要开始吃食物长大
    int foodx;
    int foody;
      //还要个随机数组
    Random random=new Random();//这样就有了一个默认的随机数组，然后在初始化中初始化食物的数据

      //4游戏当前的状态  开始  停止
    boolean isStart=false;//默认是不开始

    //10.游戏失败的判断
    boolean isFail=false;//游戏状态默认不失败  然后画数据，失败的标志


    //5定时器Timer  以毫秒为单位
    Timer timer=new Timer(75,this);//100毫秒刷新一次，监听当前这个事件

    //new的时候要放到构造器里去初始化
    public GamePanel() {
       //在构造器中调用init方法即可
        init();
        //获得焦点和键盘事件
        this.setFocusable(true);//获取焦点事件
        this.addKeyListener(this);//获取键盘的监听事件  由于是写在当前这个类，故不用new，用this，若写在其他类要new监听器
        timer.start();//游戏一开始定时器就启动
    }

    //1.用构造器或者init方法初始化   初始化小蛇的位置
    public void init(){
        length=3;//小蛇初始化长度为3，3个身体
        snakex[0]=100;snakey[0]=100;//头部的位置
        snakex[1]=75;snakey[1]=100;//第一截身体的位置
        snakex[2]=50;snakey[2]=100;//第二截身体的位置
        fx="R";//初始方向向右

        //8把食物随机的分布在游戏的界面上,然后再把食物画到面板上
        foodx=25+25*random.nextInt(34);//850/25=34  random.nextInt随机的一个数字   这样就得到界面内随机的x坐标
        foody=75+75*random.nextInt(24);
    }

    //绘制面板,游戏中的所有东西都是用这个画笔来画
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        super.paintComponents(g);//清屏，不要的话屏幕会闪烁
        //面板建好了，数据也弄好了，开始绘制静态的面板
        this.setBackground(Color.WHITE);
        Data.header.paintIcon(this,g,25,11);//this代表当前这个panel   //把头部header话上去
        //现在将面板放入游戏就可以了
        g.fillRect(25,75,850,600);//默认的游戏界面

        //2.把小蛇画上去
        //默认初始小蛇向右，需要通过方向来判断
        /*Data.right.paintIcon(this,g,snakex[0],snakey[0]);//  舌头初始化默认向右this  画到当前面板
        Data.body.paintIcon(this,g,snakex[1],snakey[1]);
        Data.body.paintIcon(this,g,snakex[2],snakey[2]);
        body是动态的，后面需要随length的变大而变大长大，用for循环
         */
        if(fx.equals("R")){
            Data.right.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("L")){
            Data.left.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("U")){
            Data.up.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("D")){
            Data.down.paintIcon(this,g,snakex[0],snakey[0]);
        }

        for (int i = 1; i < length; i++) {//头肯定不能变，所以从第一节身体开始
            Data.body.paintIcon(this,g,snakex[i],snakey[i]);
        }
        //8.画食物,然后再事件监听中判断食物的状态
        Data.food.paintIcon(this,g,foodx,foody);
        //4.游戏的状态 开始  结束
        if(isStart==false) {
            g.setColor(Color.WHITE);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("按下空格开始游戏", 300, 300);//未开始，要在界面画点文字(画在300，300这个位置)，画前指定画笔的颜色
            //现在小蛇有了，字有了，现在需要变得动态起来（即实现监听）
        }
        //11.画游戏失败的标志，然后去键盘监听（空格此刻要让他有双重作用）
        if (isFail){
            g.setColor(Color.RED);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("失败，按下空格重新开始", 300, 300);

        }
    }

      //键盘监听事件
    @Override
    public void keyPressed(KeyEvent e) {//按下空格开始，所以要监听键盘，首先要监听空格（那就先获得当前键盘的keycode）
        int keycode=e.getKeyCode();//获得键盘的按键是哪一个
        /*if (keycode==KeyEvent.VK_SPACE){//如果按下的是空格
            isStart=!isStart;//取反
            repaint();//说是值变化了，需要重新paint，不懂
          //11.此刻要让键盘实现双重作用，更改如下：
         */
        if (keycode==KeyEvent.VK_SPACE){//如果按下的是空格
            if (isFail){
                //重新开始
                isFail=false;
                //然后重新初始化   12.还得去事件监听里改点东西
                init();
            }else {
                isStart=!isStart;//取反
            }
            repaint();
//完了后让小蛇动起来，5就要用到定时器了，使用定时器就要实现一个定时器的接口ActionListener,然后再重写定时的方法
        }

        //6现在小蛇只能朝右移动，需要继续优化，使其能上下左右都能移动
        //另外，小蛇方向改变后，记得还要改变脑袋的方向
        if (keycode==KeyEvent.VK_UP){
            fx="U";

        }else if (keycode==KeyEvent.VK_DOWN){
            fx="D";
        }else if (keycode==KeyEvent.VK_LEFT){
            fx="L";
        }else if (keycode==KeyEvent.VK_RIGHT){
            fx="R";
        }//此时只是通过键盘的上下左右控制脑袋在转，并没有是实现小蛇上下左右跑
        //我们要在此时让小蛇往上下左右走，需要去事件监听中继续写
    }

    //事件监听（定时器），需要通过固定的事件来刷新，如1秒10次
    @Override
    public void actionPerformed(ActionEvent e) {
        /*if (isStart){//如果游戏是开始状态，就让小蛇动起来，如何动？就是坐标变化*/
        //12修改下判断条件即可
        if (isStart&&isFail==false){//如果游戏不处于失败状态并且处于开始状态，然后才是失败判定13
          /* //右移
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i]=snakex[i-1];//身体向右移动一节
                snakey[i]=snakey[i-1];
            }
            snakex[0]=snakex[0]+25;//向右移动一节
            if (snakex[0]>850){
                snakex[0]=25;
            }
           */
            //9.判断食物的状态
              //吃食物
            if (snakex[0]==foodx&&snakey[0]==foody){//蛇头和食物的坐标重合意味着吃到了，小蛇开始长大，吃完再产生随机食物
                length++;//长度加1
                //吃完后再重新生成随机食物，不用再去写身体了
                foodx=25+25*random.nextInt(34);//850/25=34  random.nextInt随机的一个数字   这样就得到界面内随机的x坐标
                foody=75+75*random.nextInt(24);
            }

            //7上面注释掉的只是向右移动，现在要通过判断使小蛇上下左右移动
              //移动  身体部分不用变，变头即可
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i] = snakex[i - 1];//身体向右移动一节
                snakey[i] = snakey[i - 1];
            }
                //走向   此时把边界判断也一起加进去
                if (fx.equals("R")) {
                    snakex[0] = snakex[0] + 25;
                    if (snakex[0] > 850) {//边界判断
                        snakex[0] = 25;
                    }
                } else if (fx.equals("L")) {
                    snakex[0] = snakex[0] - 25;
                    if (snakex[0] < 25) {
                        snakex[0] = 850;
                    }
                } else if (fx.equals("U")) {
                    snakey[0] = snakey[0] - 25;
                    if (snakey[0] < 75) {
                        snakey[0] = 650;
                    }
                } else if (fx.equals("D")) {
                    snakey[0] = snakey[0] + 25;
                    if (snakey[0] > 650) {
                        snakey[0] = 75;
                    }
                }


            //还需要加边界判断，不然小蛇就跑出界面回不来了（出了界面再让他回原来的位置即可）

            //13 失败判定：撞到自己就算失败
              //首先要把身体的所有坐标遍历出来
            for (int i = 1; i < length; i++) {
                if (snakex[0]==snakex[i]&&snakey[0]==snakey[i]){//如果脑袋跟身体重合了
                   isFail=true;//撞上了，游戏失败
                }
            }
            repaint();//变完后重画页面
        }
        //重画页面后，开启定时器
        timer.start();//此处的启动只是在监听器启动了

    }
    @Override
    public void keyReleased(KeyEvent e) {
    }
    @Override
    public void keyTyped(KeyEvent e) {//下面这两个没用，放着就行
    }
}       //5.键盘监听器，写一个监听的类 可以写内部类，也可以写外部类。或者单独写也可以。本次使用内部类，使用内部类的话，要去实现一个接口implements keyListener,然后重写方法即可


   //重复：定义一个数据    初始化 画上去  监听它

积分系统

package com.zhang.GUI.Lesson06.snake;

import com.zhang.GUI.Lesson06.Data;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

//游戏的面板
public class GamePanel extends JPanel implements KeyListener , ActionListener {//这样继承后就自带面板了，再在里面写一些方法就好了，当然你也可以自己写一个类创建面板
    //定义蛇的数据结构  脑袋，身体 节数
    int length;//蛇的长度
    int[] snakex=new int[600];//蛇的x坐标   数组
    int[] snakey=new int[500];//蛇的y坐标   数组
    String fx;//小蛇的脑袋不是一直向右，来个初始方向向右

    //7现在小蛇已经能够上下左右动了，需要开始吃食物长大
    int foodx;
    int foody;
    //14.积分系统
    int score;   //然后初始化
      //还要个随机数组
    Random random=new Random();//这样就有了一个默认的随机数组，然后在初始化中初始化食物的数据

      //4游戏当前的状态  开始  停止
    boolean isStart=false;//默认是不开始

    //10.游戏失败的判断
    boolean isFail=false;//游戏状态默认不失败  然后画数据，失败的标志


    //5定时器Timer  以毫秒为单位
    Timer timer=new Timer(75,this);//100毫秒刷新一次，监听当前这个事件

    //new的时候要放到构造器里去初始化
    public GamePanel() {
       //在构造器中调用init方法即可
        init();
        //获得焦点和键盘事件
        this.setFocusable(true);//获取焦点事件
        this.addKeyListener(this);//获取键盘的监听事件  由于是写在当前这个类，故不用new，用this，若写在其他类要new监听器
        timer.start();//游戏一开始定时器就启动
    }

    //1.用构造器或者init方法初始化   初始化小蛇的位置
    public void init(){
        length=3;//小蛇初始化长度为3，3个身体
        snakex[0]=100;snakey[0]=100;//头部的位置
        snakex[1]=75;snakey[1]=100;//第一截身体的位置
        snakex[2]=50;snakey[2]=100;//第二截身体的位置
        fx="R";//初始方向向右

        //8把食物随机的分布在游戏的界面上,然后再把食物画到面板上
        foodx=25+25*random.nextInt(34);//850/25=34  random.nextInt随机的一个数字   这样就得到界面内随机的x坐标
        foody=75+75*random.nextInt(24);
        //15 初始化
        score=0;//然后画
    }

    //绘制面板,游戏中的所有东西都是用这个画笔来画
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        super.paintComponents(g);//清屏，不要的话屏幕会闪烁
        //面板建好了，数据也弄好了，开始绘制静态的面板
        this.setBackground(Color.WHITE);
        Data.header.paintIcon(this,g,25,11);//this代表当前这个panel   //把头部header话上去
        //现在将面板放入游戏就可以了
        g.fillRect(25,75,850,600);//默认的游戏界面
        //16.画积分
        g.setColor(Color.GREEN);
        g.setFont(new Font("微软雅黑", Font.BOLD, 18));//设置字体
        g.drawString("长度"+length, 750, 35);
        g.drawString("分数"+score, 750, 50);  //然后写监听


        //2.把小蛇画上去
        //默认初始小蛇向右，需要通过方向来判断
        /*Data.right.paintIcon(this,g,snakex[0],snakey[0]);//  舌头初始化默认向右this  画到当前面板
        Data.body.paintIcon(this,g,snakex[1],snakey[1]);
        Data.body.paintIcon(this,g,snakex[2],snakey[2]);
        body是动态的，后面需要随length的变大而变大长大，用for循环
         */
        if(fx.equals("R")){
            Data.right.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("L")){
            Data.left.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("U")){
            Data.up.paintIcon(this,g,snakex[0],snakey[0]);
        }else if (fx.equals("D")){
            Data.down.paintIcon(this,g,snakex[0],snakey[0]);
        }

        for (int i = 1; i < length; i++) {//头肯定不能变，所以从第一节身体开始
            Data.body.paintIcon(this,g,snakex[i],snakey[i]);
        }
        //8.画食物,然后再事件监听中判断食物的状态
        Data.food.paintIcon(this,g,foodx,foody);
        //4.游戏的状态 开始  结束
        if(isStart==false) {
            g.setColor(Color.WHITE);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("按下空格开始游戏", 300, 300);//未开始，要在界面画点文字(画在300，300这个位置)，画前指定画笔的颜色
            //现在小蛇有了，字有了，现在需要变得动态起来（即实现监听）
        }
        //11.画游戏失败的标志，然后去键盘监听（空格此刻要让他有双重作用）
        if (isFail){
            g.setColor(Color.RED);//设置颜色
            g.setFont(new Font("微软雅黑", Font.BOLD, 40));//设置字体
            g.drawString("失败，按下空格重新开始", 300, 300);

        }
    }

      //键盘监听事件
    @Override
    public void keyPressed(KeyEvent e) {//按下空格开始，所以要监听键盘，首先要监听空格（那就先获得当前键盘的keycode）
        int keycode=e.getKeyCode();//获得键盘的按键是哪一个
        /*if (keycode==KeyEvent.VK_SPACE){//如果按下的是空格
            isStart=!isStart;//取反
            repaint();//说是值变化了，需要重新paint，不懂
          //11.此刻要让键盘实现双重作用，更改如下：
         */
        if (keycode==KeyEvent.VK_SPACE){//如果按下的是空格
            if (isFail){
                //重新开始
                isFail=false;
                //然后重新初始化   12.还得去事件监听里改点东西
                init();
            }else {
                isStart=!isStart;//取反
            }
            repaint();
//完了后让小蛇动起来，5就要用到定时器了，使用定时器就要实现一个定时器的接口ActionListener,然后再重写定时的方法
        }

        //6现在小蛇只能朝右移动，需要继续优化，使其能上下左右都能移动
        //另外，小蛇方向改变后，记得还要改变脑袋的方向
        if (keycode==KeyEvent.VK_UP){
            fx="U";

        }else if (keycode==KeyEvent.VK_DOWN){
            fx="D";
        }else if (keycode==KeyEvent.VK_LEFT){
            fx="L";
        }else if (keycode==KeyEvent.VK_RIGHT){
            fx="R";
        }//此时只是通过键盘的上下左右控制脑袋在转，并没有是实现小蛇上下左右跑
        //我们要在此时让小蛇往上下左右走，需要去事件监听中继续写
    }

    //事件监听（定时器），需要通过固定的事件来刷新，如1秒10次
    @Override
    public void actionPerformed(ActionEvent e) {
        /*if (isStart){//如果游戏是开始状态，就让小蛇动起来，如何动？就是坐标变化*/
        //12修改下判断条件即可
        if (isStart&&isFail==false){//如果游戏不处于失败状态并且处于开始状态，然后才是失败判定13
          /* //右移
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i]=snakex[i-1];//身体向右移动一节
                snakey[i]=snakey[i-1];
            }
            snakex[0]=snakex[0]+25;//向右移动一节
            if (snakex[0]>850){
                snakex[0]=25;
            }
           */
            //9.判断食物的状态
              //吃食物
            if (snakex[0]==foodx&&snakey[0]==foody){//蛇头和食物的坐标重合意味着吃到了，小蛇开始长大，吃完再产生随机食物
                length++;//长度加1
                //17.每吃一个食物，分数加10
                score=score+10;
                //吃完后再重新生成随机食物，不用再去写身体了
                foodx=25+25*random.nextInt(34);//850/25=34  random.nextInt随机的一个数字   这样就得到界面内随机的x坐标
                foody=75+75*random.nextInt(24);
            }

            //7上面注释掉的只是向右移动，现在要通过判断使小蛇上下左右移动
              //移动  身体部分不用变，变头即可
            for (int i =length-1; i > 0; i--) {//后一节变到前一节的位置
                snakex[i] = snakex[i - 1];//身体向右移动一节
                snakey[i] = snakey[i - 1];
            }
                //走向   此时把边界判断也一起加进去
                if (fx.equals("R")) {
                    snakex[0] = snakex[0] + 25;
                    if (snakex[0] > 850) {//边界判断
                        snakex[0] = 25;
                    }
                } else if (fx.equals("L")) {
                    snakex[0] = snakex[0] - 25;
                    if (snakex[0] < 25) {
                        snakex[0] = 850;
                    }
                } else if (fx.equals("U")) {
                    snakey[0] = snakey[0] - 25;
                    if (snakey[0] < 75) {
                        snakey[0] = 650;
                    }
                } else if (fx.equals("D")) {
                    snakey[0] = snakey[0] + 25;
                    if (snakey[0] > 650) {
                        snakey[0] = 75;
                    }
                }


            //还需要加边界判断，不然小蛇就跑出界面回不来了（出了界面再让他回原来的位置即可）

            //13 失败判定：撞到自己就算失败
              //首先要把身体的所有坐标遍历出来
            for (int i = 1; i < length; i++) {
                if (snakex[0]==snakex[i]&&snakey[0]==snakey[i]){//如果脑袋跟身体重合了
                   isFail=true;//撞上了，游戏失败
                }
            }
            repaint();//变完后重画页面
        }
        //重画页面后，开启定时器
        timer.start();//此处的启动只是在监听器启动了

    }
    @Override
    public void keyReleased(KeyEvent e) {
    }
    @Override
    public void keyTyped(KeyEvent e) {//下面这两个没用，放着就行
    }
}       //5.键盘监听器，写一个监听的类 可以写内部类，也可以写外部类。或者单独写也可以。本次使用内部类，使用内部类的话，要去实现一个接口implements keyListener,然后重写方法即可


   //重复：定义一个数据    初始化 画上去  监听它

标签：java,之旅,snakex,snakey,day.17,import,new,public
来源： https://www.cnblogs.com/Zx-3-6-0-/p/14336676.html