GUI编程
前言
某koukou老师的任务罢了，好在狂神老师居然有GUI的课，只能说是有救星了。
最好笑的是，老师要求掌握的居然是14年的知识，就连狂神在上这门课的时候都在吐槽：你们在网络上几乎看不到这样的教学资源，因为已经很少很少了（被淘汰了）
主要是这个学期的短学期实践十有八九是koukou老师，非得是用java设计图形化可视化，所以学还是得学，不该挂的课就是不能挂！
1、了解GUI
组建：
- 窗口
- 弹窗
- 面板
- 文本框
- 列表框
- 按钮
- 图片
- 监听事件
- 鼠标
- 键盘事件
- （狂神老师提到逆向破解游戏基本使用java来写
2、简介
GUI的核心：
Swing AWT
为什么javaGUI不流行？
- 界面丑
- 需要jre环境
那么为什么要学？
- 自制工具（确实，ctf许多工具都是用javaGUI写成打包的jar
- 极小概率在工作中维护Swing界面（大概我这辈子见不到了吧
- 重点是学习监听事件，可以由此了解MVC架构
3、AWT
3.1 AWT介绍
用于GUI编程，AWT就是抽象窗口工具
（Eclipse和IDEA就是用java Swing写出来的）
- 包含了很多类和接口
- 包含了很多元素：窗口、按钮、文本框
- 在java.awt包中
3.2 组件和容器
1、Frame
我们现来看看第一个frame
package top.woodwhale.study;
import java.awt.*;
// GUI的第一个界面
public class TestFrame {
public static void main(String[] args) {
// Frame
Frame frame = new Frame("First Java Window");
// 需要设置可见性，长度、宽度
frame.setVisible(true);
frame.setSize(400,400);
// 设置背景颜色 Color
frame.setBackground(new Color(22, 87, 220));
// 弹出的初始位置
frame.setLocation(200,200);
// 设置大小固定
frame.setResizable(false);
}
}
效果就是一个蓝色的、不可拉伸、不可关闭的窗口
思考：
- 为什么无法关闭？
- 如何让窗口关闭？只能靠关闭程序吗？
如果我们需要同时开启多个窗口，有没有什么好的方法呢？
- 可以写一个自类，继承自Frame，然后实现我们需要的功能
package top.woodwhale.study;
import java.awt.*;
public class TestFrame2 {
public static void main(String[] args) {
// 展示多个窗口
MyFrame mf1 = new MyFrame(100,100,200,200,Color.black);
MyFrame mf2 = new MyFrame(300,100,200,200,Color.orange);
MyFrame mf3 = new MyFrame(100,300,200,200,Color.green);
MyFrame mf4 = new MyFrame(300,300,200,200,Color.pink);
}
}
class MyFrame extends Frame{
static int id = 0; // 可能存在多个窗口，需要一个计数器
public MyFrame(int x,int y,int w,int h,Color color) {
super("Myframe"+ (++id));
setBackground(color);
setBounds(x,y,w,h);
setVisible(true);
}
}
效果如下：（有点好看
2、Panel
面板Panel可以看成是一个空间，但是不能单独存在，可以存在与一个框架中。类似于前段的div（大概
以下的例子通过适配器模式来监听窗口关闭事件
package top.woodwhale.study;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TestPanel {
public static void main(String[] args) {
// 先创建一个框架
Frame frame = new Frame();
// 设置一个面板
Panel panel = new Panel();
// 设置布局
frame.setLayout(null);
// 框架的坐标
frame.setBounds(300,300,500,500);
// 框架的背景
frame.setBackground(new Color(40,161,35));
// 面板设置坐标，相对于frame
panel.setBounds(50,50,400,400);
panel.setBackground(new Color(190,15,60));
// frame.add()
frame.add(panel);
// 将面板设置为可见
frame.setVisible(true);
// 监听窗口关闭事件
// 适配器模式:
frame.addWindowListener(new WindowAdapter() {
// 窗口点击关闭的时候需要做的事情
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
}
效果如下：（我们点击关闭按钮可以结束进程，也就是退出
3、布局管理
-
流式布局
这个按钮的年代感直接出来了，有种wine打开exe的味道了
package top.woodwhale.study; import java.awt.*; public class TestFlowLayout { public static void main(String[] args) { Frame frame = new Frame("114514"); // 组件-按钮 Button button1 = new Button("button1"); Button button2 = new Button("button2"); Button button3 = new Button("button3"); // 设置为流式布局 默认是居中 frame.setLayout(new FlowLayout()); // frame.setLayout(new FlowLayout(FlowLayout.RIGHT)); frame.setSize(200,200); // 把按钮添加上去 frame.add(button1); frame.add(button2); frame.add(button3); frame.setVisible(true); } } -
东西南北中
狂神老师说这是视频软件的布局，为什么我第一反应是，上下左右都是广告，中间是小视频（bushi
package top.woodwhale.study; import java.awt.*; public class TestBorderLayout { public static void main(String[] args) { Frame frame = new Frame("114514"); 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.add(west,BorderLayout.WEST); frame.add(south,BorderLayout.SOUTH); frame.add(north,BorderLayout.NORTH); frame.add(center,BorderLayout.CENTER); frame.setSize(300,300); frame.setVisible(true); } } -
表格布局
就是类似表格的形式，这里使用了pack()方法来使大小、内容自动填充
package top.woodwhale.study; import java.awt.*; public class TestGridLayout { public static void main(String[] args) { Frame frame = new Frame("114514"); Button bt1 = new Button("bt1"); Button bt2 = new Button("bt2"); Button bt3 = new Button("bt3"); Button bt4 = new Button("bt4"); Button bt5 = new Button("bt5"); Button bt6 = new Button("bt6"); frame.setLayout(new GridLayout(3,2)); frame.add(bt1); frame.add(bt2); frame.add(bt3); frame.add(bt4); frame.add(bt5); frame.add(bt6); frame.pack(); // java方法，用来自动填充 frame.setVisible(true); } }
4、狂神老师的作业time
如何完成下图的格式布局？
直接动手
动手之前先进行构思，一个好的项目，构思占据80%，代码只有20%！！！
我们现构建一个两行一列的frame，然后在中间部分上下各设置一个面板，frame的上半部分和下半部分都使用东西南北中的布局管理，再在两个面板中设置东西南北中格式，其中上面的嵌套一个两行一列的面板，下面的嵌套一个两行两列的面板
最终效果：
代码：
package top.woodwhale.study;
import java.awt.*;
import java.awt.image.ImageObserver;
public class MyLayout {
public static void main(String[] args) {
Frame frame = new Frame("114514");
frame.setSize(400,300);
frame.setLocation(300,300);
frame.setBackground(Color.orange);
frame.setVisible(true);
// 两行一列
frame.setLayout(new GridLayout(2,1));
// 4个面板
Panel panel1 = new Panel(new BorderLayout());
Panel panel2 = new Panel(new GridLayout(2,1));
Panel panel3 = new Panel(new BorderLayout());
Panel panel4 = new Panel(new GridLayout(2,2));
panel1.add(new Button("East-1"),BorderLayout.EAST);
panel1.add(new Button("West-1"),BorderLayout.WEST);
panel2.add(new Button("p2-btn-1"));
panel2.add(new Button("p2-btn-2"));
panel1.add(panel2,BorderLayout.CENTER);
panel3.add(new Button("East-2"),BorderLayout.EAST);
panel3.add(new Button("West-2"),BorderLayout.WEST);
for (int i = 0; i < 4; i++) {
panel4.add(new Button("for-"+i));
}
panel3.add(panel4,BorderLayout.CENTER);
frame.add(panel1);
frame.add(panel3);
}
}
5、总结
- Frame是一个*窗口
- Panel无法单独显示，得放入Frame（容器）中
-
布局管理：
- 流式
- 东西南北中
- 表格
- 设置大小、定位、背景、监听
- 设计模式不要直接写，先去构想！
3.3 监听事件
1、监听测试
监听就是，当发生某事件后，我们监听到了这个动态，应该有某种反馈
先来点效果图：
可以观察到，我们第一次这个巨大按钮，就会在控制台输出一次114514，这是为啥呢？
package top.woodwhale.study2;
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("点我控制台输出114514");
// 因为addActionListener需要一个ActionListener，所以我们字节写一个MyActionListener类
MyActionListener myActionListener = new MyActionListener();
button.addActionListener(myActionListener);
frame.add(button);
frame.setSize(300,300);
frame.setVisible(true);
windowClose(frame);
}
// 关闭窗口事件
private static void windowClose(Frame frame) {
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
}
class MyActionListener implements ActionListener{
@Override
public void actionPerformed(ActionEvent actionEvent) {
System.out.println("114514");
}
}
其实是因为，我们设置了一个按钮的监听器，我们自己写了一个MyActionListener类，是ActionListener的一个接口，我们重写的方法就是只要有这个事件产生，就输出114514。
而我们在button中使用了addActionListener方法，将我们重写的监听器赋予给了这个按钮，所以我们按下这个按钮的时候就能在控制台看到输出的114514。
并且，我们通过在主类中写了一个windowClose的static方法，这样，我们通过方法的封装直接实现了点击关闭按钮关闭窗口的监听事件。
2、单监听器监听多个事件
如果我们想实现多个按钮同时监听一个事件呢？我们可以只写一个监听类，通过更改setActionCommand达到不同的监听效果。
如下图所示，我们点击start按钮可以在控制台输出“开始”
如果我们点击Stop按钮，会输出“哼哼”
这种效果其实就是一个监听器监听了多个事件
package top.woodwhale.study2;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class TestActionEvent2 {
public static void main(String[] args) {
// 两个按钮，实现同一个监听
// 开始按钮和停止按钮
Frame frame = new Frame("Start ~ Stop");
Button button = new Button("Start");
Button button1 = new Button("Stop");
// 可以显示的定义触发会返回的命令，如果不显示定义，则会走默认的值
// 这样我们可以多个按钮，但是只需要一个监听类，只需要更改setActionCommand
button1.setActionCommand("Stop");
MyMonitor myMonitor = new MyMonitor();
button.addActionListener(myMonitor);
button1.addActionListener(myMonitor);
frame.add(button,BorderLayout.NORTH);
frame.add(button1,BorderLayout.SOUTH);
frame.setSize(300,300);
frame.setVisible(true);
}
}
class MyMonitor implements ActionListener {
@Override
public void actionPerformed(ActionEvent actionEvent) {
// actionEvent.getActionCommand()获得按钮的信息'
String command = actionEvent.getActionCommand();
if (command.equals("Stop")) {
System.out.println("想要Stop？哼哼哼哼哼哼哼哼哼哼哼哼哈哈哈哈哈哈哈哈哈～");
} else if (command.equals("Start")) {
System.out.println("开始");
}
}
}
3、输入框TextField监听
我们用TextField类可以创造出输入框的对象，输入框在很多地方都很常见，比如密码输入
这里我们用密码输入来当引子
我们应该实现什么功能？
- 首先考虑输入单行密码，密码只能显示*号
- 其次就是输入按下回车我们可以得到密码
- 最后就是按下回车我们此前输入的密码会清空
如何实现？
- 第2和第3点可以通过设置监听事件完成
- 第1点可以通过textField.setEchoChar(’*’); 替换编码的方法来实现
效果如下：
-
按下回车之前：
-
按下回车之后：
代码实现：
package top.woodwhale.study2;
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 TestText {
public static void main(String[] args) {
// 启动
new MyFrame();
}
}
class MyFrame extends Frame {
public MyFrame() {
// 写单行文本
TextField textField = new TextField();
// 因为MyFrame继承了Frame，可以直接使用add方法
add(textField);
// 监听这个文本框输入的文字，按下enter控制台就会输出我们输入的内容，并且清空文本
MyAL myAL = new MyAL();
textField.addActionListener(myAL);
// 替换编码
textField.setEchoChar('*');
setVisible(true);
setSize(300,100);
// 设置点击关闭监听事件
addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
}
class MyAL implements ActionListener {
@Override
public void actionPerformed(ActionEvent actionEvent) {
// 获取一些资源，返回了一个对象
TextField field = (TextField) actionEvent.getSource();
// 获得输入框的文字
System.out.println(field.getText());
field.setText("");
}
}
3.4 实现简易计算器
1、前言
在这章之前，狂神老师说了一点比较重要的——oop原则：组合大于继承
其实这是装饰器模式的一个体现：
比如我们如果在A类中要实现B的部分功能，一般都是将A继承B的功能。
但是因为Java不能多继承，所以组合就出现了
// 继承
public class A extends B {
}
// 组合
public class A {
public B b;
}
此外，阿里巴巴手册中提出，少用多态、少用继承！（虽然多态和继承是面向对象的三大特性之二）
2、构思
在开始写代码之前，我们需要先构思。
GUI界面如下：
界面其实就是三个输入框，一个“=”按钮，一个“+”标签，然后按照流式模型就可以构造出来了
重点来了：
如何完成监听前两个输入框的值，并且将第三个输入框写入计算后的结果？
3、setter方式
我们在面向对象的学习中，都了解到了构造器，那么我们是不是可以吧三个输入框通过构造器来获取呢？
我们在监听器类中创建三个私有的三个输入框类，通过new对象的时候将传入的三个输入框setter完成。
这样，我们在监听器类中就获取了三个输入框的对象！接下来的操作就不用多所了，代码注释中写有。
代码：
package top.woodwhale.study2;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class TestCalc {
public static void main(String[] args) {
new Calculator();
}
}
// 计算器类
class Calculator extends Frame {
public Calculator() {
// 3个文本框
TextField num1 = new TextField(10);
TextField num2 = new TextField(10);
TextField num3 = new TextField(10);
// 1个按钮
Button button = new Button("=");
button.addActionListener(new MyCalcListener(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 MyCalcListener implements ActionListener {
private TextField num1, num2, num3;
// 获取三个变量
public MyCalcListener(TextField num1, TextField num2, TextField num3) {
this.num1 = num1;
this.num2 = num2;
this.num3 = num3;
}
@Override
public void actionPerformed(ActionEvent actionEvent) {
// 1.获得加数和被加数
int n1 = Integer.parseInt(num1.getText());
int n2 = Integer.parseInt(num2.getText());
// 2.将这个值进行加法运算后，防到第三个框
num3.setText(n1+n2+"");
// 3.清除前两个框
num1.setText("");
num2.setText("");
}
}
运行截图：
按下按钮前：
按下按钮后：
4、组合方式
我们在前言部分就提到了，组合是远远好于继承的，那么如何使用组合的方式来获取三个对话框中的输入输出呢？
我们之前使用的setter方式相当于传数据，而面向对象的组合方式，就是相当于传对象了。
- 如何实现？
- 在计算器类中写一个loadFrame方法，在这个方法中实现外部大Frame的构造
- 再自己写一个监听类，其中的构造器是直接获取计算器这个对象，而这个计算器对象包含了num1，num2，num3的属性，我们通过更改这些属性的状态来完成计算器的实现！
完整代码：
package top.woodwhale.study2;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class TestCalc2 {
public static void main(String[] args) {
new Calculator2().loadFrame();
}
}
// 计算器类
class Calculator2 extends Frame {
// 属性
TextField num1, num2, num3;
// 方法
public void loadFrame() {
num1 = new TextField(10);
num2 = new TextField(10);
num3 = new TextField(10);
Button button = new Button("=");
button.addActionListener(new MyCalcListener2(this)); // 将自己这个Calculator对象给监听器类
Label label = new Label("+");
setLayout(new FlowLayout());
add(num1);
add(label);
add(num2);
add(button);
add(num3);
pack();
setVisible(true);
}
}
// 监听器类
class MyCalcListener2 implements ActionListener {
// 获取计算器这个对象，在一个类中组合另一个类
private Calculator2 calculator = null;
// 获取三个变量
public MyCalcListener2(Calculator2 calculator) {
this.calculator = calculator;
}
@Override
public void actionPerformed(ActionEvent actionEvent) {
int n1 = Integer.parseInt(calculator.num1.getText());
int n2 = Integer.parseInt(calculator.num2.getText());
calculator.num3.setText(n1+n2+"");
calculator.num1.setText("");
calculator.num2.setText("");
}
}
效果图：
按下按钮前：
按下按钮后：
5、内部类方式
面向对象的更高级形式——内部类方法实现
- 更好的包装
- 更简洁的代码
- 更易懂的对象
如何实现？
- 我们只需要将刚刚写的监听器类写入计算器类的内部类就可以了，这样这个监听器就算计算器专门的监听器，并且计算器这个类中有着完整的——属性、方法、内部类。完美的面向对象的体现！
- 内部类的最大好处就是——随意访问外部类的属性和方法
package top.woodwhale.study2;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class TestCalc2 {
public static void main(String[] args) {
new Calculator2().loadFrame();
}
}
// 计算器类
class Calculator2 extends Frame {
// 属性
TextField num1, num2, num3;
// 方法
public void loadFrame() {
num1 = new TextField(10);
num2 = new TextField(10);
num3 = new TextField(10);
Button button = new Button("=");
button.addActionListener(new MyCalcListener2()); // 将自己这个Calculator对象给监听器类
Label label = new Label("+");
setLayout(new FlowLayout());
add(num1);
add(label);
add(num2);
add(button);
add(num3);
pack();
setVisible(true);
}
// 监听器类
class MyCalcListener2 implements ActionListener {
@Override
public void actionPerformed(ActionEvent actionEvent) {
int n1 = Integer.parseInt(num1.getText());
int n2 = Integer.parseInt(num2.getText());
num3.setText(n1+n2+"");
num1.setText("");
num2.setText("");
}
}
}
3.5 Paint画笔
现了解这个paint方法，是Frame中的一个方法，我们自己构造一个MyPaint类，继承Frame，然后重写paint方法，这样在我们的Frame中就可以画出我们想要的东西了！
效果图：
实现代码：
package top.woodwhale.study3;
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.fillOval(100,100,100,100); // 实心的圆
g.setColor(Color.green);
g.fillRect(150,200,300,200);
// 养成习惯，画笔用完，将他还原到最初的颜色
}
}
3.6 鼠标监听
-
目的：想要实现鼠标画画！
-
如何实现？
-
有了方法之后，我们开始构建
代码如下：
package top.woodwhale.study3;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
public class TestMouseListener {
public static void main(String[] args) {
new MyFrame("画画");
}
}
class MyFrame extends Frame {
// 画画需要画笔，需要监听鼠标当前的位置，需要集合来存储这个点
ArrayList points;
public MyFrame(String title) {
super(title);
setVisible(true);
// 存储鼠标点击的坐标
points = new ArrayList<>();
setBounds(200,200,400,300);
// 鼠标监听器，相对于这个窗口
this.addMouseListener(new MyMouseListener());
}
@Override
public void paint(Graphics g) {
// 画画，监听鼠标的事件
for (Object o : points) {
Point point = (Point) o;
g.setColor(Color.blue);
g.fillOval(point.x, point.y, 10, 10);
}
}
// 参加一个点到界面上
public void addPaint(Point point) {
points.add(point);
}
// 适配器模式
private static class MyMouseListener extends MouseAdapter {
// 鼠标有，按下，弹起，按住不放
// 添加
@Override
public void mousePressed(MouseEvent e) {
MyFrame myframe = (MyFrame) e.getSource();
// 我们点击的时候，就会在界面上产生一个点（坐标形式）
// 这个点就是鼠标点击的坐标
myframe.addPaint(new Point(e.getX(),e.getY()));
// 每次点击鼠标都需要重新画一遍
myframe.repaint(); // 刷新
}
}
}
效果如图：
3.7 窗口监听
窗口监听其实在之前点击关闭退出那里已经讲了很多了，这里再补充一点
- 尽量将内部类实现为匿名内部类，这样看起来更美观
- 常用的就是关闭和聚焦
package top.woodwhale.study3;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TestWindow {
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());
// 使用匿名内部类
this.addWindowListener(new WindowAdapter() {
// 关闭窗口
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
// 激活窗口
@Override
public void windowActivated(WindowEvent e) {
WindowFrame source = (WindowFrame) e.getSource();
source.setTitle("被激活啦！");
}
});
}
// class MyWindowListener extends WindowAdapter{
// @Override
// public void windowClosing(WindowEvent e) {
// System.exit(0); // 正常退出
// }
// }
}
3.8 键盘监听
键盘监听，顾名思义，就是监听键盘的状态，用的多的就是判断键盘按下了什么键
- 思考：
- 如何判断按下了什么键？
- 如何对按下了键盘之后进行操作？
- 下面这段代码就是判断键盘是否按下了 up这个键，如果按下了就在控制台输出一个“upupup！～"
package top.woodwhale.study3;
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TestKeyListener {
public static void main(String[] args) {
new KeyFrame();
}
}
class KeyFrame extends Frame {
public KeyFrame() {
setBounds(1,2,300,300);
setVisible(true);
// 匿名内部类实现监听器
this.addKeyListener(new KeyAdapter() {
// 键盘按下
@Override
public void keyPressed(KeyEvent e) {
// 获得键盘下的键是哪一个
int keyCode = e.getKeyCode();
// System.out.println(keyCode);
// 不需要记录KeyCode的值，直接判断
if (keyCode == KeyEvent.VK_UP) {
System.out.println("upupup！～");
}
}
});
// 匿名内部类实现关闭
this.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.out.println("See you next time!");
System.exit(0);
}
});
}
}
4、Swing
AWT是Swing的基础，Swing从AWT进化而来
随便调用个一个JFrame类，进入源码看一下，直接看到extends Frame
4.1 窗口与面板
JFrame其实和Frame类似，只不过涉及到了容器这个概念，每一个窗口都有容器，而容器需要实例化
举例代码：
package top.woodwhale.study4;
import javax.swing.*;
import java.awt.*;
public class JFrameDemo {
// init() 初始化方法
public void init() {
// *窗口
JFrame jFrame = new JFrame("一个JFrame窗口");
jFrame.setVisible(true);
jFrame.setBounds(100,100,200,200);
// 设置文字 JLabel
JLabel jLabel = new JLabel("1145141919810");
// 让文本居中
jLabel.setHorizontalAlignment(SwingConstants.CENTER);
jFrame.add(jLabel);
// jf有容器，容器需要实例化
Container container = jFrame.getContentPane();
container.setBackground(Color.orange);
// JFrame自带的设置关闭操作方法
jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
// 建立一个窗口
new JFrameDemo().init();
}
}
效果如下：
4.2 弹窗
JDialog是一个弹窗的窗口类，我们用一个继承JDialog的类来写一个弹窗事件
package top.woodwhale.study4;
import javax.swing.*;
import javax.swing.text.LabelView;
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 jButton = new JButton("点击弹出114514"); // 创建
jButton.setBounds(30,30,200,50);
// 点击这个按钮，弹出一个弹窗，需要一个监听事件
jButton.addActionListener(new ActionListener() { // 监听器
@Override
public void actionPerformed(ActionEvent actionEvent) {
// 弹窗
new MyDialogDemo();
}
});
container.add(jButton);
}
public static void main(String[] args) {
new DialogDemo();
}
}
// 弹窗的窗口，默认就有点击关闭事件
class MyDialogDemo extends JDialog{
public MyDialogDemo() {
this.setVisible(true);
this.setBounds(100,100,500,500);
Container contentPane = this.getContentPane();
// contentPane.setLayout(null);
contentPane.add(new JLabel("1145141919810"));
}
}
来点效果图：
- 点击前：
- 点击后：
4.3 标签
label就是标签
new JLabel("114514");
图标、图片是icon
显示一个自己画的图标：
package top.woodwhale.study4;
import javax.swing.*;
import java.awt.*;
// 图标是一个接口，需要实现类，JFrame继承
public class IconDemo extends JFrame implements Icon {
private int width;
private int height;
public IconDemo() throws HeadlessException {
}
public IconDemo(int width, int height) throws HeadlessException {
this.width = width;
this.height = height;
}
public static void main(String[] args) {
new IconDemo().init();
}
public void init() {
IconDemo iconDemo = new IconDemo(15,15);
JLabel jLabel = new JLabel("iconTest", iconDemo, SwingConstants.CENTER);
Container container = getContentPane();
container.add(jLabel);
this.setVisible(true);
this.setSize(300,300);
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
@Override
public void paintIcon(Component component, Graphics graphics, int i, int i1) {
graphics.fillOval(i,i1,this.width,this.height);
}
@Override
public int getIconWidth() {
return this.width;
}
@Override
public int getIconHeight() {
return this.height;
}
}
效果如下：
那么如何来设置自定义图片icon呢？
效果如下的这种：
也很简单：
package top.woodwhale.study4;
import javax.swing.*;
import java.awt.*;
import java.net.URL;
public class ImageIconDemo extends JFrame {
public static void main(String[] args) {
new ImageIconDemo();
}
public ImageIconDemo() throws HeadlessException {
// 获取图片的地质
JLabel jLabel = new JLabel("ImageIcon");
URL url = ImageIconDemo.class.getResource("woodwhale.jpg");
assert url != null;
ImageIcon imageIcon = new ImageIcon(url);
jLabel.setIcon(imageIcon);
jLabel.setHorizontalAlignment(SwingConstants.CENTER);
Container container = getContentPane();
container.add(jLabel);
setVisible(true);
setSize(300,300);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}
4.4 面板
JPanel
和之前学的Panel一样，就是多了容器操作
package top.woodwhale.study5;
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 = new JPanel(new GridLayout(1,3));
jPanel.add(new JButton("114"));
jPanel.add(new JButton("514"));
jPanel.add(new JButton("1919"));
container.add(jPanel);
this.setVisible(true);
this.setSize(300,300);
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new JPanelDemo();
}
}
效果如下：
那么如何来点滚动条呢？
使用JScroll即可
代码：
package top.woodwhale.study5;
import javax.swing.*;
import java.awt.*;
public class JScrollDemo extends JFrame {
public JScrollDemo() {
// 容器
Container container = this.getContentPane();
// 文本
JTextArea textArea = new JTextArea(20,50);
textArea.setText("114514");
// 滚动条
JScrollPane scrollPane = new JScrollPane(textArea);
container.add(scrollPane);
this.setVisible(true);
this.setBounds(300,300,300,300);
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new JScrollDemo();
}
}
4.5 按钮
其实Swing中的按钮和html中的选择框很像，也是需要设置选择域进行分组，许多单选框如果在一个组就只能选一个，多选就没这么限制了
Swing中的按钮分为下面三类：
-
图片按钮 （JButton中的setIcon实现）
效果图：
代码：
package top.woodwhale.study5; import javax.swing.*; import java.awt.*; import java.net.URL; public class JButtonDemo1 extends JFrame { public JButtonDemo1 (){ Container container = this.getContentPane(); URL rs = JButtonDemo1.class.getResource("woodwhale.jpg"); assert rs != null; Icon icon = new ImageIcon(rs); // 把这个图标放在按钮上 JButton jButton = new JButton(); jButton.setIcon(icon); jButton.setToolTipText("114514"); container.add(jButton); this.setVisible(true); this.setSize(300,300); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new JButtonDemo1(); } } -
单选按钮 （JRadioButton和ButtonGroup）
效果如下：
代码：
package top.woodwhale.study5; import javax.swing.*; import java.awt.*; public class JButtonDemo2 extends JFrame { public JButtonDemo2() { Container container = this.getContentPane(); // 单选框 JRadioButton radioButton = new JRadioButton("JRadioButtonTest"); JRadioButton radioButton1 = new JRadioButton("JRadioButtonTest114514"); JRadioButton radioButton2 = new JRadioButton("JRadioButtonTest1919810"); // 由于单选框只能选择一个，所以需要分组 ButtonGroup buttonGroup = new ButtonGroup(); buttonGroup.add(radioButton); buttonGroup.add(radioButton1); buttonGroup.add(radioButton2); container.add(radioButton1,BorderLayout.CENTER); container.add(radioButton,BorderLayout.NORTH); container.add(radioButton2,BorderLayout.SOUTH); this.setVisible(true); this.setSize(300,300); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new JButtonDemo2(); } } -
复选按钮 （ JCheckBox）
效果图：
代码：
package top.woodwhale.study5; import javax.swing.*; import java.awt.*; public class JButtonDemo3 extends JFrame { public JButtonDemo3() { Container container = this.getContentPane(); // 多选框 JCheckBox ch1 = new JCheckBox("114514"); JCheckBox ch2 = new JCheckBox("1919810"); container.add(ch1,BorderLayout.NORTH); container.add(ch2,BorderLayout.SOUTH); this.setVisible(true); this.setSize(300,300); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new JButtonDemo3(); } }
4.6 列表
-
下拉框
效果如下：
代码：
package top.woodwhale.study6; import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; public class ComboDemo1 extends JFrame { public ComboDemo1() { Container contentPane = this.getContentPane(); JComboBox comboBox = new JComboBox(); comboBox.addItem(null); comboBox.addItem("114514"); comboBox.addItem("1919810"); // 监听选择 comboBox.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent actionEvent) { System.out.println(comboBox.getSelectedIndex()); System.out.println(comboBox.getSelectedItem()); } }); contentPane.add(comboBox); this.setVisible(true); this.setSize(300,100); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new ComboDemo1(); } } -
列表框
效果如下：
代码：
package top.woodwhale.study6; import javax.swing.*; import java.awt.*; import java.util.LinkedList; import java.util.Vector; public class ComboDemo2 extends JFrame { public ComboDemo2() { Container container = this.getContentPane(); // 生成Vector内容 Vector contents = new Vector(); JList jList = new JList(contents); // 动态添加 contents.add("114514"); contents.add("1919810"); container.add(jList); this.setVisible(true); this.setSize(300,300); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new ComboDemo2(); } } -
应用场景：
- 选择地区、班级、学院之类的多选择器
- 展示一些列表信息，一般使用动态扩容
4.7 文本框
-
文本框
效果如下：
代码：
package top.woodwhale.study6; import javax.swing.*; import java.awt.*; public class TextDemo1 extends JFrame { public TextDemo1() { Container container = this.getContentPane(); JTextField t1 = new JTextField("hello"); JTextField t2 = new JTextField("word",20); container.add(t1,BorderLayout.NORTH); container.add(t2,BorderLayout.SOUTH); this.setVisible(true); this.setSize(300,300); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new TextDemo1(); } } -
密码框
默认效果图：
但是我们可以通过setEchoChar的方法来更改显示
代码：
package top.woodwhale.study6; import javax.swing.*; import java.awt.*; public class TestDemo2 extends JFrame { public TestDemo2() { Container container = this.getContentPane(); JPasswordField passwordField = new JPasswordField(); passwordField.setEchoChar('*'); container.add(passwordField); this.setVisible(true); this.setBounds(300,300,300,300); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new TestDemo2(); } } -
文本域
JTextArea可以配合面板使用
效果图（上面在面板中使用的例子）：
代码：
package top.woodwhale.study5; import javax.swing.*; import java.awt.*; public class JScrollDemo extends JFrame { public JScrollDemo() { // 容器 Container container = this.getContentPane(); // 文本（20行，50列） JTextArea textArea = new JTextArea(20,50); textArea.setText("114514"); // 滚动条 JScrollPane scrollPane = new JScrollPane(textArea); container.add(scrollPane); this.setVisible(true); this.setBounds(300,300,300,300); this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String[] args) { new JScrollDemo(); } }