awt、swing

￡小羽毛

已于 2023-10-25 21:12:07 修改

阅读量679

点赞数 1

文章标签： java jvm android

于 2023-04-01 11:40:42 首次发布

本文链接：https://blog.csdn.net/m0_56799642/article/details/129894930

版权

AWT

AWT：抽象窗口工具集。

程序仅指定了界面组件的位置和行为，并未提供真正的实现。把组件的创建和动作委托给程序所运行的平台。

AWT窗体

Component常见API

Component：一个能以图形方式显示出来并且可以与用户交互的对象。比如按钮Button和文本框TextField

Container常见API

Container是一种特殊的Component，可以装普通的Component，用add操作。

Container特有的常用API如下：

Container默认布局

Window是可以独立存在的顶级窗口，默认使用BorderLayout边界布局

Panel可以嵌入其他组件，默认使用FlowLayout流式布局

ScrollPane是一个带滚动条的容器，和Window一样使用BorderLayout边界布局

Frame 窗口

Frame类用于创建一个具有标题栏的框架窗口作为程序的主要界面，它不依赖其他容器可以单独存在。运行后可以看到一个弹窗

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setSize(400,400);
        //设置背景颜色
        frame.setBackground(new Color(145, 36, 44));
        //设置弹出的初始位置  0,0 在左上角
        frame.setLocation(0,0);
        //设置窗口是否可拉伸
        frame.setResizable(false);
   }

Panel 面板

特性：面板不能单独存在，必须在容器里面，可以看成一个空间。在程序中通常会使面板来实现一些特殊的布局。

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setSize(400,400);
        //设置背景颜色
        frame.setBackground(new Color(145, 36, 44));
        //设置弹出的初始位置  0,0 在左上角
        frame.setLocation(0,0);
        //设置窗口是否可拉伸
        frame.setResizable(false);
        //设置布局
        frame.setLayout(null);
        //pannel面板
        Panel panel = new Panel();
        panel.setBounds(0,0,100,400);
        panel.setBackground(new Color(83, 169, 56));
        frame.add(panel);
     }

ScollPane 滚动条容器

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //scrollPane滚动条容器
        ScrollPane scrollPane = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS);
        scrollPane.add(new Button("button"));
        scrollPane.add(new TextField("textField"));
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setSize(400, 400);
        //设置弹出的初始位置  0,0 在左上角
        frame.setLocation(0, 0);
        frame.add(scrollPane);
    }

AWT布局管理器

布局管理器可以根据操作系统来自动的调整组件大小，不用再手动设置组件的大小和位置。只需要选择合适的布局管理器就好

FlowLayout 流式布局

按水平方向依次排列放置组件，排满一行，换下一行继续排列。

排列方向（左到右或右到左）取决于容器的componentOrientation属性（该属性属于Component），它可能的值如下:

ComponentOrientation.LEFT_TO_RIGHT（默认）
ComponentOrientation.RIGHT_TO_LEFT

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setBounds(0,0,400,400);
        //文本框组件
        TextField num1 = new TextField();
        TextField num2 = new TextField();
        TextField num3 = new TextField();
        //一个按钮
        Button button = new Button("=");
        //一个标签
        Label label = new Label("+");
        FlowLayout flowLayout = new FlowLayout();
        //设置流式布局
        frame.setLayout(flowLayout);
        frame.add(num1);
        frame.add(label);
        frame.add(num2);
        frame.add(button);
        frame.add(num3);
        //设置最佳大小
        frame.pack();
    }

BorderLayout 边界布局

BorderLayout（边框布局管理器）是 Window、JFrame 和 JDialog 的默认布局管理器。

1.向BorderLayout的容器中添加组件时，需要指定添加到哪个区域，如果没有指定添加到哪个区域，则默认添加到center区域。
2.如果向同一个区域添加多个组件，则后放入的组件会覆盖先放入的

如果出现中文乱码：则VM options需要设置： -Dfile.encoding=gbk

frame是Window窗口，默认布局就是 BorderLayout

     public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setSize(400,400);
        //设置弹出的初始位置  0,0 在左上角
        frame.setLocation(0,0);
        //按钮组件
        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.setLayout(new BorderLayout());
        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.pack();
    }

边框布局管理器将窗口分为 5 个区域：North、South、East、West 和 Center。

如果西侧按钮和东侧按钮我不放，则不会留白，而是会被中间区域占有。如下：

GridLayout 网格布局

以矩形网格形式对容器的组件进行布置，把容器按行列分成大小相等的矩形网格，一个网格中放置一个组件，组件宽高自动撑满网格。默认是从左往右、从上往下添加到网格中

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setSize(400,400);
        //按钮组件
        Button button1 = new Button("游泳馆");
        Button button2 = new Button("电视馆");
        Button button3 = new Button("空调馆");
        Button button4 = new Button("小家电馆");
        Button button5 = new Button("厨卫馆");
        Button button6 = new Button("企业购");
        Button button7 = new Button("品牌大家电");
        Button button8 = new Button("品牌小家电");
        //设置网格2行4列
        GridLayout gridLayout = new GridLayout(2, 4);
        //设置网格布局
        frame.setLayout(gridLayout);
        frame.add(button1);
        frame.add(button2);
        frame.add(button3);
        frame.add(button4);
        frame.add(button5);
        frame.add(button6);
        frame.add(button7);
        frame.add(button8);
    }

