Java的基本学习第四部分

最新推荐文章于 2024-07-12 15:51:39 发布

轻舟在过

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量735

点赞数 2

文章标签： java

本文链接：https://blog.csdn.net/m0_46378049/article/details/105109908

版权

承接上面的内容

我们来继续学习Java，这一篇主要会讲常用组件GUI设计与高级组件GUI设计

常用组件GUI设计♥：

布局管理器：

Java的GUI界面是由AWT类和Swing类来完成的。在Java中，容器和布局管理是相分离的，容器只负责承载组件，而将布局的管理任务交给专门的布局管理器接口类（Layout Manager）的实现类来完成。当然也可以不用缺省的布局管理器，而是通过setLayout()方法来为其指定新的布局管理器，一旦确定了布局管理方式，容器的组件就可以使用add()加入了。

AWT和Swing分别持有的几种布局管理器类：

java.awt包中的这五个类，都是java.lang.Object类的直接子类

BorderLayout：

BorderLayout是JApplet的默认布局模式，通过NORTH、SOUTH、EAST、WEST、CENTER进行标识，

将容器内的空间划分为东、西、南、北、中五个区域（每个区域最多只能包含一个组件）

构造方法：

//用于创造一个各组件间的水平、垂直间隔均为0的BorderLayout对象
BorderLayout( )
//用于创造一个各组件间的水平间隔为hgap，垂直间隔为vgap的BorderLayout对象
BorderLayout(int hgap,int vgap)

package 测试;
import java.awt.*;
import javax.swing.*;
public class test extends JApplet
{
	//获得顶级容器的内容面板
	Container cp=getContentPane();
	public void init()
	{
		//给内容面板添加组件，根据BorderLayout布局管理器的位置
		cp.add(new JButton("North"),BorderLayout.NORTH);
		cp.add(new JButton("South"),BorderLayout.SOUTH);
		cp.add(new JButton("East"),BorderLayout.EAST);
		cp.add(new JButton("West"),BorderLayout.WEST);
		cp.add(new JButton("Center"),BorderLayout.CENTER);
	}
}

FlowLayout:

FlowLayout的布局策略是按照加入容器的组件的先后顺序从左到右排列，当一行排满之后就转到下一行继续从左到右排列，每一行中的组件都居中排列。

构造方法：

//用于创造一个版面设定为居中对齐、各组件的水平及垂直间隔为5个像素点的对象
FlowLayout()
//用于创建一个版面按给出的align值对齐。各组件的水平及垂直间隔为5个像素点的对象
//align可以是1或FlowLayout.CENTER：居中对齐
//align可以是2或FlowLayout.RIGHT：右对齐
//align可以是3或FlowLayout.LEFT：左对齐
FlowLayout(int align)
//用于创建一个即指定对齐方式又指定组件间间隔的对象
FlowLayout(int align,int hgap,int vgap)

package 测试;
import java.awt.*;
import javax.swing.*;
public class test extends JApplet
{
	//获得顶级容器的内容面板
	Container cp=getContentPane();
	//设定按钮对象
	JButton button[]=new JButton[3]; 
	public void init()
	{
		//设定容器的布局为FlowLayout策略
		cp.setLayout(new FlowLayout());
		button[0]=new JButton("忽视");
		button[1]=new JButton("打开");
		button[2]=new JButton("关闭");
		//foreach结构的循环
		for(JButton o:button)
		{
			cp.add(o);
		}	
	}
}

CardLayout:

CardLayout的布局方式是将每个组件看成一张卡片，向扑克那样堆叠起来，每次显示在屏幕上的只能是最上面的一个组件。

CardLayout类的常用成员方法:

//显示container中的第一个对象
first(Container container)  
//显示container中的最后一个对象
last(Container container)
//显示下一个对象
next(Container container)
//显示上一个对象
previous(Container container)

构造方法：

