标签：java GUI 基础 学习 add frame import new public

Java_GUI编程基础

GUI组件

• 窗口
• 弹窗
• 面板
• 文本框
• 列表框
• 按钮
• 图片
• 监听事件
• 鼠标
• 键盘事件

1、简介

GUI核心技术：Swing、AWT

为什么不用：

1. 界面不美观
2. 需要jre环境

为什么要学GUI：

1. 可以写出自己想要的工具
2. 工作的时候，也可能需要维护到swing，概率极小
3. 了解MVC架构，了解监听器

2、AWT

2.1、AWT介绍

1. 包含了很多类和接口！GUI：图形用户界面编程
2. 元素：窗口、按钮、文本框
3. java.awt

2.2 组件和容器

1、Frame

单窗口

package GUI.AWT.frame;

/**
 * 单窗口
 */
import java.awt.*;
public class TestFrame{
    public static void main(String[] args){
        //Frame
        Frame frame = new Frame("我的第一个java图形界面窗口");
        //设置可见性
        frame.setVisible(true);
        //设置窗口大小
//        frame.setSize(400,400);
        //设置背景颜色 color
        frame.setBackground(Color.pink);
        //弹出的初始位置
//        frame.setLocation(200,200);
        //设置大小固定
        frame.setResizable(false);
        //一个代替两个frame.setLocation(200,200);frame.setSize(400,400);
        frame.setBounds(200,200,400,400);

    }
}

运行效果

扩展

这里的设置背景颜色时没有调色板的在idea里

修改一下new 个color对象

这样就有啦

修改颜色之后的效果

多窗口

package GUI.AWT.frame;

/**
 * 多窗口
 * 当我想建立多个不同的窗口的时候，就可以这么干啦，弄一个方法继承Frame
 * 然后在方法里设置区别的值
 */
import java.awt.*;
public class TestFrame2 {
    public static void main(String[] args) {
        //展示多个窗口
        MyFrame MyFrame1 = new MyFrame(100, 100, 400, 400, Color.green,true);
        MyFrame MyFrame2 = new MyFrame(500, 100, 400, 400, Color.yellow,true);
        //固定不能拉伸
        MyFrame MyFrame3 = new MyFrame(100, 500, 400, 400, Color.pink,false);
        MyFrame MyFrame4 = new MyFrame(500, 500, 400, 400, Color.MAGENTA,false);
    }
}
class MyFrame extends Frame {
    static int id = 0;//可能存在多个窗口，我们需要给出计数器。
    public MyFrame(int x, int y, int w, int h, Color color ,boolean Resizable) {
        //设置窗口名字，类似这个 Frame frame = new Frame("我的第一个java图形界面窗口");
        super("MyFrame+" + (++id));
        setVisible(true);
        setBackground(color);
        setBounds(x, y, w, h);
        //设置大小固定,false是固定，true是可以拉伸
        setResizable(Resizable);
    }
}

---

---

效果：

2、面板Panel

package GUI.AWT.Panel;


import java.awt.*;
import java.awt.event.WindowAdapter;//窗口监听器
import java.awt.event.WindowEvent;
/**
 * 面板！
 * 面板加在frame上，不能单独存在
 */
public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("第一个Panel");
        //布局的概念
        Panel panel = new Panel();
        //设置布局
        frame.setLayout(null);//这里的null就是不采用Java提供的布局，自己通过坐标布局
        //设置frame坐标
        frame.setBounds(300, 300, 500, 500);
        frame.setBackground(new Color(0xF99E9E));
        //设置Panel的坐标，相对定位，相对于frame的
        panel.setBounds(50, 50, 400, 400);
        panel.setBackground(new Color(0x86F78D));//自己写个Color对象
        //frame添加面板
        frame.add(panel);
        frame.setVisible(true);
        //监听实践，监听窗口关闭System.exit(0)
        //适配器模式
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                super.windowClosing(e);
                //结束程序
                System.exit(0);
            }
        });
    }
}

效果

2.3、布局管理

布局一般都有frame布局

1.流式布局 Flowlayout

package GUI.AWT.Layout;

/**
 * 流式布局
 */

import java.awt.*;
public class TestFlowLayout{
    public static void main(String[] args){
        Frame frame = new Frame();
        frame.setBackground(new Color(0x6BEBE9));
        Panel panel = new Panel();
//        panel.setLayout(new FlowLayout(FlowLayout.LEFT));
        panel.setBackground(new Color(0xDC9090));
        //组件-按钮
        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.setLayout(new FlowLayout(FlowLayout.RIGHT));//靠右
        frame.setBounds(200,200,400,400);

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

        //添加面板
        frame.add(panel);
    }
}

效果

2.东西南北中布局

package GUI.AWT.Layout;

/**
 * 东西南北中
 */

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
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.add(west, BorderLayout.WEST);
        frame.add(south, BorderLayout.SOUTH);
        frame.add(north, BorderLayout.NORTH);
        frame.add(center, BorderLayout.CENTER);

        frame.setSize(200, 200);
        frame.setVisible(true);
        //窗口监听关闭事件
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                //当窗口关闭时啥也不做，直接退出结束程序
                System.exit(0);
            }
        });
    }
}

效果

扩展

设置各个布局大小的方法