第3个参数，第4个参数设置横向间距，和纵向间距
 //设置网格2行4列
 GridLayout gridLayout = new GridLayout(2, 4,10,10);

中文乱码

这是因为 Java 程序代码的编码方式是 UTF-8 格式的编码 ,而 Windows 系统使用的是 GBK 格式的编码 ;

点击 IntelliJ IDEA 中执行选项中的 " Edit Configurations… " 选项 ,在 VM options 输入框中 ,

输入-Dfile.encoding=gbk

AWT事件监听

窗口关闭事件

        //监听窗口关闭事件
        frame.addWindowListener(new WindowAdapter() {
            //适配器模式
            @Override
            public void windowClosing(WindowEvent e) {
                //结束程序
                System.exit(0);
            }
        });

按钮点击事件

public static void main(String[] args) {
    //frame窗口
    Frame frame = new Frame("java图形化界面窗口");
    //设置可见性 与 窗口大小
    frame.setVisible(true);
    frame.setSize(400,400);
    //设置背景颜色
    frame.setBackground(new Color(145, 36, 44));
    //设置弹出的初始位置  0,0 在左上角
    frame.setLocation(0,0);
    //设置窗口是否可拉伸
    frame.setResizable(false);
    //按钮组件
    Button button1 = new Button("button1");
    //显示设置按钮上的信息
    button1.setActionCommand("button1-11");
    button1.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("eee");
            System.out.println(e.getActionCommand());
        }
    });
    frame.add(button1,BorderLayout.CENTER);
}

点击按钮后，控制台打印。setActionCommand是为了在多个按钮的监听写在一个监听器，用if判断

文本框回车事件

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setSize(400,400);
        //设置背景颜色
        frame.setBackground(new Color(145, 36, 44));
        //设置弹出的初始位置  0,0 在左上角
        frame.setLocation(0,0);
        //设置窗口是否可拉伸
        frame.setResizable(false);
        //文本框组件
        TextField textField = new TextField();
        //按下回车键，会触发这个监听
        textField.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //获取资源
                TextField field = (TextField) e.getSource();
                //打印文本框内容
                System.out.println(field.getText());
            }
        });
        frame.add(textField,BorderLayout.CENTER);
    }

鼠标监听

监听鼠标按压、鼠标释放、鼠标点击

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setBounds(0,0,400,400);
        frame.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                System.out.println("鼠标进入组件区域");
            }

            @Override
            public void mouseExited(MouseEvent e) {
                System.out.println("鼠标离开组件区域");
            }

            @Override
            public void mousePressed(MouseEvent e) {
                // 获取按下的坐标（相对于组件）
                System.out.println("相对组件" + e.getPoint() + "，横坐标：" + e.getX() + ", 纵坐标：" + e.getY());
                // 获取按下的坐标（相对于屏幕）
                System.out.println("相对屏幕" + e.getLocationOnScreen() + "，横坐标：" + e.getXOnScreen() + ", 纵坐标：" + e.getYOnScreen());
            }

            @Override
            public void mouseReleased(MouseEvent e) {
                System.out.println("鼠标释放");
            }

            @Override
            public void mouseClicked(MouseEvent e) {
                // 鼠标在组件区域内按下并释放（中间没有移动光标）才识别为被点击
                System.out.println("鼠标点击");
            }
        });
    }

鼠标拖动、鼠标移动、鼠标滚轮滚动

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setBounds(0,0,400,400);
        /**
         * 鼠标移动/拖动监听器
         */
        frame.addMouseMotionListener(new MouseMotionAdapter() {
            @Override
            public void mouseDragged(MouseEvent e) {
                // 鼠标保持按下状态移动即为拖动
                System.out.println("鼠标拖动");
            }
            @Override
            public void mouseMoved(MouseEvent e) {
                System.out.println("鼠标移动");
            }
        });
        /**
         * 鼠标滚轮监听器
         */
        frame.addMouseWheelListener(new MouseWheelListener() {
            @Override
            public void mouseWheelMoved(MouseWheelEvent e) {
                // e.getWheelRotation() 为滚轮滚动多少的度量
                System.out.println("mouseWheelMoved: " + e.getWheelRotation());
            }
        });
    }

键盘监听

上下左右键和空格键：KeyEvent.VK_UP