//使用默认（间隔为0）方式创建一个CardLayout()类对象
CardLayout();
//使用hgap指定的水平间隔和vgap指定的垂直间隔创建一个CardLayout()类对象
CardLayout(int hgap,int vgap);

package 测试;
import java.awt.*;
import javax.swing.*;
public class test extends JApplet
{
	//获得顶级容器的内容面板
	Container cp=getContentPane();
	//设定按钮对象
	JButton bt1=new JButton("按钮A");
	JButton bt2=new JButton("按钮B");
	JButton bt3=new JButton("按钮C");
	//设置CardLayout布局
	CardLayout card=new CardLayout(20,20);
	public void init()
	{
		//以此为布局管理
		cp.setLayout(card);
		//添加组件（给组件分配字符串名字从而方便以后调用）
		cp.add("a",bt1);
		cp.add("b",bt2);
		cp.add("c",bt3);
		//展示下一个
		card.next(cp);
	}
}

GridLayout:

grid:网格、方格

GridLayout把容器分成大小相等的矩形，一个矩形中放置一个组件，而每个组件按添加的顺序从左到右、从上到下地占据这些网格。

构造方法：

//按默认（一行一列）创建一个布局
GridLayout( )
//创建一个具有rows行，cols列的布局
GridLayout(int rows,int cols)
//按照指定行数列数和水平/垂直间隔创建的布局
GridLayout(int rows,int cols,int hgap,int vgap)

package 测试;
import java.awt.*;
import javax.swing.*;
public class test extends JApplet
{
	//获得顶级容器的内容面板
	Container cp=getContentPane();
	//设定按钮对象
	JButton bt1=new JButton("按钮A");
	JButton bt2=new JButton("按钮B");
	//设置GridLayout布局
	GridLayout grid=new GridLayout(2,2,20,30);
	public void init()
	{
		//以此为布局管理
		cp.setLayout(grid);
		//添加组件
		cp.add(bt1);
		cp.add(bt2);
		cp.add(new JButton("按钮C"));
		cp.add(new JButton("按钮D"));
	}
}

BoxLayout:

BoxLayout是Swing所提供的布局管理器

BoxLayout只有两种排列方式，水平排列（X_AXIS），垂直排列（Y——AXIS）。BoxLayout类和Box类相结合，可以提供多样化的布局。通常的做法是使用若干个Box容器（默认布局：BoxLayout）

BoxLayout构造方法：

//target是容器对象，axis指明在target中组件的排列方式
//axis可以取BoxLayout.X_AXIS或者BoxLayout.Y_AXIS
BoxLayout(Container container,int axis)

Box构造方法：

//axis指明Box中的组件按水平还是垂直排列
//axis可以取BoxLayout.X_AXIS或者BoxLayout.Y_AXIS
Box(int axis)

BoxLayout类和Box类常用成员方法

//返回容器沿X轴的对齐方式
float getLayoutAlignmentX(Container con)
//返回容器沿Y轴的对齐方式
float getLayoutAlignmentY(Container con)
//创建水平排列的Box组件
static Box createHorizontalBox()
//创建垂直排列的Box组件
static Box createVerticalBox()
//创建可向水平与垂直方向延伸的Glue组件
Component createGlue()
//创建一个水平Glue组件
Component createHorizontalGlue()
//创建一个垂直Glue组件
Component createVerticalGlue()
//创建一个水平的Strut组件
Component createHorizontalStrut(int width)
//创建一个垂直的Strut组件
Component createVerticalStrut(int height)
//创建Rigid组件
Component createRigidArea(Dimension d)
//取得与此Box相关联的AccessibleContext
AccessibleContext getAccessibleContext()
//抛出AWTError，Box只使用BoxLayout布局
void setLayout(LayoutManager l)

为方便布局管理，Box类还提供了4种透明组件Glue、Strut、Rigid、Filler。
可以将这些透明组件插入其它组件的中间，使各个组件产生分开的效果，效果如下：