//设置各区域的大小和布局
        east.setPreferredSize(new Dimension(200,300));
        west.setPreferredSize(new Dimension(200,300));
        south.setPreferredSize(new Dimension(600,250));
        north.setPreferredSize(new Dimension(600,250));
        center.setPreferredSize(new Dimension(200,300));

效果

3.表格布局 GridLayout

package GUI.AWT.Layout;

/**
 * 表格布局
 */
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("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) {
                super.windowClosing(e);
                System.exit(0);
            }
        });
    }
}

效果:

布局综合练习（做出下图的效果）

思路：

可以用4个面板做

一个Frame上放两个大面板A和B，然后用的是表格布局（2行1列）

接着对上边的A面板进行东西南北中的布局，

只设置中和东西，不设置南北（一共3个按钮）

接着对下面的B面板也是这个操作。

接着在A面板的中间弄个表格布局2行一列（2个按钮）

同理，在B面板的中间弄个表格布局2行2列（4个按钮）

实现

package GUI.AWT.Layout;

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

/**
 *
 */
public class ComprehensiveLayoutExercise {
    public static void main(String[] args) {
        //创建frame和4个面板
        Frame frame = new Frame();
        frame.setVisible(true);
        frame.pack();//自适应大小，自动布局
        Panel panelA = new Panel();
        Panel panelB = new Panel();
        Panel panel1 = new Panel();
        Panel panel2 = new Panel();
        //创建几个按钮
        Button button1 = new Button("按钮1");
        Button button2 = new Button("按钮2");
        Button button3 = new Button("按钮3");
        Button button4 = new Button("按钮4");
        Button button5 = new Button("按钮5");
        Button button6 = new Button("按钮6");
        Button button7 = new Button("按钮7");
        Button button8 = new Button("按钮8");
        Button button9 = new Button("按钮9");
        Button button10 = new Button("按钮10");

        //    一个Frame上放两个大面板A和B，然后用的是表格布局（2行1列）
        frame.setLayout(new GridLayout(2,1));
        //    接着对上边的A面板进行东西南北中的布局，
        panelA.setLayout(new BorderLayout());
        panelA.add(button1,BorderLayout.WEST);
        panelA.add(button2,BorderLayout.EAST);
        //    只设置中和东西，不设置南北（一共2个按钮）
        //    接着对下面的B面板也是这个操作。
        panelB.setLayout(new BorderLayout());
        panelB.add(button3,BorderLayout.WEST);
        panelB.add(button4,BorderLayout.EAST);
        //    接着在A面板的中间弄个面板1表格布局2行一列（2个按钮）
        panelA.add(panel1, BorderLayout.CENTER);
        panel1.setLayout(new GridLayout(2,1));
        panel1.add(button5);
        panel1.add(button6);
        //    同理，在B面板的中间弄个面板2表格布局2行2列（4个按钮）
        panelB.add(panel2, BorderLayout.CENTER);
        panel2.setLayout(new GridLayout(2,2));
        panel2.add(button7);
        panel2.add(button8);
        panel2.add(button9);
        panel2.add(button10);

        //把面板A，B加到Frame上
        frame.add(panelA);
        frame.add(panelB);

        //设置窗口关闭
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

    }

}

效果

新的问题：按钮的中文居然不能正常显示（awt GUI图形界面，按钮中文乱码）

解决方法

勾选这个

然后再 VMoption框输入

-Dfile.encoding=gbk

Apply ,ok

• 成功解决！

2.4、事件监听

事件监听：当某个事情发生的时候，干什么

package GUI.AWT.EventListener;

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("事件监听测试");
        frame.setVisible(true);
        frame.pack();

        Button button1 = new Button("btn");
        frame.add(button1);
        //给button绑定事件
        MyActionListener01 myActionListener01 = new MyActionListener01();
        button1.addActionListener(myActionListener01);
        //给button+事件监听器的时候的时候发现需要一个ActionListener接口，所以需要自己创造个类实现它。

        //窗口关闭
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }

}
class MyActionListener01 implements ActionListener{

    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("按钮被按下！");
    }
}

效果

多个按钮，实现同一个窗口

package GUI.AWT.EventListener;

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

/**
 * 多个按钮实现同一个窗口
 * 思路可以是自己写个类实现事件监听接口，然后不同的按钮再不同的设定
 *
 * 知识：e.getActionCommand() 获得按钮的信息
 *
 */

public class TestActionTwo {
    public static void main(String[] args) {
        Frame frame = new Frame("多个按钮实现同一个窗口");
        Button button1 = new Button("btn1");
        Button button2 = new Button("btn2");
        //事件监听
        MyActionListener02 myActionListener02 = new MyActionListener02();
        button1.addActionListener(myActionListener02);
        button2.addActionListener(myActionListener02);
        //给按钮设置信息
        button1.setActionCommand("按钮1的setActionCommand");
//        frame.setLayout(new GridLayout(2,1));
        frame.setLayout(new FlowLayout());
//        frame.setLayout(null);//不用
        //按钮加到frame
        frame.add(button1);
        frame.add(button2);
        //基本设置
        frame.setVisible(true);
        frame.pack();
        //关闭窗口
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}
class MyActionListener02 implements ActionListener{