public static final int VK_LEFT = 0x25;
public static final int VK_UP = 0x26;
public static final int VK_RIGHT = 0x27;
public static final int VK_DOWN = 0x28;
public static final int VK_SPACE = 0x20;

     public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setBounds(0,0,400,400);
        /**
         * 键盘监听事件
         */
        frame.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                // 获取键值，和 KeyEvent.VK_XXXX 常量比较确定所按下的按键
                System.out.println("按下: " + e.getKeyChar() + "，键值为：" + e.getKeyCode());
            }

            @Override
            public void keyTyped(KeyEvent e) {
                // e.getKeyChar() 获取键入的字符
                System.out.println("键入: " + e.getKeyChar());
            }

            @Override
            public void keyReleased(KeyEvent e) {
                System.out.println("释放: " + e.getKeyCode());
            }
        });
    }

窗口监听

    public static void main(String[] args) {
        //frame窗口
        Frame frame = new Frame("java图形化界面窗口");
        //设置可见性 与 窗口大小
        frame.setVisible(true);
        frame.setBounds(0, 0, 400, 400);
        /**
         * 窗口监听事件
         */
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("窗口被关闭了");
                System.exit(0);
            }

            @Override
            public void windowActivated(WindowEvent e) {
                System.out.println("窗口被激活了");
            }
        });
    }

Swing

Swing基本使用

基本窗口（一）

写一个基本的窗口

public class SwingDemo extends JFrame {

	private JPanel contentPane;

	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					SwingDemo frame = new SwingDemo();
					frame.setTitle("Swing jframe窗口");
					//设置窗口是否可见
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the frame.
	 */
	public SwingDemo() {
		//表示在关闭页面后程序自动结束运行
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 450, 300);
		contentPane = new JPanel();
		//创建空边框
		Border emptyBorder  = BorderFactory.createEmptyBorder();
		contentPane.setBorder(emptyBorder);
        //设置窗口的内容面板
		setContentPane(contentPane);
	}

}

无标题窗口

当调用窗体的this.setUndecorated(true)，即可不显示标题栏，去掉窗口的装饰风格；

基本案例（二）

public class SwingDemo {
    JFrame jf = new JFrame("jframe 窗口测试");

    //声明菜单相关组件
    JMenuBar jMenuBar = new JMenuBar();

    JMenu fileMenu = new JMenu("文件");
    JMenu editMenu = new JMenu("编辑");

    JMenuItem auto = new JMenuItem("自动换行");
    JMenuItem copy = new JMenuItem("复制");
    JMenuItem paste = new JMenuItem("粘贴");

    JMenu formatMenu = new JMenu("格式");

    JMenuItem comment = new JMenuItem("注释");
    JMenuItem cacleComment = new JMenuItem("取消注释");

    //声明文本域
    JTextArea jTextArea = new JTextArea(8, 20);

    //声明选择框
    //下拉列表框
    JComboBox<String> colorSelect = new JComboBox<>();

    //单选框需要按钮组
    ButtonGroup buttonGroup = new ButtonGroup();
    JRadioButton male = new JRadioButton("男", false);
    JRadioButton female = new JRadioButton("女", true);

    //复选框
    JCheckBox isSingle = new JCheckBox("是否单身", true);

    //声明底部
    JTextField tf = new JTextField(40);
    JButton ok = new JButton("确定");

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

    //初始化界面
    public void init() {
        //组装底部
        JPanel bottomJPanel = new JPanel();
        bottomJPanel.add(tf);
        bottomJPanel.add(ok);

        jf.add(bottomJPanel, BorderLayout.SOUTH);

        //组装选择组件
        JPanel selectJPanel = new JPanel();
        colorSelect.addItem("绿色");
        colorSelect.addItem("红色");
        colorSelect.addItem("黄色");
        selectJPanel.add(colorSelect);

        buttonGroup.add(male);
        buttonGroup.add(female);
        selectJPanel.add(male);
        selectJPanel.add(female);

        selectJPanel.add(isSingle);


        //组装文本域和选择相关组件
        Box top = Box.createVerticalBox();
        top.add(jTextArea);
        top.add(selectJPanel);

        jf.add(top);//默认放centre区域

        //组装菜单相关
        formatMenu.add(comment);
        formatMenu.add(cacleComment);

        editMenu.add(auto);
        editMenu.addSeparator();//添加横杠
        editMenu.add(copy);
        editMenu.add(paste);
        editMenu.addSeparator();//添加横杠
        editMenu.add(formatMenu);

        jMenuBar.add(fileMenu);
        jMenuBar.add(editMenu);

        //窗口菜单显示
        jf.setJMenuBar(jMenuBar);

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口大小与可见
        jf.pack();
        jf.setVisible(true);
    }
}

效果如下：

swing相比于awt

Swing是纯java实现的（100%），不再调用本地平台的GUI，可以在所有操作系统上都保持相同的界面外观，相较于awt被称为“轻量级组件”。

大部分情况下，在awt组件的名称前面加J，就变成Swing组件。但是有几个特殊情况：

Swing组件相较于AWT组件，额外增加了以下功能：

Jlabel