Glue：将Glue两边的组件挤到容器的两端
Strut：将Strut两端的组件按水平或垂直方向指定的大小分开
Rigid：可以设置二维的限制，将组件按水平或垂直方向指定的大小分开
Filler：不仅可以设置二维的限制，将组件按水平或垂直方向指定的大小分开，而且还可以设置最大、较佳、最小的长宽大小

代码示例：

使用BoxLayout

package 测试;
import java.awt.Component;
import java.awt.Container;
import javax.swing.BoxLayout;
import javax.swing.JApplet;
import javax.swing.JButton;;
public class test extends JApplet
{
	public void addComponentsToPane(Container pane)
	{
		//pane容器中的组件按照竖直排列
		pane.setLayout(new BoxLayout(pane,BoxLayout.Y_AXIS));
		addAButton("Button 1",pane);
		addAButton("Long-Name Button 4",pane);
		addAButton("5",pane);		
	}
	private void addAButton(String text,Container container)
	{
		JButton button=new JButton(text);
		//设置按钮在面板中横向居中
		button.setAlignmentX(Component.CENTER_ALIGNMENT);
		container.add(button);
	}
	@Override //要求系统帮助检查重载方法书写的正确性
	public void init()
	{
		addComponentsToPane(getContentPane());
	}
}

利用Box：

package 测试;
//导入BorderLayout只是为了东南西北的方位
import java.awt.BorderLayout;  
import javax.swing.Box;
import java.awt.Container;
import javax.swing.JButton;
import java.awt.Dimension;
import javax.swing.JApplet;;
public class test extends JApplet
{
	//按钮组件
	JButton b1=new JButton("Top");
	JButton b2=new JButton("Middle1");
	JButton b3=new JButton("Bottom");
	JButton b4=new JButton("Left");
	JButton b5=new JButton("Right");
	@Override   //要求系统帮助检查重载方法书写的正确性
	public void init()
	{
		//得到内容面板
		Container cp=getContentPane();
		//按垂直排列
		Box vBox=Box.createVerticalBox();
		//设置按钮的最大长度
		b1.setMaximumSize(new Dimension(200,200));
		//加入垂直透明组件Strut，间隔为10像素
		vBox.add(Box.createVerticalStrut(10));
		//将组件加入Box面板中
		vBox.add(b1);
		vBox.add(Box.createVerticalStrut(10));
		vBox.add(b2);
		vBox.add(b3);
		cp.add(vBox,BorderLayout.NORTH);
		//按水平排列
		Box hBox=Box.createHorizontalBox();
		hBox.add(b4);
		//加入透明组件Glue，组件挤到两边
		hBox.add(Box.createHorizontalGlue());
		hBox.add(b5);
		cp.add(hBox,BorderLayout.SOUTH);
	}
}

窗口与面板容器：

JFrame容器：

JFrame是Java Application程序的图形用户界面容器，是带有标题和边框的顶层窗口。窗体的默认布局为BorderLayout。JFrame类包含支持任何通用窗口特性的基本功能。JFrame容器作为顶层容器，不能被其他容器所包含，但可以被其他容器创建并弹出成为独立的容器。JFrame类的继承关系如下：

java.lang.Object⇒ java.awt.Component⇒java.awt.Container ⇒java.awt.Window⇒java.awt.Frame ⇒javax.swing.JFrame

使用JFrame容器时需要注意以下几点：

可以使用JFrame()方法创建一个无标签的JFrame对象，也可以使用JFrame(Stringtitle)方法创建一个标签为title的JFrame对象，还可以使用专门的方法getTitle()和setTitle(String)来获取或指定JFrame标题
使用setSize(int x,int y)方法设置JFrame容器的大小
创建的JFrame是不可见的，若要其可见，则需要使用给出实际参数为true的setVisible(boolean)方法
向JFrame添加组件时，必须先去的ContentPane，然后再使用add()方法把组件加入到此ContentPane中，而不像AWT中的Frame那样直接调用add()方法
JFrame类可以引发WindowsEvent类代表的所有其中窗口事件
每个JFrame在其右上角都有三个控制图标，分别为最小化、最大化、关闭窗口。其中JFrame可自动完成窗口的最小化和最大化操作，而关闭窗口的操作不能通过点击关闭图标来实现，但可以使用三个方法（都是用JFrame的System.exit(0)）之一来关闭窗口：1-设置一个按钮，当用户点击此按钮时关闭窗口。2-用WINDOWS_CLOSEING事件作出响应，关闭窗口。3-使用菜单命令