    @Override
    public void actionPerformed(ActionEvent e) {
        if(e.getActionCommand().equals("按钮1的setActionCommand")){
            System.out.println("按钮1被按下！");
        }else if(e.getActionCommand().equals("btn2")) {
            System.out.println("按钮2被按下");
        }

    }
}

效果：

2.5、输入框TextField监听

package GUI.AWT.EventListener;

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

/**
 * 输入框TextField监听
 *
 *  e.getSource();//获得一些资源,点进去看，该函数返回一个object对象
 *
 * 设置替换编码
 *         textField.setEchoChar('*');//设置为'*'
 *  TextField的getText()方法可以获得输入框中的文本
 */

public class TestField1 {
    public static void main(String[] args) {
        new myFrame();
    }
}
//继承框架，就可以直接用里边的add方法
class myFrame extends Frame{
    //构造对象
    public myFrame(){
        //先构造单行文本对象。
        TextField textField = new TextField();
        //做事件监听（也就是输入框监听）
        myActionListener03 myActionListener = new myActionListener03();
        //默认按下回车就会触发事件
        textField.addActionListener(myActionListener);
        //基础设置
        pack();
        setVisible(true);
        add(textField);//将单行文本框放到Frame里
    }
}
class myActionListener03 implements ActionListener{
    //事件监听
    @Override
    public void actionPerformed(ActionEvent e) {
        //获得单行文本资源
        TextField textField = (TextField) e.getSource();//将对象object转成TextField对象
        //获取输入框中的文本并且输出
        System.out.println(textField.getText());
        //输出之后将文本框的文本设置为空
        textField.setText("");

    }
}

效果

2.6、简易计算器，回顾组合内部类

1.面向过程版本

package GUI.AWT.SimpleCalculator;

import java.awt.*;
import java.awt.event.*;

/**
 * 面向过程简易计算器
 * 先创建一个计算器
 * 然后监听那个等号按钮（用到3个textField)
 * 
 */
public class TestCalc {
    public static void main(String[] args) {
        new Calculator();
    }
}
//构建计算器
class Calculator extends Frame{
    //构造一个计算器的
    public Calculator(){
        //三个文本框，1个等号按钮，一个+号标签 ，设置流式布局。
        TextField textField1 = new TextField();
        TextField textField2 = new TextField();
        TextField textField3 = new TextField();
        Button button = new Button("=");
        Label label = new Label("+");

        //布局
        add(textField1);
        add(label);
        add(textField2);
        add(button);
        add(textField3);
        setLayout(new FlowLayout());
        pack();
        setVisible(true);
        //事件监听
        MyActionListener04 myActionListener04 = new MyActionListener04(textField1,textField2,textField3);

        button.addActionListener(myActionListener04);
        //关闭窗口
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        } );
    }
}
//按钮事件监听（得文本框数据弄一下）
class MyActionListener04 implements ActionListener{
    /*
    这里就是说得点击按钮的时候做加法运算
    先三个获取前两个个文本框的输入的内容
    获取了之后对于等于的位置进行一次setText的加法运算
    然后在清空前两个框框的内容
     */
    //那么先拿到3个内容
    private TextField textField1 ,textField2,textField3;
    //为了拿到它们构建个方法,把三个东西传进来，在new的时候就可以拿到了
    public MyActionListener04(TextField num1,TextField num2,TextField num3){
        //这里把构造方法接收到的参数赋值给当前类的对象，就可以拿到值啦
        this.textField1=num1;
        this.textField2=num2;
        this.textField3=num3;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //获取对应框的数值（把拿到的字符串转换成int对象）
        int n1 = Integer.parseInt(textField1.getText());
        int n2 = Integer.parseInt(textField2.getText());
        textField3.setText(""+(n1+n2));
        textField1.setText("");
        textField2.setText("");

    }
}

效果

升级版：面向对象，组合类

package GUI.AWT.SimpleCalculator;

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 TestCal1 {
    public static void main(String[] args) {
        Calculator02 calculator02 = new Calculator02();
        calculator02.loadFrame();
    }

}

//计算器类
class Calculator02 extends Frame {
    //构建三个在本类里的文本框
    TextField textField1, textField2, textField3;
    public Calculator02(){
        super("面向对象计算器，组合类");
    }

    //加载框架的方法（构建计算器）
    public void loadFrame() {
        //对三个本类的文本框初始化
        textField1 = new TextField(10);
        textField2 = new TextField(10);
        textField3 = new TextField(10);
        Label label = new Label("+");
        Button button = new Button("=");
        //给等号加事件监听
        MyActionListener05 myActionListener05 = new MyActionListener05(this);//this指的是本对象，也就是Calculator02
        button.addActionListener(myActionListener05);

        //布局
        add(textField1);
        add(label);
        add(textField2);
        add(button);
        add(textField3);
        setLayout(new FlowLayout());
        setVisible(true);
        pack();
        //关闭窗口
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}
//监听器类！
class MyActionListener05 implements ActionListener{
    //组合计算器类，将计算器类注入本类
    private Calculator02 calculator02;
    //构造方法，初始化得到的对象
    public MyActionListener05(Calculator02 calculator02){
        //将得到的对象赋值到本对象
        this.calculator02=calculator02;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        //获取前两个数
        int n1 = Integer.parseInt(calculator02.textField1.getText());
        int n2 = Integer.parseInt(calculator02.textField2.getText());
        //等号+清空
        calculator02.textField3.setText(""+(n1+n2));
        calculator02.textField1.setText("");
        calculator02.textField2.setText("");

    }
}

效果：

更高级的版本：内部类！！！很重要

• 内部类：更好的包装
• 内部类最大的好处，就是可以畅通无阻的访问外部的属性和方法

package GUI.AWT.SimpleCalculator;

/**
 * 更高级的版本：内部类！！！很重要
 *
 * 内部类：更好的包装
 * 内部类最大的好处，就是可以畅通无阻的访问外部的属性和方法
 */
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 TestCalc2 {
    public static void main(String[] args) {
        Calculator03 calculator03 = new Calculator03();
        calculator03.loadFrame();
    }

}

//计算器类
class Calculator03 extends Frame {
    //构建三个在本类里的文本框
    TextField textField1, textField2, textField3;
    public Calculator03(){
        super("面向对象计算器，内部类！");
    }