JLabel（）创建一个不含图像，不含文本的 JLabel 对象

JLabel（String text）使用指定的文本创建一个 JLabel 对象

JLabel（Icon image）创建一个具有指定图像的 JLabel 对象

void setText("内容");//设置组件内容
void setForeground(Color c);//设置字体颜色
void setFont(Font font);//设置字体风格、大小
void setBorder(BorderFactory bf);//设置组件JLabel标签的边框线
void setPreferredSize(Dimension n);//设置标签的宽度和高度
void setHorizontalAlignment(JLabel.CENTER);//设置标签内的文本对齐方式
void setCursor(cursor);//设置当鼠标触碰标签时，鼠标的样式。
void setOpaque(true);//关闭透明度
void setBackground(Color.yellow);//设置背景，需要将透明度关闭
// 设置文本相对于图片的位置（文本默认在图片右边垂直居中）
void setHorizontalTextPosition(int textPosition)
void setVerticalTextPosition(int textPosition)
// 设置标签内容（在标签内）的对其方式（默认左对齐并垂直居中）
void setHorizontalAlignment(int alignment)
void setVerticalAlignment(int alignment)
void setIconTextGap(int iconTextGap)// 设置图片和文本之间的间隙
void setToolTipText(String text)// 当鼠标移动到组件上时显示的提示文本
void setVisible(boolean visible)// 设置组件是否可见
void setMinimumSize(Dimension minimumSize)// 设置组件的 最小 大小
void setMaximumSize(Dimension maximumSize)// 设置组件的 最大 大小

JFrame窗口

一个窗口通常包含有标题、图标、操作按钮（关闭、最小化、最大化）

JFrame构造器

JFrame frame = new JFrame("窗口的名字，也可以空着");

常用的方法

void setTitle(String title) // 设置窗口的标题

void setIconImage(Image image) // 设置窗口的图标

void setResizable(boolean resizable) // 设置窗口是否可以放大缩小

void setSize(int width, int height) // 设置窗口的宽高

/**
 * 设置窗口的相对位置。
 * 如果 comp 整个显示区域在屏幕内，则将窗口放置到 comp 的中心。
 * 如果 comp 显示区域有部分不在屏幕内，则将窗口放置在最接近 comp 中心的一侧。
 * comp 为 null，表示将窗口放置到屏幕中心。
 */
void setLocationRelativeTo(Component comp) 

void setVisible(boolean visible)//设置窗口是否可见

void pack() // 调整窗口的大小，以适合其子组件的首选大小和布局

boolean isShowing() // 判断窗口是否处于显示状态

// 设置窗口的 位置（相对于屏幕左上角）
void setLocation(int x, int y)
void setLocation(Point p)

// 设置窗口的 位置 和 宽高
void setBounds(int x, int y, int width, int height)
void setBounds(Rectangle rect)

// 设置将窗口 置顶 显示
void setAlwaysOnTop(boolean alwaysOnTop)

// 销毁窗口, 释放窗口及其所有子组件占用的资源, 之后再次调用 setVisible(true) 将会重构窗口
void dispose()

JPanel面板

JPanel面板本身不能作为窗口显示，必须依赖如JFrame容器进行显示。一个界面只可以有一个JFrame窗体组件，但可以有多个JPanel面板组件。

JPanel的默认布局为FlowLayout【按水平方向依次排列放置组件，排满一行，换下一行继续排列】

JPanel类构造方法

JPanel() //创建具有双缓冲和流布局的新 JPanel。
JPanel(boolean isDoubleBuffered) //创建具有 FlowLayout 和指定缓冲策略的新 JPanel。
JPanel(LayoutManager layout) //创建具有指定布局管理器的新缓冲 JPanel。
JPanel(LayoutManager layout, boolean isDoubleBuffered) //创建具有指定布局管理器和缓冲策略的新 JPanel。

JPanel方法

Component add（Component comp）//往面板内添加控件
void remove（Component comp）//从容器中移除指定的组件
void setFont（Font f）//设置容器的字体
void setLayout（LayoutManager mgr）//设置容器的布局管理器
void setBackground（Color c）//设置组件的背景色

一个小案例

	public SwingDemo() {
		//表示在关闭页面后程序自动结束运行
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 450, 300);
		contentPane = new JPanel();
		//创建空边框
		Border emptyBorder  = BorderFactory.createEmptyBorder();
		contentPane.setBorder(emptyBorder);
        //设置窗口的内容面板
		setContentPane(contentPane);
		
		JPanel panel = new JPanel();
		panel.setBackground(new Color(0, 255, 0));
		//add(组件)加入组件
		contentPane.add(panel);
		
		JButton btnNewButton = new JButton("接收");
		panel.add(btnNewButton);
		
		JButton btnNewButton_1 = new JButton("发送");
		panel.add(btnNewButton_1);
	}

Swing边框

Swing允许我们在组件的边缘绘制边框。有不同种类的边界