示例：

package 测试;
import java.awt.*;
import javax.swing.*;
public class test
{
	public test()
	{
		JFrame f=new JFrame("JFrame容器");
		//设置用户在此窗体上发起“close”时默认执行的操作
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		JLabel lb=new JLabel("这是JFrame");
		lb.setPreferredSize(new Dimension(17,100));
		//添加标签对象到返回此窗体的ContentPane对象中
		f.getContentPane().add(lb,BorderLayout.CENTER);
		f.pack();             //调整窗口
		f.setVisible(true);    //显示这个JFrame
	}
	public static void main(String[] args)
	{
		test t=new test();
	}
}

JPanel：

Panel和JPanel是面板（将所需组件先排列在面板中，在将其作为一个整体嵌入窗口）。Panel和JPanel就是这样一类被称为面板的容器，他们是无边框，不能被移动、放大、缩小或关闭的容器。AWT中的Panel与Swing中的JPanel的区别是：JPanel支持双缓冲（Double Buffering）（学过MFC的朋友应该知道这玩意）功能，在处理动画上较少发生画面闪烁的情况。JPanel类的继承关系如下：

java.lang.Object⇒ java.awt.Component⇒java.awt.Container⇒javax.swing.JComponent ⇒javax.swing.JPanel

不能把JPanel作为一个图形界面程序最底层的容器，也不能指明JPanel的大小。JPanel总是作为一个容器组件被加入到JFrame、JApplet等其他容器中，当然，JPanel也可以加入到JPanel容器中。JPanel的大小由包含在它里边的组件、包含它的那个容器的布局策略，以及该容器中的其他组件所决定

构造方法	内容说明
JPanel()	创建具有双缓冲和流布局的新JPanel
JPanel(boolean isDoubleBuffered)	创建具有FlowLayout和指定缓冲策略的新Panel
JPanel(LayoutManager layout)	创建具有指定布局管理器的新缓冲JPanel
JPanel(LayoutManager layout,boolean isDoubleBuffered)	创建具有指定布局管理器和缓冲策略的新JPanel

建立一个JPanel时，首先使用表中所列JPanel类构造方法创建JPanel类对象，然后调用setLayout()方法设置组件在面板上面的排列方式，最后将所需组件加入面板

示例程序：

package 测试;
import java.awt.*;
import javax.swing.*;
public class test extends JFrame
{
	JLabel[] lb=new JLabel[3];   //创建标签按钮
	JPanel pa1=new JPanel();   //创建面板对象
	//GridLayout：创建一个具有1行2列的网格布局
	JPanel pa2=new JPanel(new GridLayout(1,2));
	public test()
	{
		//设置组件在面板上的排列方式（2行1列的网格）
		setLayout(new GridLayout(2,1));
		for(int i=0;i<lb.length;i++)  //设置每个标签的属性
		{
			//构造每个标签（名字为标签加序号）
			lb[i]=new JLabel("标签"+(i+1),JLabel.CENTER);
			//设置标签颜色
			lb[i].setBackground(Color.yellow);
			//设置标签边框
			lb[i].setBorder(BorderFactory.createEtchedBorder()); 
			//让组件变得不透明，使标签的颜色显示出来
			lb[i].setOpaque(true);
		}
		pa1.add(lb[0]);
		pa2.add(lb[1],BorderLayout.NORTH);
		pa2.add(lb[2],BorderLayout.SOUTH);
		//test继承自JFrame，所以可以直接调用JFrame的方法
		add(pa1);          //将面板添加到某对象中
		add(pa2);
		setTitle("JPanel示例");
		pack();           //调整窗口
		setVisible(true);   //显示这个JFrame
	}
	public static void main(String[] arg)
	{
		test t=new test();
	}
}