    //加载框架的方法（构建计算器）
    public void loadFrame() {
        //对三个本类的文本框初始化
        textField1 = new TextField(10);
        textField2 = new TextField(10);
        textField3 = new TextField(10);
        Label label = new Label("+");
        Button button = new Button("=");
        //给等号加事件监听
        button.addActionListener(new Calculator03.MyActionListener06());//因为是内部类，所以直接new一个class对象出来就好

        //布局
        add(textField1);
        add(label);
        add(textField2);
        add(button);
        add(textField3);
        setLayout(new FlowLayout());
        setVisible(true);
        pack();
        //关闭窗口
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }

    //监听器类！(放到类的内部里！！）
    private class MyActionListener06 implements ActionListener{

        @Override
        public void actionPerformed(ActionEvent e) {
            //获取前两个数
            int n1 = Integer.parseInt(textField1.getText());
            int n2 = Integer.parseInt(textField2.getText());
            //等号+清空
            textField3.setText(""+(n1+n2));
            textField1.setText("");
            textField2.setText("");

        }
    }
}

效果：

2.7、画笔

package GUI.AWT;

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

/**
 * 画笔
 * Alt+ins 重写里面的Paint函数
 * 重写发现参数是Graphics 按主CTRL键点击进去看，就能了解到对象g能调用那些方法了
 * 重写前写个方法，让弹窗可以出现
 */

public class TestPaint {
    public static void main(String[] args) {
        Mypaint mypaint = new Mypaint();
        mypaint.loadFrame();
    }
}
//创造画笔对象
class Mypaint extends Frame{
    public Mypaint(){
        //标题
        super("测试画笔对象");
    }
    //加载框架
    public void loadFrame(){
        setBounds(100,100,400,400);
        setVisible(true);
        //关闭窗口
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }

    @Override
    public void paint(Graphics g) {
        //super.paint(g);
        //设置画笔颜色
        g.setColor(new Color(0x49F2EF));
        //空心圆
        g.drawOval(50,50,50,50);
        
        //实心圆
        g.setColor(new Color(0x3AFE3A));
        g.fillOval(100,100,50,50);
        //用完恢复默认颜色
        g.setColor(Color.black);
    }
}

效果：

2.8、鼠标监听

package GUI.AWT;

/*
对于鼠标监听器
        this.addMouseListener(new MyMouseListener());
        ctrl点击进去，参数是MouseListener对象
        再点击进去MouseListener,是一个接口继承事件监听类（单击之类的事件监听）
        public interface MouseListener extends EventListener
        我们写一个MyMouseListener的类来实现MouseListener，发现继承要实现好多个方法
        这时我们就可以选择采用适配器模式
        private class MyMouseListener extends MouseAdapter{}
        这样只需重写我们要的方法！！！

想法：
        弄一个鼠标监听器，用来画点，画很多点，
        所以需要一个集合来存放所有点的集合
        并且需要重写画画的方法。
        在每一次画点的时候都要重画一遍（也就是刷新一下画板）

 */

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

//鼠标监听事件
public class TestMouseListener {
    public static void main(String[] args) {
        new MyFrame();
    }
}
//自己的类
class MyFrame extends Frame {
    //弄个points集合存放所有点的坐标
    ArrayList points;
    public MyFrame(){
        super("画点，鼠标监听");
        //存放鼠标的点？
        points = new ArrayList();
        //对窗口进行鼠标监听，this就是代表本Frame
        this.addMouseListener(new MyMouseListener01());
        //布局
        setBounds(100,100,400,400);
        setVisible(true);
        //关闭
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

    }