线边框只是画一条线。我们可以指定线的颜色和粗细
public static Border createLineBorder(Color color, int thickness){}
thickness：直译厚度
//创建线边框
Border  lineThickerBorder = BorderFactory.createLineBorder(Color.RED, 3);
contentPane.setBorder(lineThickerBorder);

jpanel边框

TitledBorder 带标题的边框
JPanel panel = new JPanel();
//设置panel的边框和标题
panel.setBorder(new TitledBorder(new EtchedBorder(), "按钮设置"));
EtchedBorder 该类实现简单的浮雕化边框

--------------------------------------------------------------------

SoftBevelBorder 要么凸出要么凹入且拐角圆滑
JPanel panel = new JPanel();
//设置panel的边框和标题
panel.setBorder(new TitledBorder(BorderFactory.createLoweredBevelBorder(), "按钮设置"));
-----------------------------------------------------------------------------

BevelBorder 简单的双线斜面边框
JPanel panel = new JPanel();
//设置panel的边框和标题
panel.setBorder(new TitledBorder(new BevelBorder(BevelBorder.RAISED), "按钮设置"));
------------------------------------------------------------------------------------------------------

EmptyBorder 空边框
JPanel panel = new JPanel();
//设置panel的边框和标题
panel.setBorder(new TitledBorder(BorderFactory.createEmptyBorder(), "按钮设置"));

JToolBar工具条

jToolBar基本使用

public class SwingDemo {
    JFrame jf = new JFrame("jframe 工具条测试");
    JTextArea jTextArea = new JTextArea(6, 30);
    //声明工具条相关组件
    JToolBar jToolBar = new JToolBar("播放工具条", SwingConstants.HORIZONTAL);
    AbstractAction pre = new AbstractAction("上一曲") {
        @Override
        public void actionPerformed(ActionEvent e) {
            //工具条按钮点击后的行为
            jTextArea.append("上一曲\n");
        }
    };

    AbstractAction pause = new AbstractAction("暂停播放") {
        @Override
        public void actionPerformed(ActionEvent e) {
            //工具条按钮点击后的行为
            jTextArea.append("暂停播放\n");
        }
    };


    AbstractAction next = new AbstractAction("下一曲") {
        @Override
        public void actionPerformed(ActionEvent e) {
            //工具条按钮点击后的行为
            jTextArea.append("下一曲\n");
        }
    };


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

    //初始化界面（组装视图）
    public void init() {
        jToolBar.add(pre);
        jToolBar.addSeparator();
        jToolBar.add(pause);
        jToolBar.addSeparator();
        jToolBar.add(next);

        //设置工具条可以拖动
        jToolBar.setFloatable(true);

        jf.add(jToolBar, BorderLayout.NORTH);
        jf.add(jTextArea);

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口大小与可见
        jf.pack();
        jf.setVisible(true);
    }
}

把一个组件设置在JScrollPane，就可以支持滚动条了。

JOptionPane对话框

MessageType，五种不同的消息类型如下：

JOptionPane可以创建一些简单的对话框。如下：

消息对话框 showMessageDialog()

用户只能点击确定按钮。

第一个参数是一个组件，它决定了显示对话框的框架；如果为 null，或者如果parentComponent没有 Frame，则使用默认 Frame。
//第一个参数：对话框所在的容器
JOptionPane.showMessageDialog(null,"保存成功！","提示",JOptionPane.INFORMATION_MESSAGE);

确认对话框 showConfirmDialog()

向用户确认某个问题。用户可以选择yes、no、cancel

 //第一个参数：对话框所在的容器
 int result = JOptionPane.showConfirmDialog(dlgIconAdd, "表格中存在不完整的行，关闭会造成不完整的行丢失！\n确认关闭吗？", "提示", JOptionPane.OK_OPTION, JOptionPane.QUESTION_MESSAGE);
 if(result == JOptionPane.YES_OPTION) {
     System.out.println("用户点击了Yes按钮");
 } else if (result == JOptionPane.NO_OPTION) {
     System.out.println("用户点击了No按钮");
 }

输入对话框 showInputDialog();

要求输入某些信息

//第一个参数：对话框所在的容器
String info = JOptionPane.showInputDialog(null,"你的csdn昵称是什么","找回密码",JOptionPane.QUESTION_MESSAGE);
System.out.println(info);

选择对话框 showOptionDialog();

JDialog窗体

JDialog 窗体的功能是从一个窗体中弹出另一个窗体

在应用程序中创建JDialog窗体需要实例化JDialog类，通常使用以下几个JDialog类的构造方法

　　public JDialog(): 创建一个没有标题和父窗体的对话框。

　　public JDialog(Frame f): 创建一个指定父窗体的对话框，但该窗体没有标题。

　　public JDialog(Frame f, boolean model): 创建一个指定模式的父窗体对话框，但该窗体没有指定标题。

　　public JDialog(Frame f, String title): 创建一个指定父窗体和标题的对话框。

