关闭

黑马程序员---GUI图形化界面

295人阅读 评论(0) 收藏 举报
分类:
-----------android培训java培训、java学习型技术博客、期待与您交流!---------


GUI


        Graphical  Vser Interface(图形用户接口)。


        用图形的形式来显示计算机操作界面,这样更方便直观

 

        Java为GUI提供的对象都存在java.Awt和 javax.Swing包中


                java.Awt:AbstractWindow Toolkit(抽象窗口工具包)


                        需要调用本地系统方法实现功能,属重量级控件。

 

                javax.Swing:在Awt的基础上,建立的一套图形化界面系统。


                        其中提供了更多的组件,而且完全由Java实现,增强了一致性,属轻量级控件。

 

         Awt中继承关系图



 

        布局管理器


                布局:容器中的组件的排放方式。

                  

                常见的布局管理器


                        1.   FlowLayout(流式布局管理器)


                                从左到右顺序排列。是Panel默认的布局管理器


                        2.   BorderLayout(边界布局管理器)


                                东南西北中的排列方式。Frame默认的布局管理器。如果只有一个组件,将会覆盖整个窗体。


                        3.   GridLayout(网格布局管理器)


                                规矩的矩阵


                        4.   CardLayout(卡片布局管理器)


                                选项卡


                        5.   GridBagLayout(网格包布局管理器)


                                非规矩的矩阵

 

        创建图形化界面步骤


                1.   创建fame窗体


                        例:Frame  f = new  Frame(“我的窗口”);          //可设置标题,就是窗口的名字


                        创建的窗体是不可见的,下面会学习如何让窗口变得可见。


                2.   对窗体进行基本设置


                        可以用Frame类中的以下几种方法,不是全部方法,只是我会演示的方法


                        a.   void  setSize(int  width , int  height)


                                调整组件大小,宽为width,长为height


                        b.   void  setLocation(int  x  ,  int  y)


                                将组建移动到指定位置。


                        c.   void setBounds(int x  , int y , int width , int heigth)


                                移动组建,并调整其大小。


                        d.   voidsetLayout(LayoutManager  mgr)


                                设置容器的布局管理。参数位置传入布局管理器的对象。


                3.   定义组件


                        例:Button b =new Button(“我的按钮”);       //定义组件对象,可设置组件的名称。


                4.   将组建通过窗体的add方式添加到窗体中。


                        例:f.add(b);    //将刚刚定义的按钮组建添加到窗体中。


                5.   让窗体显示


                        void setVisible(boolean b)                使窗体可见


                        例:f.setVisible(true)

 

                代码示例

/*
创建图形化界面演示代码

步骤
1.创建frame窗体
2.对窗体进行基本设置
3.定义组件
4.将组建通过窗体的add方法添加到窗体中
5.让窗体显示。
*/
import java.awt.*;