    //画画（重写paint方法）
    @Override
    public void paint(Graphics g) {
        //画点，实心圆
        g.setColor(Color.blue);
        //因为需要每个鼠标的点的坐标，所以这里需要一个遍历器
        Iterator iterator = points.iterator();
        while (iterator.hasNext()){
            Point point = (Point) iterator.next();
            g.fillOval(point.x,point.y,10,10);
        }

    }
    //鼠标监听内部类
    private class MyMouseListener01 extends MouseAdapter{
        //重写里边的鼠标单击的方法，重写快捷键ctrl+o
        @Override
        public void mouseClicked(MouseEvent e) {
            //当鼠标单击的时候需要获取鼠标的坐标，并且传到points集合里
            //先获取当前窗口MyFrame。用到e.getSource.（返回当前对象）谁调用就返回谁
            MyFrame myFrame = (MyFrame) e.getSource();
            Point position = myFrame.getMousePosition();//获取本窗口鼠标位置的方法
            points.add(position);//把每个位置存放到集合中！

            //当我每次点击鼠标的时候，鼠标都重画一遍
            myFrame.repaint();
        }
    }
}

效果：

这个和上边的差不多，我重新又敲了一次而已

package GUI.AWT;

/*
对于鼠标监听器
        this.addMouseListener(new MyMouseListener());
        ctrl点击进去，参数是MouseListener对象
        再点击进去MouseListener,是一个接口继承事件监听类（单击之类的事件监听）
        public interface MouseListener extends EventListener
        我们写一个MyMouseListener的类来实现MouseListener，发现继承要实现好多个方法
        这时我们就可以选择采用适配器模式
        private class MyMouseListener extends MouseAdapter{}
        这样只需重写我们要的方法！！！

想法：
        弄一个鼠标监听器，用来画点，画很多点，
        所以需要一个集合来存放所有点的集合
        并且需要重写画画的方法。
        在每一次画点的时候都要重画一遍（也就是刷新一下画板）

 */

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

public class TestMouseListener {
    public static void main(String[] args) {
        new MyPaintFrame();
    }
}
//构造画板+鼠标监听+存点
class MyPaintFrame extends Frame{
    ArrayList points;//设置个集合来存所有的点的坐标

    public MyPaintFrame(){
        points = new ArrayList();
        //鼠标监听
        this.addMouseListener(new myMouseListener());
        //布局
        setBounds(100,100,400,400);
        setVisible(true);
        //关窗
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
    //要画画，得重写画画的方法
    @Override
    public void paint(Graphics g) {
        //遍历器，遍历points集合，得到每个单独的point的坐标
        Iterator iterator = points.iterator();
        while (iterator.hasNext()){
            Point point2 = (Point) iterator.next();//将遍历器的每个遍历到的对象赋值给Point
            g.setColor(Color.PINK);
            g.fillOval(point2.x,point2.y,10,10);

        }
        //画笔用完恢复原来的颜色
        g.setColor(Color.black);
    }

    //一个内部类，用来实现鼠标监听
    private class myMouseListener extends MouseAdapter{
        //重写鼠标单击事件
        @Override
        public void mouseClicked(MouseEvent e) {
            //当鼠标单击的时候得到他的坐标。
            //所以需要得到当前的窗口
            MyPaintFrame myPaintFrame = (MyPaintFrame) e.getSource();
            Point point1 = myPaintFrame.getMousePosition();//得到了当前坐标
            points.add(point1);//坐标存起来
            //每点击一下就重画一次
            myPaintFrame.repaint();
        }
    }
}

效果：

2.9、窗口监听

package GUI.AWT;

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

/**
 * 窗口监听
 *     加个窗口监听，当我点击关闭窗口按钮的时候，先隐藏窗口再退出
 */

public class TestWindow {
    public static void main(String[] args) {
        new WindowFrame();
    }
}
//先创造个frame
class WindowFrame extends Frame{
    public WindowFrame(){
        super("窗口监听01");
        //对当前窗口加个监听事件
        this.addWindowListener(new MyWindowListener());
        //布局
        setVisible(true);
        setBounds(100,100,400,400);
    }
    //内部类，窗口监听（不建议这样写），建议写成匿名内部类
    private class MyWindowListener extends WindowAdapter{
        @Override
        public void windowClosing(WindowEvent e) {
            //先隐藏窗口再关闭
            setVisible(false);
            System.out.println("这是我在隐藏窗口的情况下打印的");
            System.exit(0);
        }
    }


}

效果：

当我点击关闭的时候

控制台

建议写法：

package GUI.AWT;

/**
 * 这是匿名内部类写法（窗口监听）
 */

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TestWindow2 {
    public static void main(String[] args) {
        new WindowFrameTwo();
    }
}
//先创造个frame
class WindowFrameTwo extends Frame{
    public WindowFrameTwo(){
        super("窗口监听01");
        //对当前窗口加个监听事件
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                setVisible(false);
                System.out.println("匿名内部类");
                System.out.println("已经隐藏窗口啦，下一步，退出");
                System.exit(0);
            }
        });
        //布局
        setVisible(true);
        setBounds(100,100,400,400);
    }
    

}

效果：

2.10、键盘监听