事件响应原理：

委托事件模型：

Java采用委托事件模型来处理事件。委托事件模型由事件源、事件（Event）及事件监听器（Listener）组成。委托事件模型的特点是将事件的处理委托给事件监听器，而不是组件本身

事件源与事件

如果在一个图形用户界面上，点击按钮后改变了界面上的内容，这就意味着这个界面上的按钮组件可以触发一个事件，它就是事件源（能够接受外部事件的源体），是事件的生产者。事件源会在事件产生时，将与该事件及事件源相关信息封装在事件中。当事件被触发时，事件将被一个或多个“事件监听器”接收，事件监听器负责处理事件。

事件监听器

事件监听器是实现事件监听的接口类。事件监听器不断地监听事件源的动作，当事件源产生一个事件，监听器接收到事件源的通知后，就调用特点的方法执行指定的动作。

委托事件模型的实现步骤

委托事件模型的实现步骤：建立事件源对象⇒为事件源对象选择合适的时间监听器⇒为监听器添加适当的处理方法⇒为监听器与事件源建立联系

java.awt.Event事件类：

Java中的事件类可分为高级事件类和低级事件类。

低级事件是基于组件和容器的时间。例如ComponentEvent（组件时间）和ContainerEvent（容器事件）。

高级事件是基于语义的事件，它可以不和特定的动作相关联，而是依赖于触发此事件的类。例如ActionEvent（动作时间）、AdjustmentEvent（调整事件）、ItemEvent（选择事件）和TextEvent（文本事件）。

事件与监听器的关系：

事件与组件：

JLabel组件：

JLabel组件被称为标签，是一个静态组件，也是标准组件中最简单的一个组件。每个标签用一个标签类的对象表示，可以显示一行静态文本。

标签只用来说明信息，不能接受输入，不能产生交互。

JButton与JToggleButton：

JButton与JToggleButton就是按钮，javax.swing.JButton和javax.swing.JToggleButtton都继承自AbstractButton类。

ActionEvent事件及相应：

ActionEvent事件处理程序的结构如下：

将响应动作事件所需要的业务逻辑封装在是实现监听器接口的类中：

Class ClickAction implements ActionListener
{ 
        public void actionPerformed(ActionEvent e)
        {
                 //响应动作事件所需要的业务逻辑
        } 
}

在方法体重可以引用ActionEvent事件的getSource()方法来获取引发事件的对象，也可以引用getActionCommand()来获取对象标签或事先为对象设置的命令名。

创建事件源并注册完成所需业务逻辑的监听器

//创建监听器对象
ActionListener click=new ClickAction();   
//创建按钮对象
JButton btn=new JButton()
//注册监听器对象
btn.addActionListener(click)

这样，当事件发生，注册的监听器对象就可以接收来自事件源的事件

引用监听器的actionPerformed()方法来完成事件的响应

代码示例：

package 测试;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
//声明该类实现ActionListener接口，监听器对象是test类的对象
public class test extends JApplet implements ActionListener
{
	//创建窗口容器对象（获得顶级容器的内容面板）
	Container cp=getContentPane();    
	//创建图标对象
	Icon ro=new ImageIcon(getClass().getResource("/image/G1.gif")); 
	Icon ge=new ImageIcon(getClass().getResource("/image/G2.gif"));
	