　　public JDialog(Frame f, String title, boolean model): 创建一个指定窗体、标题和模式的对话框。

常用方法

名称	概述
getContentPane()	返回此对话框的 contentPane 对象。
getDefaultCloseOperation()	返回用户在此对话框上启动 "close" 时所执行的操作。
getGraphics()	为组件创建一个图形上下文。
getJMenuBar()	返回此对话框上设置的菜单栏。
getLayeredPane()	返回此对话框的 layeredPane 对象。
remove(Component comp)	从该容器中移除指定组件
repaint(longtime, int x, int y, int width, int height)	在 time 毫秒内重绘此组件的指定矩形区域
setContentPane(Container contentPane)	设置 contentPane 属性。
setDefaultCloseOperation(int operation)	设置当用户在此对话框上启动 "close" 时默认执行的操作。
setJMenuBar(JMenuBar menu)	设置此对话框的菜单栏
setLayout(LayoutManager manager)	设置 LayoutManager。
setTransferHandler(TransferHandler newHandler)	设置 transferHandler 属性，该属性是支持向此组件传输数据的机制
update(Graphics g)	调用 paint(g)。

Swing绘图

AWT 绘图步骤如下 :

自定义 Canvas 组件类 , 重写其中的 Component#paint(Graphics g) 函数 , Component 组件与 Graphics 是由 paint(Graphics g) 函数进行关联的 ;
在自定义的 Canvas 组件重写的 Component#paint(Graphics g) 函数中 , 先调用 Graphics 实例对象的 setColor , setFont 等函数 , 设置画笔的相关属性 ;
调用 Graphics 实例对象的 drawXxx 函数开始绘图 ;

颜色Color

以设置画笔颜色为例

创建具有指定组合的 RGB 值的不透明的 sRGB 颜色
graphics.setColor(new Color(255));
点击前面的颜色方块有惊喜呢

也可以使用静态常量
graphics.setColor(Color.pink);
实际上在Color中还是
public final static Color pink = new Color(255, 175, 175);

画布Canvas

包含用于创建用户界面和绘制图形图像的所有类

Toolkit.createCanvas(Canvas target)

画笔Graphics

设置画笔的相关属性

void setColor(Color c) //设置画笔颜色
void setFont(Font font) //设置画笔绘制文字的字体

绘制图形

绘制直线 点(x1, y1)和点(x2, y2)之间绘制一条线
void drawLine(int x1, int y1, int x2, int y2)
绘制矩形 要画的矩形左上角的x坐标和y坐标，要画的矩形的宽度和高度
void drawRect(int x, int y, int width, int height) 
fillRect(int x,int y, int width, int height)  //对矩形的颜色进行填充
绘制圆形
void drawOval(int x, int y, int width,int height)
fillOval(int x,int y, int width, int height)//填充圆形
绘制位图
boolean drawImage(Image img, int x, int y, ImageObserver observer)

绘制小案例

public class DrawPersonDemo {

    // 创建相框
    JFrame jFrame = new JFrame();

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

    public void init() {
        //设置画框大小（宽度，高度），默认都为0
        jFrame.setSize(600, 600);
        //关闭窗口后停止程序
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //创建底部的按钮面板
        JPanel jPanel = new JPanel();
        jPanel.add(button);
        //将绘有小人图像的画板嵌入到相框中
        jFrame.add(jPanel, BorderLayout.SOUTH);
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //画布重新绘制
                myCanvas.repaint();
            }
        });

        //设置画布的大小和位置
        myCanvas.setPreferredSize(new Dimension(300, 300));
        myCanvas.setBackground(Color.pink);
        jFrame.add(myCanvas);

        //将画框展示出来。true设置可见，默认为false隐藏
        jFrame.setVisible(true);
    }

    Button button = new Button("绘制");

    //创建自定义的画布对象
    MyCanvas myCanvas = new MyCanvas();

    //继承Canvas 组件类 , 重写paint函数
    private class MyCanvas extends Canvas {
        @Override
        public void paint(Graphics g) {
            // 用画笔Graphics，在画板JPanel上画一个小人
            g.drawOval(100, 70, 30, 30);// 头部（画圆形）
            g.drawRect(105, 100, 20, 30);// 身体（画矩形）
            g.drawLine(105, 100, 75, 120);// 左臂（画直线）
            g.drawLine(125, 100, 150, 120);// 右臂（画直线）
            g.drawLine(105, 130, 75, 150);// 左腿（画直线）
            g.drawLine(125, 130, 150, 150);// 右腿（画直线）
        }
    }
}

结果就是我还没点击按钮呢，就绘制出来了？而且中文也乱码。一到自己上手操作真的就是问题一堆！

Canvas是AWT组件,JPanel是Swing组件,Swing组件是以AWT组件为基础的,从理论上来说,Canvas要比JPanel更轻量些.如果canvas能满足需求,就用canvas.

还有一种不用继承Canvas，额。。。