package GUI.AWT;

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 MyKeyFrame();
    }
}
class MyKeyFrame extends Frame{
    public MyKeyFrame(){

        //给窗口设置键盘监听
        this.addKeyListener(new KeyAdapter() {
            //监听键盘按压的是哪个键
            @Override
            public void keyPressed(KeyEvent e) {
                int n = e.getKeyCode();//获取被按下的键的数值
                System.out.println("你按下的键的数值==》"+e.getKeyCode());
                //键盘事件可以获取各种键
                if(n==KeyEvent.VK_DOWN){
                    System.out.println("你按下了键盘下键");
                }
            }
        });
        //布局
        setBounds(100,100,400,400);
        setVisible(true);
        //关窗
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
}

效果：

3、Swing

3.1、窗口、面板

教学版本

package GUI.Swing;

/**
 * 窗口、面板
 */
import javax.swing.*;
import java.awt.*;
public class JFrameDemo {
    //init():初始化
    //越来越接近实际开发
    public void init() {
        //JFrame是一个顶级窗口，窗口也是容器
        JFrame jFrame = new JFrame("这是一个JFrame窗口");
        //jFrame.setBackground(Color.pink);
        /**
         * 上面的frame.setBackground(Color.pink);无效
         * JFrame这样的框架,一旦创建,在其中就已经包含一个内容面板,一般我们在往JFrame中添加组件时,
         * 都加在了内容面板中,这个面板可以通过JFrame的成员方法getContentPane()取出来,
         * 所以如果设置JFrame的背景颜色,仍然会被内容面板盖住,不如设置内容面板的背景颜色
         *
         * 这里我们设置背景颜色呢
         * 我可以实例化容器
         * Container contentPane = jFrame.getContentPane();
         * 在容器里设置背景颜色
         */
        jFrame.setBounds(650, 300, 500, 500);
        jFrame.setVisible(true);
        //设置文字Jlable
        JLabel jLabel = new JLabel("这是JLabel");
//        jFrame.setLayout(new FlowLayout(FlowLayout.CENTER));
        jLabel.setHorizontalAlignment(SwingConstants.CENTER);//设置水平居中
        jFrame.add(jLabel);
        //获得容器
        Container contentPane = jFrame.getContentPane();
        contentPane.setBackground(Color.pink);
        //关闭事件
        /**
         * 人家继承Frame，已经实现许多监听事件，再自己写就很low
         * setDefaultCloseOperation默认的关闭事件
         * 参数是WindowConstants常量
         */
        jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }
    //接下来才去主函数生成窗口
    public static void main(String[] args) {
        new JFrameDemo().init();
    }
}

效果：

个人测试

package GUI.Swing;

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

/**
 * 窗口、面板
 * 设置背景颜色。
 *  并且做到在上边加一个标签，并且要设置居中什么的
 *  和布局做区分
 * 知识
 *  jLabel.setHorizontalAlignment(SwingConstants.CENTER);//设置水平居中
 *  //获得容器
 *         Container contentPane = jFrame.getContentPane();
 *         contentPane.setBackground(Color.pink);
 *
 *  关闭窗口
 *      jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 */

public class JFrameDemo {
    //构造框架，作为初始化加载的面板
    public void init(){
        JFrame jFrame1 = new JFrame("第一个jframe");
        Container containerPane = jFrame1.getContentPane();
        containerPane.setBackground(new Color(0xFCE69F));
        JLabel label1 = new JLabel("小标签");

        //布局
        label1.setHorizontalAlignment(SwingConstants.CENTER);
        jFrame1.setVisible(true);
        jFrame1.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        jFrame1.setBounds(200,200,400,400);
        jFrame1.add(label1);
    }
    //测试
    public static void main(String[] args) {
        new JFrameDemo().init();
    }
}

效果：

3.2、弹窗

package GUI.Swing;

/**
 * 弹窗
 * 要点：
 *  在原本的Jframe（要设置颜色）里放一个按钮，添加事件监听
 *  然后在事件监听之后，弹出一个弹窗！（这个弹窗也弄颜色）
 *
 *  弹窗类继承JDialog，当然啦，继承Jframe也是可以的
 */

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

//主窗口
public class DialogDemo extends JFrame {
    //布局
    public DialogDemo(){
        super("弹窗的主窗口");
        JButton jButton1 = new JButton("点击本按钮弹出弹窗");
        Container containerPane = getContentPane();
        containerPane.setBackground(Color.red);
        jButton1.setBounds(0,0,300,100);
        //给按钮添加添加事件监听
        jButton1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                new myDialog();
            }
        });
        //布局
        //绝对布局，按照坐标来
        setLayout(null);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setVisible(true);
        setBounds(200,200,400,400);
        add(jButton1);
    }
    //弹窗内部类
    class myDialog extends JDialog{
        public myDialog(){
            Container container = getContentPane();
            container.setBackground(Color.yellow);
            //布局
            setVisible(true);
            setBounds(400,400,400,400);
        }
    }

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

效果:

3.3、标签

画一个标签

package GUI.Swing;

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

/**
 * 标签(图标)
 * 做一个图标（自己画）用到paintIcon
 * 需要实现Icon接口
 * 图标可以放在按钮/标签上。（如果要弄多个，得记得设置布局，不然会覆盖）
 */


public class IconDemo extends JFrame implements Icon{
    //定义图标的宽度和高度
    int width;
    int heigth;
    //初始化咯
    public IconDemo(int width,int heigth){
        super("第一个图标");//对“super（）”的调用必须是构造函数体中的第一条语句
        this.width = width;
        this.heigth = heigth;
    }
    //为了区分业务逻辑，这里再写一个加载类（也就是形成框架）
    public void init(){
        //来个按钮和标签放图标
        JButton jButton1 = new JButton("放图标的按钮",this);


        //布局
        Container container = new Container();
//        setLayout(new FlowLayout());
        add(jButton1);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        pack();//自适应宽高

    }

    //画图标，弄个实心矩形好啦
    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
        //坐标和宽高
        g.fillRect(x,y,width,heigth);
    }
    //这两个一定要返回，不然会位置失调
    @Override
    public int getIconWidth() {
        return width;
    }

    @Override
    public int getIconHeight() {
        return heigth;
    }

    public static void main(String[] args) {
        //创造图标
        IconDemo iconDemo=new IconDemo(20,20);
        //加载框架
        iconDemo.init();
    }
}

效果：

把图片做成标签

package GUI.Swing;

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