	JButton bt=new JButton();   //创建按钮对象
	Icon icon=new ImageIcon(getClass().getResource("/image/G2.gif"));
	JLabel lb=new JLabel("Java",icon,JLabel.CENTER);  //创建标签对象
	public void init()
	{
		//将按钮图标变化的功能打开
		bt.setRolloverEnabled(true);
		bt.setText("OK");
		//将按钮文字放在图标中间
		bt.setHorizontalTextPosition(JLabel.CENTER);
		//设置按钮文字在图标下方
		bt.setVerticalTextPosition(JLabel.BOTTOM);
		//将标签添加到JApplet界面的北部位置上
		cp.add(lb,BorderLayout.NORTH);
		cp.add(bt,BorderLayout.SOUTH);
		//设置鼠标离开按钮的图标
		bt.setIcon(ge);  
		//设置鼠标在按钮上的按钮的图标
		bt.setRolloverIcon(ro);
		//设置鼠标按下按钮的图标
		bt.setPressedIcon(ge);
		//注册监听器对象到事件源（我自身，因为我实现了ActionListener接口）
                //bt是事件源，this为监听器对象
		bt.addActionListener(this);
	}
	
	@Override  //要求系统帮忙检查重载的正确性
	public void actionPerformed(ActionEvent e) {
		//actionPerformed在单机bt时被系统自动调用
		if(e.getSource()==bt)  //动作事件由bt引发
		{
			//修改标签文本
			if("Hello".equals(lb.getText()))
			{
				lb.setText("你好!");
			}
			else
				lb.setText("Hello");
			//修改按钮文本
			if("OK".equals(bt.getText()))
			{
				bt.setText("确定");
			}
			else
				bt.setText("OK");
		}
	}	
}

JCheckBox与JRadioButton组件：

JCheckBox组件被称为复选框（也称检测框），它提供“选中/ON”和“未选中/OFF”两种状态，用户点击某复选框就会改变该复选框原有的状态

JRadioButton组件被称为选项按钮，在Java中JRadioButton组件与JCheckBox组件功能完全一样，只是图形不同，复选框是方形图标，选项按钮为圆形图标

由于目前所使用的软件的RadioButton多为单选按钮，即在同类的一组组件中，用户只能选择其中之一为ON，其余为OFF。Java为了与其他系统保持一致，专门提供了javax.swing.ButtonGroup类。

ItemEvent事件及其响应：

ItemEvent事件是事件源的选项被选定或取消的语义事件（简称选择事件），是在用户已选中选定项或取消选定项时由ItemSelectable（例如：复选框）生成的。

我们用复选框选择触发事件并处理改事件的过程来说明选择事件的响应原理。如果要恢复复选框能够触发ItemEvent事件，应该做下述工作：

首先，建立一组复选框对象，引用复选框的AbstractButton类的addItemListener()方法，将一个ItemListener对象添加到复选框中，即为复选框注册监听器（ItemListener）对象，以接收触发事件。

其次，在程序的监听器itemStateChanged()方法中编写事件的处理程序

示例代码：