class AwtDemo 
{
	public static void main(String[] args) 
	{
		//定义Frame对象,并在参数位置传入窗体名
		Frame f = new Frame("我是一个小窗体");

		//定义窗体大小
		f.setSize(300,200);
		//设置窗体的位置
		f.setLocation(400,500);
		//指定布局管理器
		f.setLayout(new FlowLayout());

		//定义一个按钮组件,并在参数中传入组件名称
		Button b = new Button("按我啊~");

		//将组建添加到窗体中
		f.add(b);

		//让窗体显示
		f.setVisible(true);
	}
}


                        运行结果



      

                  虽然我们创建了这个窗口,但是有一点小小的问题,就是窗体右上角的X点了不能结束,只能是我在DOS命令行中使用ctrl+c 结束程序。


                        窗体现在是无法提供正常使用的。要想让窗体和窗体内的组件可以具备功能,就要使用到我们下面要学习的,事件监听机制。

 

 

      事件监听机制


            事件监听机制的组成


                  事件源(组件)


                  事件(Event)


                  监听器(Listener)


                  事件处理

 

            事件监听机制流程图



           

            事件监听机制特点


                  1.   事件源:就是awt包和swing包中的那些图形界面组件


                  2.   事件:每个事件源都有自己特有的对应事件和共性事件。


                  3.   监听器:将可以触发某一个事件的动作(不只一个动作)都封装在监听器中。


                  以上三者在java中都已定义好,直接获取其对象来用即可。


                  我们要做的事情是对产生的动作进行处理。


                  4.   事件处理


                        现在我们要使用窗口上的X来关闭窗口。但是我刚才试过了,不行。


                        这时可以使用 java.awt.window类中的方法


                              void addWindowListener(WindowLIstener L)              添加指定的窗口监听器,以窗口接收窗口事件。


                        但是呢,这个方法接受的参数类型WindowListener是一个接口类型的参数,创建子类对象只能复写其中所有的方法,


                        但是我们只用到了一个关闭窗口方法。所以这时就要使用WindowAdapter类,它是WindowListener的子类已经实现了该接口。


                        并覆盖了其中所有的方法,那么只要继承WindowAdapter类,并覆盖所需的方法即可。


                        要再定义一个类什么的写继承太麻烦了,所以就用匿名内部类内部类的知识来完成。(WindowAdapter适配器,方便功能使用


                              例:f.addWindowListener(new WindowAdapter()  {


                                            要监听的动作方法;


                                      });

 

                        WindowAdapter中的部分方法展示


                              1.   void  windowClosing(WindowEvent  e)            窗口正处于关闭过程中调用


                              2.   void  windowActivated(WindowEvext  e)           激活窗口时调用。


                              3.   void  windowOpend(WindowEvent  e)             一打开窗口时调用。

                             

                              其中WindowEvent为事件对象。

 

                        理解:这些方法可以用于在操作窗口时执行指定的代码块。


                                   如:windowActivated方法可以用于记录窗口被激活的次数,每次窗口被激活调用次数+1.


                                           windowOpend方法中可以输出语句,输出如何使用窗体的说明等等。

 

                  就用我刚才创建的窗体的例子,我们来使X管用。

/*
事件监听处理方法演示

监听事件源,当用户对事件源做出监听器正在监听的动作后进行处理

在窗体已经建立完的情况下

思路:
给事件源添加监听器
将适配器作为参数传入构造函数中
使用内部类的方式定义事件发生之后的处理方式

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

class AwtDemo2 
{
	public static void main(String[] args) 
	{
		//定义Frame对象,并在参数位置传入窗体名
		Frame f = new Frame("我是一个小窗体");

		//定义窗体大小
		f.setSize(300,200);
		//设置窗体的位置
		f.setLocation(400,500);
		//指定布局管理器
		f.setLayout(new FlowLayout());

		//定义一个按钮组件,并在参数中传入组件名称
		Button b = new Button("按我啊~");
		//将组建添加到窗体中
		f.add(b);

		//为窗体添加监听器,将适配器作为参数传入构造函数中,定义内部类
		f.addWindowListener(new WindowAdapter()
		{
			//复写WindowAdapter类中的方法,创建自己的事件处理方式
			//点X可以关闭窗口,并输出语句
			public void windowClosing(WindowEvent e)
			{
				//输出语句
				System.out.println("我走了再见");
				//程序结束
				System.exit(0);
			}
			
			//激活窗口时显示被激活
			public void windowActivated(WindowEvent e)
			{
				System.out.println("我被你激活了!");
			}
			//窗口一建立就输出信息
			public void windowOpened(WindowEvent e) 
			{
				System.out.println("嗨,小伙伴");
			}
		});
		//让窗体显示
		f.setVisible(true);
	}
}


                        运行结果



                  

                  按钮事件


                        在我们上面做的窗口中还有个按钮,下面我们来学习按钮的事件处理


                        按钮就是事件源, 那么选择哪个监听器呢?


                              通过前一个示例了解到,要想知道哪个组件具备什么样的特有监听器,要去查看该组件对象的功能。


                              在API中我们找到了Buttom类中的方法


                                    void  addActionListener(ActionListener  l)            添加指定的动作监听器,以接收发自此按钮的动作事件。


                              因为addActionListener方法参数ActionListener类中,只有一个void  actionPerformed(ActionEvent  e)方法,


                              它的功能也就是我们需要的,发生操作时调用。所以使用匿名内部类,直接复写这个方法即可即可。


                              (这是少有的没有适配器的接口)

 

                        下面来看代码演示

/*
事件监听小程序

需求
按窗体X关闭窗体
按按钮也退出窗体
*/
import java.awt.*;
import java.awt.event.*;
class  AwtDemo3
{	
	//定义该图形中所需的组件的引用。
	private Frame f;
	private Button but;

	//对象一建立就调用init方法。
	AwtDemo3()
	{
		init();
	}

	public void init()
	{
		//建立窗体对象,并传入字符串作为窗体名
		f = new Frame("我是一个小窗体~");

		//对frame进行基本设置。
		//设置窗体的长宽,还有位置
		f.setBounds(400,200,300,500);
		//设置窗体使用哪个布局
		f.setLayout(new FlowLayout());

		//建立按钮对象,并传入字符串作为按钮上现实的信息
		but = new Button("我是按钮~");

		//将组件添加到窗体中
		f.add(but);

		//加载一下窗体上事件。
		myEvent();

		//显示窗体;
		f.setVisible(true);

	}
	//设置窗体事件方法。
	private void myEvent()
	{
		//给窗体添加监听器,WindowAdapter是窗口监听器的子类
		f.addWindowListener(new WindowAdapter()
		{
			//窗体一建立就输出信息
			public void windowOpened(WindowEvent e) 
			{
				System.out.println("我来啦~");
			}
			//窗体关闭时输出信息,并结束程序
			public void windowClosing(WindowEvent e)
			{
				System.out.println("我走了");
				System.exit(0);
			}
		});

		//给按钮添加监听器
		but.addActionListener(new ActionListener()
		{
			//按按钮 退出窗体
			public void actionPerformed(ActionEvent e)
			{
				System.out.println("退出,按钮干的");
				System.exit(0);
			}
		});
	}
	public static void main(String[] args) 
	{
		new AwtDemo3();
	}	
}


                              运行结果



 

                  鼠标事件


                        鼠标有三个监听器


                              void  addMouseListener(MouseListener  l)


                                    添加指定的鼠标侦听器,以接收发自此组件的鼠标事件。


                              void  addMouseMotionListener(MouseMotionListener  l)


                                    添加指定的鼠标移动侦听器,以接收发自此组件的鼠标移动事件。


                              void  addMouseWheelListener(MouseWheelListener  l)


                                    添加指定的鼠标滚轮侦听器,以接收发自此组件的鼠标滚轮事件。

 

                        当我们为按钮设定鼠标监听器之后要复写事件处理方法,传入的参数是事件对象。


                              事件对象中也有方法,可以调用。如:我们如果给鼠标添加第一个监视器,复写方法


                                    void  mouseClicked(MouseEvent   e)             鼠标按键在组件上单击(按下并释放)时调用。


                              可以在按钮被鼠标点的时候调用此方法,来完成事件处理。其中参数MouseEvent对象中还有方法可以供我们使用。


                              如int getClickCount() 返回与此事件关联的鼠标单击次数。返回我点了几次按钮。


                              所以想要通过此事件做更多的事情,要去事件对象中寻找。

 

                  注意:按钮的自己被按事件和鼠标去点击按钮时间,鼠标事件会先执行。

 

                  键盘事件

            

                        void  addKeyListener(KeyListener  l)


                              添加指定的按键侦听器,以接收发自此组件的按键事件。

 

                        同样的,和鼠标监听一样,想要使用特殊的方法就去找事件对象中的方法。

 

                  练习

/*
图形化界面练习

需求
输入一个目录,列出目录下的所有文件,如果传入的目录错误,则出现弹框提示

思路
1.创建窗体
2.添加组件,文本框,文本区,按钮
3.创建弹窗,指定它的所有者是哪个窗体,并起名字
4.添加组件,标签,按钮
5.给窗体文本框添加监听器,使输完数据按回车时可以展示出目录中的文件
6.给窗体按钮添加监听器,使一按按钮就可以展示目录中文件
7.给窗体添加监听器,一按X就退出
8.给弹窗的窗体和按钮添加监听器,使一按按钮或者按X,弹窗就消失
9.使窗体显示。
10.获取目录下所有文件,如果传入的目录错误,则把错误信息显示在弹窗上,并使弹窗显示

这个是个挺长的程序啊 大家准备好,注释我就不写那么详细了,简单的就不写啦~
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;

class  WindowDemo
{
	//创建要使用的组件的引用
	//窗口的
	private	Frame f;
	private TextField tf;
	private Button b1;
	private TextArea ta;

	//对话框的
	private Dialog dia;
	private Label l;
	private Button b2;
	
	//对象一建立就调用init方法
	WindowDemo()
	{
		init();
	}

	public void init()
	{
		//建立窗体对象,设置属性,添加组件
		f = new Frame("我是一个可以列出所有文件的窗体");
		f.setBounds(300,100,600,500);
		f.setLayout(new FlowLayout());
		tf = new TextField(60);
		b1 = new Button("转到");
		ta = new TextArea(25,70);
		f.add(tf);
		f.add(b1);
		f.add(ta);

		//建立对话框属相,设置属性,添加组件
		dia = new Dialog(f,"看我看我",true);
		dia.setBounds(400,200,240,150);
		dia.setLayout(new FlowLayout());
		l = new Label();
		b2 = new Button("知道啦");
		dia.add(l);
		dia.add(b2);

		//调用添加监听器方法
		myEvent();

		//使窗体显示
		f.setVisible(true);	
	}
	//添加监听器方法
	private void  myEvent()
	{
		//先给对话框添加监视器,使按X和按按钮都消失
		b2.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				dia.setVisible(false);
			}
		});
		dia.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				dia.setVisible(false);
			}
		});
		//给文本框添加监听器
		tf.addKeyListener(new KeyAdapter()
		{
			//在文本框内用键盘输入信息时
			public void keyPressed(KeyEvent e)
			{
				//如果按了ender键,也就是回车键
				if(e.getKeyCode()==KeyEvent.VK_ENTER)
				//调用展示目录内所有文件的方法
				showDir();
			}
		});

		//给按钮添加监听器
		b1.addActionListener(new ActionListener()
		{
			//如果按钮被按了
			public void actionPerformed(ActionEvent e)
			{
				//就调用展示目录内所有文件的方法
				showDir();
				
			}
		});
			
		//给窗体添加监听器
		f.addWindowListener(new WindowAdapter()
		{
			//窗体被按X
			public void windowClosing(WindowEvent e)
			{
				//程序退出
				System.exit(0);	
			}
		});
	}

	//展示目录内所有文件的方法
	private void showDir()
	{
		//获取文本框中输入的信息,也就是目录
		String dirPath = tf.getText();
		//将目录封装成对象
		File dir = new File(dirPath);
		//如果这个目录是一个文件或者是一个文件夹
		if(dir.exists() && dir.isDirectory())
		{
			//则先往把文本区清空
			ta.setText("");
			//获取文件夹中所有文件或文件夹名称的数组
			String[] names = dir.list();
			//遍历数组
			for(String name : names)
			{
				//将名称添加到文本区中
				ta.append(name+"\r\n");
			}
		}
		//如果输入的数据不是目录也不是文件
		else
		{
			//定义一个要输出的字符串
			String info = "您输入的信息:"+dirPath+"有误。查查再输入";
			//添加到对话框的标签中
			l.setText(info);
			//使对话框显示
			dia.setVisible(true);
		}
	}

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


                        运行结果





      

      菜单


            菜单的继承关系



                  Menu:菜单,继承MenuItem;有右三角的图标存在,可添加Menu和MenuItem


                  MenuBar:菜单栏,可添加菜单和菜单条目。一般先创建菜单栏,再创建菜单。


                  MenuItem:菜单条目,也称菜单项,无右三角的图标存在,是最终的菜单项。


            菜单的事件处理和组件一样,可以对类型为MenuItem和Menu的对象事件源添加活动监听ActionListener,并进行相关的事件处理。


                  通过setMenuBar()方法,将菜单添加到Frame中。

        

            打开文件


                  要用到Dialog对话框的子类FileDialog


                        构造函数


                              FileDialog(Frame parent  , String  title ,  int  made)          


                                    made为对话模式,可以是FileDialog.LOAD打开。FileDialog.SAVE保存。不写默认为LOAD。

 

            结合菜单,演示代码。

package myPack
/*
建立菜单,并通过菜单打开文件。

我有在上面创建一个包,为了接下来的jar包调用用的,稍安勿躁等会儿讲~
*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class MyMenuTest
{
	//建立组建的引用
	private Frame f;
	private MenuBar bar;
	private TextArea ta;
	private Menu fileMenu;
	private MenuItem openItem,saveItem,closeItem;
	//打开和保存文件用的组件
	private FileDialog openDia,saveDia;
	//File对象的引用
	private File file;
	MyMenuTest()
	{
		init();
	}
	public void init()
	{
		//建立窗体并设置属性
		f = new Frame("小窗口");
		f.setBounds(300,100,650,600);
		//建立菜单栏
		bar = new MenuBar();
		//建立文本框,用于展示打开的文件
		ta = new TextArea();
		//建立文件菜单
		fileMenu = new Menu("文件");
		//建立打开,保存,退出三个菜单项
		openItem = new MenuItem("打开");
		saveItem = new MenuItem("保存");
		closeItem = new MenuItem("退出");
		//把三个菜单项添加到文件菜单中
		fileMenu.add(openItem);
		fileMenu.add(saveItem);
		fileMenu.add(closeItem);
		//将文件菜单添加到菜单栏中
		bar.add(fileMenu);
		//将菜单栏组件添加到窗体中
		f.setMenuBar(bar);
		//打开文件和保存文件组件,属于f窗体
		openDia = new FileDialog(f,"我要打开",FileDialog.LOAD);
		saveDia = new FileDialog(f,"我要保存",FileDialog.SAVE);
		//在窗体中添加文本框组件
		f.add(ta);
		//设置我的事件
		myEvent();
		//使窗体显示
		f.setVisible(true);
	}
	//设置事件方法
	private void myEvent()
	{
		//给保存菜单项添加监听器
		saveItem.addActionListener(new ActionListener()
		{
			//当保存菜单项被点了
			public void actionPerformed(ActionEvent e)
			{
				//判断file指向的对象是否存在
				if(file==null)
				{
					//显示保存组件
					saveDia.setVisible(true);
					//获取此文件对话框的目录
					String dirPath = saveDia.getDirectory();
					//获取此文件对话框的选定文件。
					String fileName = saveDia.getFile();
					if(dirPath==null || fileName==null)
						return ;
					//将获取的目录和文件名封装成对象
					file = new File(dirPath,fileName);
				}
				//异常处理
				try
				{
					//写入文件
					BufferedWriter bufw  = new BufferedWriter(new FileWriter(file));
					//获取文本框中的文字
					String text = ta.getText();
					//将文字写入输出流中
					bufw.write(text);
					bufw.flush();
					bufw.close();
				}
				catch (IOException ex)
				{
					throw new RuntimeException();
				}
				
			}
		});

		//给打开菜单项添加监视器
		openItem.addActionListener(new ActionListener()
		{
			//当打开菜单项被点的时候
			public void actionPerformed(ActionEvent e)
			{
				//打开文件组件显示
				openDia.setVisible(true);
				//获取被选中文件的目录
				String dirPath = openDia.getDirectory();
				//获取被选中文件的文件名
				String fileName = openDia.getFile();
				if(dirPath==null || fileName==null)
					return ;
				//清空文本区
				ta.setText("");
				//将获取的目录和文件名封装成对象
				file = new File(dirPath,fileName);

				try
				{
					//创建输入流
					BufferedReader bufr = new BufferedReader(new FileReader(file));
					//读取文件中的内容
					String line = null;

					while((line=bufr.readLine())!=null)
					{
						ta.append(line+"\r\n");
					}

					bufr.close();
				}
				catch (IOException ex)
				{
					throw new RuntimeException("读取失败");
				}


			}
		});
		//给关闭菜单项添加监视器
		closeItem.addActionListener(new ActionListener()
		{
			//当关闭菜单项被点
			public void actionPerformed(ActionEvent e)
			{
				//程序结束
				System.exit(0);
			}
		});
		//窗体被点X程序结束
		f.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				System.exit(0);	
			}
		});
	}
	public static void main(String[] args) 
	{
		new MyMenuTest();
	}
}

                            运行结果


 


Jar包


      既然是图形化界面,就需要通过图形化界面的形式运行程序,而不是是用Dos命令行执行,


            那么如何通过双击程序就执行程序呢?这就需要将程序的class文件打包。


      步骤如下:


            1.   首先要在java文件中导入一个包,没有则需创建一个包,如package mypack;


            2.   生成包:通过编译javac -d e:\myclass MyMenuTest.java,此时则在e盘下的myclass文件夹下生成了所有的.class文件


            3.   在此目录下新建一个文件,如1.txt或者其他任意名称任意扩展名的文件都可,


                  然后在其中编辑固定的格式:“Main-Class: mymenu.MenuDemo”,只写引号中的内容。需要在冒号后有一个空格,在文件末尾要回车。


            4.   编译:jar -cvfm my.jar 1.txt mypack即可。如果想添加其他信息,则直接编译jar即可得出相应的命令


            5.   此时双击即可执行。

 

 

 



谢谢大家观看~!

-----------android培训java培训、java学习型技术博客、期待与您交流!---------
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:5856次
    • 积分:218
    • 等级:
    • 排名:千里之外
    • 原创:17篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档