/**
 * 图片做成标签
 * 实现：
 *  把图片做成标签就显示在中间就好啦
 *  把图片做成图标，再把图标放在标签上/按钮上
 * 知识：
 * //获取图片的地址
 *         URL url = ImageIconDemo.class.getResource("tx.jpg");
 * //调用图标对象
 *         ImageIcon imageIcon = new ImageIcon(url);
 */

public class ImageIconDemo extends JFrame {
    public ImageIconDemo(){
        super("图片做成标签");
        //获取图片地址
        URL url = ImageIconDemo.class.getResource("2.png");
        ImageIcon imageIcon = new ImageIcon(url);
        JLabel jLabel1 = new JLabel(imageIcon,SwingConstants.CENTER);

        //布局
        Container containerPane = getContentPane();//获取JFrame自带的内容面板
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(200,200,400,400);
        containerPane.add(jLabel1);
//        add(jLabel1); 这个也可以哦
    }
    public static void main(String[] args) {
        new ImageIconDemo();
    }

}

效果：（图片放的位置和类同级）

3.4、面板

package GUI.Swing;

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

/**
 * 面板
 * 目标
 *      做一个上下结构的，上面3个按钮，下面一个大按钮的效果
 *
 * 思路：
 *      在JFrame上可以用表格布局！（整体结构又是一个表格布局，2行1列，设置边距）
 *      创建两个面板
 *      上面的面板1行3列。
 *      下面的面板1行1列
 *
 */
public class JPanelDemo extends JFrame{
    /**
     * 创建面板
     */
    public JPanelDemo(){
        super("Jpanel");
        //创立两个面板
        JPanel jPanel1 = new JPanel(new GridLayout(1,3,10,0));
        JPanel jPanel2 = new JPanel(new GridLayout(1,1));

        //布局
        Container containerPane = getContentPane();
        containerPane.setLayout(new GridLayout(2,1,10,10));//右边两个代表边距（水平间距和垂直间距）
        setVisible(true);
        setBounds(200,200,600,600);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        //把东西放进去
        containerPane.add(jPanel1);
        containerPane.add(jPanel2);
        jPanel1.add(new Button("button1"));
        jPanel1.add(new Button("button2"));
        jPanel1.add(new Button("button3"));
        jPanel2.add(new Button("button4"));
    }
    /**
     * 测试
     */
    public static void main(String[] args) {
        new JPanelDemo();
    }

}

效果：

JScrollPanel（滚动条与文本域）

package GUI.Swing;

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

/**
 * 滚动条
 * 目标：
 *      做个滚动条，上边放个文本域
 *
 * 实现：
 *      需要创建滚动面板
 *      需要创建文本域，并且加到滚动面板上
 *      需要让文本域的大小大于jframe边界的大小，这样才能显示滚动条
 * 知识：
 *   //文本域
 *         JTextArea textArea = new JTextArea(20, 50);
 *         textArea.setText("这是一个文本域");
 *   //Scroll面板
 *         JScrollPane scrollPane = new JScrollPane(textArea);
 */

public class JScrollDemo extends JFrame {
    public JScrollDemo(){
        super("滚动条与文本域");
        JTextArea textArea1 = new JTextArea(30, 30);
        textArea1.setText("这是文本域的内容");
        JScrollPane jScrollPane = new JScrollPane(textArea1);//固定用法，不需要在另外add了
        Container containerPane = getContentPane();
        //布局
        //把东西加上去
        containerPane.add(jScrollPane);
        //基础设置
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(200,200,300,400);
    }

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

效果：

3.5、按钮

按钮添加图标：

package GUI.Swing;

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

/**
 * 按钮添加图标
 * 目标：
 *      将图片放在按钮上
 * 知识：
 *      前面的用法是
 *      JLabel jLabel1 = new JLabel(imageIcon);
 *      这里是(其实实现的效果是完全一样的）
 *      JButton button = new JButton();
 *      button.setIcon(icon);//set…什么，这里设置图标咯
 *      button.setToolTipText("图片按钮");//设置提示按钮
 */

public class JButtonDemo01 extends JFrame {
    public JButtonDemo01(){
        super("图片放在按钮上");
        //图片转化为图标
        URL url = JButtonDemo01.class.getResource("4.png");
        ImageIcon imageIcon = new ImageIcon(url);

        JButton jButton1 = new JButton();
        jButton1.setIcon(imageIcon);
        jButton1.setToolTipText("图片按钮");//提示信息(当鼠标悬浮上去的时候就会看到）

        //布局
        //add
        Container containerPane = getContentPane();
        containerPane.add(jButton1);
        //basic
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(200,200,500,500);
    }

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

}

效果：

单选按钮：

package GUI.Swing;

/**
 * 单选框按钮
 * 目标：做个单选框
 * 实现：
 *      直接干
 * 知识：
 *      创建单选框，需要分组（一个组只能选择一个）
 *      单选框：JRadioButton
 *      分组：ButtonGroup
 */

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

public class JButtonDemo02 extends JFrame {
    public JButtonDemo02(){
        super("单选框");
        Container containerPane = getContentPane();
        //创建单选框
        JRadioButton jRadioButton01 = new JRadioButton("按钮1");
        JRadioButton jRadioButton02 = new JRadioButton("按钮2");
        JRadioButton jRadioButton03 = new JRadioButton("按钮3");
        //创建按钮组
        ButtonGroup group = new ButtonGroup();
        group.add(jRadioButton01);
        group.add(jRadioButton02);
        group.add(jRadioButton03);

        //add
        containerPane.setLayout(new GridLayout(3,1));
        containerPane.add(jRadioButton01);
        containerPane.add(jRadioButton02);
        containerPane.add(jRadioButton03);
        setVisible(true);
        setBounds(200,200,500,500);
    }

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

效果：

复选框按钮：

package GUI.Swing;

/**
 * 复选框按钮
 * 实现：
 *      和单选框差不多，改个名字，并且不用分组
 *      JcheckBox
 */

import javax.swing.*;
import java.awt.*;
public class JButtonDemo03 extends JFrame {
    public JButtonDemo03() {
        super("单选框");
        Container containerPane = getContentPane();
        //创建复选框
        JCheckBox jCheckBox1 = new JCheckBox("按钮1");
        JCheckBox jCheckBox2 = new JCheckBox("按钮2");
        JCheckBox jCheckBox3 = new JCheckBox("按钮3");

        //add
        containerPane.setLayout(new GridLayout(3,1));
        containerPane.add(jCheckBox1);
        containerPane.add(jCheckBox2);
        containerPane.add(jCheckBox3);
        setVisible(true);
        setBounds(200,200,500,500);
    }
    public static void main(String[] args) {
        new JButtonDemo03();
    }
}

效果

3.6、列表

下拉框：

package GUI.Swing;

/**
 * 列表
 * 目标：
 *      就是做一个组合框，下拉框
 *
 * JcomboBox (组合框)
 * 这个组合框！
 * 使用布局管理器时设置按钮大小
 * jbutton.setPreferredSize(new Dimension(w,h));
 *
 */

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

public class TestComboboxDemo01 extends JFrame {