package 测试;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class test extends JApplet implements ItemListener,ActionListener
{
	int i1=0,i2=0,i3=0;
	int fonti=10;
	Font font;
	//内容面板
	Container ctp=getContentPane();
	//标签
	JLabel lb=new JLabel("请选择");
	//声明复选框对象
	JCheckBox cb1,cb2,cb3;
	//声明按钮对象
	JRadioButton r1,r2,r3;
	//创建按钮组对象，事件JRadioButton多选一功能
	ButtonGroup bg=new ButtonGroup();
	public void init()
	{
		//设置布局方式为流式布局
		ctp.setLayout(new GridLayout(3,3));
		
		initCheckBox();
		InitRadioButton();
		
		//加载标签到界面上
		ctp.add(lb);
	}
	private void initCheckBox()
	{
		//对复选框的初始化
		//创建复选框
		cb1=new JCheckBox("红色",false);
		//注册监听器（自身）
		cb1.addItemListener(this);
		//添加复选框到界面上
		ctp.add(cb1);
		cb2=new JCheckBox("绿色",false);
		cb2.addItemListener(this);
		ctp.add(cb2);
		cb3=new JCheckBox("蓝色",false);
		cb3.addItemListener(this);
		ctp.add(cb3);
	}
	public void InitRadioButton()
	{
		//对选项按钮的初始化
		//创建选项按钮
		r1=new JRadioButton("10");
		//注册监听器（自身）
		r1.addActionListener(this);		
		//加载按钮到界面上
		ctp.add(r1);
		r2=new JRadioButton("15");
		r2.addActionListener(this);		
		ctp.add(r2);
		r3=new JRadioButton("20");
		r3.addActionListener(this);		
		ctp.add(r3);
		//加载按钮到按钮组
		bg.add(r3);
		bg.add(r1);
		bg.add(r2);
	}
	
	
	@Override  //要求系统帮忙检验重载的正确性
	public void actionPerformed(ActionEvent e) {
		//ActionListener接口中的方法（选项按钮触发这个方法）
		String rbt=e.getActionCommand();
		if("10".equals(rbt))
			fonti=10;
		else if("15".equals(rbt))
			fonti=15;
		else 
			fonti=20;
		
		font=new Font("宋体",Font.BOLD,fonti);
		lb.setFont(font);
		lb.setForeground(new Color(i1,i2,i3));		
	}
	public void itemStateChanged(ItemEvent e) {
		//ItemListener接口中的方法(复选框触发这个方法)
		//触发事件反值给cbx
		JCheckBox cbx=(JCheckBox)e.getItem();
		if("红色".equals(cbx.getText()))
		{
			//红色复选框状态是选中
			if(e.getStateChange()==ItemEvent.SELECTED)
				i1=255;
			else
				i1=0;
		}
		if("绿色".equals(cbx.getText()))
		{
			//红色复选框状态是选中
			if(e.getStateChange()==ItemEvent.SELECTED)
				i2=255;
			else
				i2=0;
		}
		if("蓝色".equals(cbx.getText()))
		{
			//红色复选框状态是选中
			if(e.getStateChange()==ItemEvent.SELECTED)
				i3=255;
			else
				i3=0;
		}
		font=new Font("宋体",Font.BOLD,fonti);
		lb.setFont(font);
		lb.setForeground(new Color(i1,i2,i3));
	}
}

JComboBox组件：

JComboBox是下拉列表框

JComboBox组件能够响应的事件分为选择事件与动作事件，用户选择下拉列表中的选择项时，则激发选择事件，使用ItemListener事件监听器进行处理；若用户在JComboBox上直接输入选择项并回车，则激发动作事件，使用ActionListener事件监听器进行处理

示例：

package 测试;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class test extends JApplet implements ItemListener
{
	//内容面板
	Container ctp=getContentPane();
	JLabel lb1=new JLabel("姓名：");
	JLabel lb2=new JLabel("英语：");
	JLabel lb3=new JLabel("    ");
	String name[]= {"李林","赵欣","张扬","童梅"};
	String score[]= {"80","95","76","74"};
	//创建下拉式列表框对象
	JComboBox cbx=new JComboBox();
	public void init()
	{
		//设置流式布局
		ctp.setLayout(new FlowLayout());
		//添加选项到下拉式列表框对象中
		for(int j=0;j<name.length;j++)
			cbx.addItem(name[j]);
		ctp.add(lb1);
		ctp.add(cbx);
		//注册监听器对象到事件源
		cbx.addItemListener(this);
		ctp.add(lb2);
		ctp.add(lb3);
	}
	@Override
	public void itemStateChanged(ItemEvent e) {
		int c=0;
		//获取所选项给str
		String str=(String)e.getItem();
		for(int i=0;i<name.length;i++)
		{
			if(str.equals(name[i]))
			{
				//用c记录该选项的下标
				c=cbx.getSelectedIndex();
			}
		}
		//获取该学生成绩
		lb3.setText(score[c]);
	}	
}

JList组件：

JList称为组件列表，它将所有选项放入列表框中。如果将JList放入滚动面板（JScrollPane）中，则会出现滚动菜单效果。