public class DrawPersonDemo {
    public static void main(String[] args) {
        // 创建相框
        JFrame jFrame = new JFrame();
        // 创建画板
        JPanel jpanel = new JPanel() {
            //序列号（可省略）
            private static final long serialVersionUID = 1L;

            // 重写paint方法
            @Override
            public void paint(Graphics graphics) {
                // 必须先调用父类的paint方法
                super.paint(graphics);
                // 用画笔Graphics，在画板JPanel上画一个小人
                graphics.drawOval(100, 70, 30, 30);// 头部（画圆形）
                graphics.drawRect(105, 100, 20, 30);// 身体（画矩形）
                graphics.drawLine(105, 100, 75, 120);// 左臂（画直线）
                graphics.drawLine(125, 100, 150, 120);// 右臂（画直线）
                graphics.drawLine(105, 130, 75, 150);// 左腿（画直线）
                graphics.drawLine(125, 130, 150, 150);// 右腿（画直线）
            }
        };
        //将绘有小人图像的画板嵌入到相框中
        jFrame.add(jpanel);
        //设置画框大小（宽度，高度），默认都为0
        jFrame.setSize(300, 300);
        //关闭窗口后停止程序
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 将画框展示出来。true设置可见，默认为false隐藏
        jFrame.setVisible(true);
    }
}

效果

位图BufferedImage

BufferedImage是Image的一个子类， BufferedImage生成的图片在内存里有一个图像缓冲区，利用这个缓冲区我们可以很方便的操作这个图片，通常用来做图片修改操作如大小变换、图片变灰、设置图片透明或不透明等

Java将一副图片加载到内存中的方法是：

//把图片从硬盘加载到内存BufferedImage
String imgPath = "D:\\wallhaven-3z32j3.jpg";
//生成图像缓冲区，方便操作图片
BufferedImage image = ImageIO.read(new FileInputStream(imgPath));

接下来画出加载到内存的图片

Graphics提供了drawImage(Image img, int x, int y,int width, int height,ImageObserver observer);