    public TestComboboxDemo01(){
        Container containerPane = getContentPane();
        JButton jButton1 = new JButton("按钮");
//        jButton1.setBounds(20,20,100,100);
        jButton1.setPreferredSize(new Dimension(300,100));
        //创建组合框
        JComboBox comboBox = new JComboBox();

        //给组合框添加子项
        comboBox.addItem("第一项");
        comboBox.addItem("第二项");
        comboBox.addItem("第三项");
        comboBox.addItem("第四项");

        //布局
        //add
        jButton1.add(comboBox);
        containerPane.add(jButton1);

        setVisible(true);
        setLayout(new FlowLayout());
        containerPane.setBackground(Color.pink);
        setBounds(200,200,500,500);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

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

}

效果：

列表框：

package GUI.Swing;

/**
 * 列表框
 * 知识：
 * //矢量，向量，载体
 *      Vector vector = new Vector();
 *         vector.add("列表1");
 * //列表中放入内容
 *      JList jList = new JList(vector);
 *         container.add(jList);
 */

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

public class TestComboboxDemo02 extends JFrame {
    public TestComboboxDemo02(){
        super("列表框");

        Vector vector = new Vector();
        vector.add("列表1");
        vector.add("列表2");
        vector.add("列表3");
        vector.add("列表4");

        JList list = new JList(vector);
        //add
        add(list);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(200,200,300,300);
    }

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

效果：

• 应用场景
  • 选择地区，或者一些单个选项
  • 列表，展示信息，一般是动态扩容

3.7、文本框

文本框

package GUI.Swing;

/**
 * 文本框
 * 注意：
 *      文本框：JTextField
 *      文本域：JTextArea
 */

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

public class TestTextDemo01 extends JFrame {
    public TestTextDemo01(){
        super("JTextField");

        JTextField jTextField1 = new JTextField("hello");
        JTextField jTextField2 = new JTextField("world");

        //add
        Container containerPane = getContentPane();
        containerPane.add(jTextField1, BorderLayout.WEST);
        containerPane.add(jTextField2, BorderLayout.EAST);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setBounds(200,200,400,400);

    }

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

效果

密码框

package GUI.Swing;

/**
 * 密码框
 * 知识：
 *      JPasswordField jPasswordField = new JPasswordField();//默认就是几个点
 *      //手动设置为###########
 *         jPasswordField.setEchoChar('#');
 */

import javax.swing.*;
public class TestTextDemo03 extends JFrame {
    public TestTextDemo03(){
        super("密码框");
        JPasswordField passwordField = new JPasswordField(30);

        //手动设置
        passwordField.setEchoChar('$');
        add(passwordField);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//        this.setSize(500, 350);
        this.setVisible(true);
        pack();
    }

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

效果：

文本域

package GUI.Swing;

/**
 * 文本域
 * 注意：
 *      这个在滚动条那里一起学了的，这里重新写一遍复习一遍，但是代码和效果是一样的
 *
 */

import javax.swing.*;
public class jScorllDemo extends JFrame {
    public jScorllDemo(){
        super("文本域与滚动条");
        //文本域
        JTextArea area1 = new JTextArea(40,40);
        area1.setText("我是文本域哦！！！");
        //添加到滚动面板
        JScrollPane jScrollPane1 = new JScrollPane(area1);
        //add
        add(jScrollPane1);
        setVisible(true);
        pack();
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

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

效果：

版权

版权声明：本文为博主(Lovi)二创文章，遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明。

参考博客教程链接

参考视频教程链接

标签：java,GUI,基础,学习,add,frame,import,new,public
From： https://www.cnblogs.com/Lovi/p/16946030.html