JList和JComboBox组件的最大区别是：JComboBox组件一次只能选择一项，而JList组件一次可以选择一项或多项。选择多项时可以是连续区间选择（按住Shift键进行选择），也可以是不连续的选择（按住Ctrl键进行选择）

JList组件的事件处理一般也是分为两种：一种是当用户单机列表框中的某个选项并选中它时，将产生ListSelectionEvent类的选择事件，此事件是swing的时间；另一种是当用户双击列表中某个选项时，则产生MouseEvent类的动作事件

示例

package 测试;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
public class test extends JApplet implements ListSelectionListener
{
	JList lis=null;
	JLabel lb=null;
	String[] s= {"小学","初中","高中","大学","研究生"};
	public void init()
	{
		Container cp=getContentPane();
		cp.setLayout(new BorderLayout());
		lb=new JLabel();
		//直接用数组构造
		lis=new JList(s);
		//设置列表框的可见选项行数为3，
		//选项超过则出现滚动条
		lis.setVisibleRowCount(3);
		lis.setBorder(BorderFactory.createTitledBorder("请选择"));
		//注册监听器到事件源
		lis.addListSelectionListener(this);
		//加入标签
		cp.add(lb,BorderLayout.NORTH);
		//将list的对象放入滚动容器，再将此容器加载到界面上
		cp.add(new JScrollPane(lis),BorderLayout.CENTER);
	}
	@Override
	public void valueChanged(ListSelectionEvent e) {
		int m;
		String str="选择的是：";
		//取得所有选项（被选择）的下标值给index数组
		int[] index=lis.getSelectedIndices();
		for(int i=0;i<index.length;i++)
		{
			//根据取得的下标值，找出相应的数组元素
			m=index[i];
			str=str+s[m]+" ";
		}
		//输出选中项的值
		lb.setText(str);
	}	
}

JTextField与JTextArea组件：

JTextField与JTextArea组件是输入/输出文本信息的主要工具，他们不仅有自己的成员方法，同时还继承了父类JTextComponent类的成员方法。

JTextField：

JTextField被称为文本框，它定义了一个单行条形文本区，只能输入输出一行文本，可以输出任何基于文本的信息，也可以接受用户的输入，按下回车时触发Action事件。

JTextArea：

JTextArea被称为文本域，文本域可以输入输出多行文本

示例：

package 测试;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class test extends JApplet implements ActionListener
{
	Container ctp=getContentPane();
	JLabel lb1=new JLabel("输入文字后按回车：",JLabel.CENTER);
	JLabel lb2=new JLabel("输出结果：",JLabel.CENTER);
	JTextField tf1=new JTextField(10);   //创建文本框对象
	JTextArea tf2=new JTextArea(5,10);   //创建文本区域对象
	
	public void init()
	{
		ctp.setLayout(new FlowLayout());
		ctp.add(lb1);
		ctp.add(tf1);
		ctp.add(lb2);
		ctp.add(tf2);
		tf1.addActionListener(this);
	}
	
	@Override
	public void actionPerformed(ActionEvent e) {
		String str;
		//获取文本框的文本给str（这是JTextComponent类的方法）
		str=tf1.getText();
		//tf2.setText(str)
		//将str添加到文本区域（append是JTextArea类的方法）
		tf2.append(str+"\n");
	}
}

博客：is-hash.com

商业转载请联系作者获得授权，非商业转载请标明出处，谢谢

轻舟在过

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java的基本学习第四部分

承接上面的内容我们来继续学习Java，这一篇主要会讲常用组件GUI设计与高级组件GUI设计常用组件GUI设计♥：布局管理器：Java的GUI界面是由AWT类和Swing类来完成的。在Java中，容器和布局管理是相分离的，容器只负责承载组件，而将布局的管理任务交给专门的布局管理器接口类（Layout Manager）的实现类来完成。当然也可以不用缺省的布局管理...
复制链接

扫一扫