来绘制位图，该方法需要一个位图做参数。
//x，y是指定绘制图像矩形左上角的位置，
//idth是指定绘制图像矩形的宽，width是指定绘制图像矩形的高，observer是要绘制图像的容器
graphics.drawImage(image, 0, 0, image.getWidth(null), image.getHeight(null), null);

        // 创建相框
        JFrame jFrame = new JFrame();
        // 创建画板
        JPanel jpanel = new JPanel() {
            //序列号（可省略）
            private static final long serialVersionUID = 1L;

            // 重写paint方法
            @Override
            public void paint(Graphics graphics) {
                // 必须先调用父类的paint方法
                super.paint(graphics);

                //把图片从硬盘加载到内存BufferedImage
                String imgPath = "D:\\wallhaven-3z32j3.jpg";
                BufferedImage image;
                try {
                    //生成图像缓冲区，方便操作图片
                    image = ImageIO.read(new FileInputStream(imgPath));
                    //x，y是指定绘制图像矩形左上角的位置，
                    //idth是指定绘制图像矩形的宽，width是指定绘制图像矩形的高，observer是要绘制图像的容器
                    graphics.drawImage(image,0,0,image.getWidth(jFrame),image.getHeight(jFrame),jFrame);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        };
        //将图像的画板嵌入到相框中
        jFrame.add(jpanel);
        //设置画框大小（宽度，高度），默认都为0
        jFrame.setSize(600, 400);
        //关闭窗口后停止程序
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // 将画框展示出来。true设置可见，默认为false隐藏
        jFrame.setVisible(true);
    }

JPanel刷新重绘

面板操作在Java程序设计中很常见，有的时候更是需要对面板进行相应的操作，比如点击按钮对面板进行更新或者重画

1、移除JPanel/Panel面板的所有组件，重新构建一个JPanel/Panel面板，在新面板上重新构建所需要的组件。造成了系统资源的浪费

2、移除所有组件（或者移除特定组件），抽象一个方法，把JPanel/Panel面板和需要添加或重构的组件传递过去

优点：至始至终都只有一个面板，不管你点击多少次，方便操作之余，也不会出现重新构建够面板突然缩水的情况

revalidate()方法

panel.revalidate();//对panel面板中的组件重新布局并绘制

.repaint()方法

panel.repaint();//对panel本身进行重绘

Swing组件

JColorChooser颜色选择器对话框

JColorChooser用于创建颜色选择器对话框，showDialog是一个静态方法。用法如下：

component：指定当前对话框的父组件
title：对话框名称
initialColor：默认选中的颜色

返回值是用户选中的颜色

    public static Color showDialog(Component component,
        String title, Color initialColor) throws HeadlessException {

    }

案例测试

public class SwingDemo {
    JFrame jf = new JFrame("jframe 颜色选择器测试");
    JTextArea jTextArea = new JTextArea("我行我素，大大咧咧",6,30);
    JButton jButton = new JButton(new AbstractAction("选择背景颜色") {
        @Override
        public void actionPerformed(ActionEvent e) {
            //弹出颜色选择器
            Color result = JColorChooser.showDialog(jf, "颜色选择器", Color.white);
            //修改文本框背景颜色
            jTextArea.setBackground(result);
        }
    });


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

    //初始化界面（组装视图）
    public void init() {
        jf.add(jTextArea);
        jf.add(jButton,BorderLayout.SOUTH);

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口大小与可见
        jf.pack();
        jf.setVisible(true);
    }
}

JFileChooser文件选择器

JFileChooser用于生成“打开文件”、“保存文件”对话框

public class SwingDemo {
    JFrame jf = new JFrame("jframe 文件选择器测试");
    JMenuBar jMenuBar = new JMenuBar();
    JMenu jMenu = new JMenu("文件");

    JMenuItem open = new JMenuItem(new AbstractAction("打开") {
        @Override
        public void actionPerformed(ActionEvent e) {
            //显示文件选择器,传入默认打开路径为当前项目路径
            JFileChooser jFileChooser= new JFileChooser(".");
            jFileChooser.showOpenDialog(jf);
            //获取用户选择的文件
            File file = jFileChooser.getSelectedFile();
            try {
                //读取图片，重绘画布
                image = ImageIO.read(file);
                myCanvas.repaint();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    });

    JMenuItem save = new JMenuItem(new AbstractAction("另存为") {
        @Override
        public void actionPerformed(ActionEvent e) {
            //显示文件选择器,传入默认打开路径为当前项目路径
            JFileChooser jFileChooser= new JFileChooser(".");
            jFileChooser.showSaveDialog(jf);
            //获取用户选择的保存文件路径
            File file = jFileChooser.getSelectedFile();
            try {
                ImageIO.write(image,"jpg",file);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    });

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

    private class MyCanvas extends Panel{
        @Override
        public void paint(Graphics g) {
            //把图片绘制到组件上
            g.drawImage(image,0,0,null);
        }
    }

    BufferedImage image;
    MyCanvas myCanvas= new MyCanvas();

    //初始化界面（组装视图）
    public void init() {
        jMenu.add(open);
        jMenu.add(save);

        jMenuBar.add(jMenu);
        //菜单条设置给窗口
        jf.setJMenuBar(jMenuBar);

        //放入绘图区
        myCanvas.setPreferredSize(new Dimension(740,500));
        jf.add(myCanvas);

        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口大小与可见
        jf.pack();
        jf.setVisible(true);
    }
}

JSplitPane分割面板

可以将一个容器分割成上下或者左右俩个部分。

JSplitPane使用步骤：

JTablePane标签页面板

JTablePane使用步骤

JProgressBar进度条

JProgressBar使用步骤

JProgressMonitor进度对话框

JProgressMonitor使用如下：

JList、JComboBox列表框

JComboBox下拉框

JTree、TreeModel树

树本质上是一个一个节点（父节点、子节点）组成的。

public class SwingDemo {
    JFrame jf = new JFrame("jframe JTree测试");

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

    //初始化界面（组装视图）
    public void init() {
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("中国");
        DefaultMutableTreeNode shanxi = new DefaultMutableTreeNode("陕西");
        DefaultMutableTreeNode liaoning = new DefaultMutableTreeNode("辽宁");
        DefaultMutableTreeNode xian = new DefaultMutableTreeNode("西安");
        DefaultMutableTreeNode yulin = new DefaultMutableTreeNode("榆林");
        DefaultMutableTreeNode shenyang = new DefaultMutableTreeNode("沈阳");
        DefaultMutableTreeNode dalian = new DefaultMutableTreeNode("大连");

        //组装节点关系
        root.add(shanxi);
        root.add(liaoning);

        shanxi.add(xian);
        shanxi.add(yulin);

        liaoning.add(shenyang);
        liaoning.add(dalian);

        //根据根节点创建JTree对象
        JTree jTree=new JTree(root);

        jf.add(jTree);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口大小与可见
        jf.pack();
        jf.setVisible(true);
    }
}

其他重要方法

编辑树节点

监听树节点事件

改变树节点外观

JTable、TableModel表格

public class SwingDemo {
    JFrame jf = new JFrame("jframe JTable测试");

    Object[] titles={"姓名","年龄","性别"};

    Object[][] data={
            {"张三","21","男"},
            {"李四","22","女"},
            {"王五","23","男"}
    };

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

    //初始化界面（组装视图）
    public void init() {
        JTable jTable = new JTable(data, titles);
        jf.add(new JScrollPane(jTable));
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置窗口大小与可见
        jf.pack();
        jf.setVisible(true);
    }
}

表格调整

自定义TableModel

DefaultTableModel

DefaultTableModel defaultTableModel=new DefaultTableModel(data,titles);
JTable jTable = new JTable(defaultTableModel);

DefaultTableModel提供如下方法控制数据行操作