java编程思想 --22图形化用户页面

Jcreator使用初步
Jcreator是一个小巧灵活的Java开发工具，它可将Java的程序的编写、编译、运行和调试集成进自身的环境中直接进行开发，且无需进行环境变量的设定。我们可以直接在JCreator中编辑Java源文件，选择相应的菜单和点击对应的按钮就可以完成Java程序的编译、运行等工作，十分方便
由于Jcreator集成了编辑源文件、编译、运行调试为一体，所以又被称为IDE(Integration Developer Environment,集成开发环境),其他的具有类似特点的开发工具也被称为IDE
 
         一、Jcreator的下载：
 
Jcreator pro 5.0英文破解版
http://download.csdn.net/detail/liujun13579/4430786
 
jcreator 4.5英文破解版（含注册机）
http://download.csdn.net/detail/liujun13579/4430782
 
JCreator Pro 4.5汉化破解版
http://download.csdn.net/detail/liujun13579/4431493
也是在csdn看到的，不过这哥们要1分，呵呵，我就重新发布一下，免费了！
 
JCreator Pro V4.00.028Java编程初学者的IDE工具绿色汉化特别版
http://115.com/file/dpaf3zu3#JCreator Pro 4 汉化绿色版.rar
绿色版呢，就是方便你携带的，解压就可以用了，携带方便！
        
二、Jcreator文件简介
Jcreator的工程（project）和工作空间workspace
n Jcreator利用工程(Project)管理相应的文件，一个工程由多个Java源文件和其他一些文件组成，Jcreator中工程文件的扩展名为jcp
n Jcreator的工作空间(Workspace)用来管理工程，一个工作空间中可以包含多个工程，Jcreator中工作空间文件的扩展名为jcw
n Jcreator规定，一个工程必须包含在一个工作空间中。所以，当我们创建一个工程时，Jcreator会自动给我们创建一个工作空间已包含当前工程。JCreator在同一时刻只容许打开一个工作空间
 
Java文件、project和workspace之间的关系
 
         三、Jcreator界面
         1、开始界面：可以快速新建项目，打开近期项目，对程序进行相关操作
 
         2、打开项目窗口

 
（1）文件视图
n  文件视图用来显示工程中的所有文件，并且可以显示当前的工程名称和工程所在的工作空间的名称
n  一个工作空间中可以包含多个工程，但只能有一个活动工程。活动工程是指当前起作用的工程。双击工作空间中的一个工程名字将使得该工程成为活动工程，活动工程的名字显示为黑体，而非活动工程显示为普通字体
（2）代码视图      
n  代码视图用来编辑工程文件的源代码。在文件视图中双击某个文件名称，即可在代码视图中对该文件进行编辑Jcreator提供了代码帮助的功能。即如果输入相应的方法或变量，代码视图可提供该方法或变量的动态提示。如果代码提示不出现，可能的原因有两条：
=  JDK及相关类库文件没有正确设置，请参看设置JDK一节
=  书写的代码有错误
 
（3）类视图 
n 类视图显示了当前显示在代码视图中Java源文件的类的层次和类中的方法
n 双击某一方法将直接在代码视图中定位到该方法的定义处
 
（4）包视图
         包视图可以看出相关源文件所属的包，以便编程时引用包。
 
（5）编译视图      
编译视图显示的信息实际就是Dos命令提示符中执行javac命令后的显示信息。
 
（6）运行视图
运行视图显示的信息就是Dos命令提示符中执行java命令后的显示信息，即程序的执行结果。
 
 
四、Jcreator的配置
在Jcreator 5.0版本中，不需要像EditPlus中那样对编译命令和执行命令进行配置，Jcreator会自动调用相关的操作完成编译和运行java程序，这一点比EditPlus要方便。
如果升级的JDK，或者重新安装了JDK，Jcreator会自动将相关的版本信息添加的程序的配置中，以确保程序的正确运行。
可以通过“配置（Configuration）→选项（options）”打开Jcreator软件编程配置的对话框，如下图：

         从该对话框中可以对相应的编译程序进行一定的配置，上图中就是更改Jcreator中代码文字的大小设置。

实例1：一个空的java窗口
// JFrameDemo1.java
import javax.swing.*;     //使用Swing类，必须引入Swing包
public class JFrameDemo1{
  public staticvoid main( String args[]) {
         //定义一个窗体对象f，窗体名称为"一个简单窗口"        
         Jframe  f = new JFrame("一个简单窗口");
         //设置窗体左上角与显示屏左上角的坐标，     
         f.setLocation(300,300);           //离显示屏上边缘300像素，里显示屏左边缘300像素
         f.setSize(300,200);            //设置窗体的大小为300*200像素大小
         f.setResizable(false);       //设置窗体是否可以调整大小，参数为布尔值
         //设置窗体可见，没有该语句，窗体将不可见，此语句必须有，否则没有界面就没有如何意义了
f.setVisible( true);   
//用户单击窗口的关闭按钮时程序执行的操作
         f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);
 }
}
 
程序运行结果生成一个窗体。
可以根据程序代码的注释，依次修改相应的方法参数查看效果。

setDefaultCloseOperation(int operation)：设置用户在此窗体上发起 "close" 时默认执行的操作。方法中的参数解释如下：
 为“0”或DO_NOTHING_ON_CLOSE：
（在 WindowConstants 中定义）：不执行任何操作；要求程序在已注册的WindowListener 对象的 windowClosing 方法中处理该操作。
比如实例程序代码中更改为f.setDefaultCloseOperation(f. DO_NOTHING_ON_CLOSE);或者f.setDefaultCloseOperation(0),然后查看效果，可以发现窗口无法关闭，下面是相同测试方法，不再解释了。

 为“1”或HIDE_ON_CLOSE
调用任意已注册的 WindowListener 对象后自动隐藏该窗体。此时没有关闭程序，只是将程序界面隐藏了。可以打开任务管理器，可以看到一个叫“java.exe”的进程（如果调试运行了多个java程序，则会看到多个“java.exe”的进程），如果此时用EditPlus测试程序，会发现当单击窗口的关闭按钮关闭窗口后，却无法再次对程序进行调试，因为程序线程没有关闭，在任务管理器中关闭java.exe（如果有多个“java.exe”的进程，则先都关闭掉，再来测试该问题）基础后，EditPlus才可以重新编译改程序。

为“2”或DISPOSE_ON_CLOSE
调用任意已注册 WindowListener 的对象后自动隐藏并释放该窗体。但继续运行应用程序，释放了窗体中占用的资源。
 为“3”EXIT_ON_CLOSE（在 JFrame 中定义）：使用 System exit 方法退出应用程序。仅在应用程序中使用。结束了应用程序。

默认情况下，该值被设置为 HIDE_ON_CLOSE。
当注释掉实例中的f.setDefaultCloseOperation(f.EXIT_ON_CLOSE);语句时，起到的效果和f.setDefaultCloseOperation(f. HIDE_ON_CLOSE); 或者f.setDefaultCloseOperation(1);一样。


      上一篇讲解了Jframe顶层容器，例子中生成了一个空的窗体，在实际编程过程中，一般很少将文本框、按钮等组件直接放在顶层容器中进行布局，大多数时候是通过布局管理器结合中间容器对组件进行布局设置。
 
1、  将组件添加到JFrame中
方式之一：
frame.getContentPane().add(childComponent)
用getContentPane()方法获得JFrame的内容面板，再对其加入组件，一般只使用该方式添加组件。
 
向JFrame中添加组件的两种方式之二：
把组件添加到Jpanel之类的中间容器中，用setContentPane()方法把该容器置为JFrame的内容面板：
    Jpanel contentPane=new Jpanel( );
      ……//把其它组件添加到Jpanel中;
frame.setContentPane(contentPane);
 
注意：用setContentPane（）方法不允许设置窗体布局，其只显示最后添加的组件，且该组件将布满整个窗口，而不管原先组件的大小设置，相当于只允许添加一次组件作为JFrame的内容面板。所以一般不实用该方法进行添加组件（可能是我不知道吧）。
 
2、  JPanel的使用

 
         JPanel是java图形化界面中最常使用的容器。
实例：在窗体中添加一个蓝色的面板
// PanelDemo.java
import javax.swing.*;
import java.awt.*;  //引入AWT包，因为要使用到颜色类
class PanelDemo {
         public static void main(String[] args)throws Exception
         {   JFrame f=new JFrame("第一个Java窗口");                   
f.setSize(300,200);         
              f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);         
                f.setResizable(false);
                f.setLocationRelativeTo(null) ;
                   f.setLayout(null);  //设置窗体布局为空布局
                JPanel p=new JPanel();             //实例化一个面板
                   //设置面板背景色为蓝色，如果不引入AWT包，程序将出错，可以试试看
                p.setBackground(Color.BLUE);       
                p.setSize(100,100);          //设置面板对象大小
                f.getContentPane().add(p);     //将面板添加到窗体中
                   //如果使用下面添加面板的方法，面板将布满整个窗口，可以试试看
                   //f. setContentPane(p);
          }
}
 
 
中间容器可以嵌套中间容器
 
实例2：面板的嵌套
import java.awt.*;
import javax.swing.*;
class  TwoPanel extends JFrame {
  public TwoPanel( String title){
  super(title);
}
 public static void main(String args[]) {
   TwoPanel fr=new TwoPanel("Two Panel测试");
   JPanel pan1 = new JPanel();
   JPanel pan2 = new JPanel();
   fr.setLayout(null);     
   fr.getContentPane().setBackground(Color.green);  //设置窗口的颜色
   fr.setSize(250,250);
   pan1.setLayout(null);                  //设置面板为空布局
   pan1.setBackground(Color.red);
   pan1.setSize(150,150);
   pan2.setBackground(Color.yellow);
   pan2.setSize(50,50);
   pan1.add(pan2);   //将面板pan2添加到pan1中
         //将pan1添加到窗体中，因为pan2被添加到pan1中，所以pan1、pan2都被显示在窗体中
   fr.getContentPane().add(pan1); 
   fr.setVisible(true);
fr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 }
}

前文讲解了JFrame、JPanel，其中已经涉及到了空布局的使用。Java虽然可以以像素为单位对组件进行精确的定位，但是其在不同的系统中将会有一定的显示差异，使得显示效果不尽相同，为此java提供了布局管理器，以使编写的图形界面具有良好的平台无关性。
 
         注意：所有的布局管理器均是针对容器来使用的，包括顶层容器和中间容器。
 
一、布局管理器所属类包
所属类包
布局管理器名称
说明
Java.awt
FlowLayout（流式布局）
组件按照加入的先后顺序按照设置的对齐方式从左向右排列，一行排满到下一行开始继续排列
BorderLayout（边界布局）
容器划分为东、西、南、北、中五个区域，每个区域只能放置一个组件。
GridLayout（网格布局）
容器的空间划分成M×N列的网格区域, 每个区域只能放置一个组件。
CardLayout（卡片布局）
如同一叠牌，每个牌对应一个组件，但每次只能显示其中的一张牌。适用于在一个空间中防止多个组件的情况
GridBagLayout（网格包布局）
GridLayout的升级版，组件仍然是按照行、列放置，但是每个组件可以占据多个网格
Java.swing
BoxLayout（箱式布局）
允许在容器中纵向或者横向防止多个控件
SprigLayout（弹簧布局）
根据一组约束条件放置控件
无
空布局
不使用布局管理器，按照控件自身提供的大小、位置信息放置控件
 
 
二、容器的默认布局管理器
各容器都有默认的布局管理，见下表：
容器
默认布局方式
顶层容器
JFrame
BorderLayout（边界布局)
JDialog
BorderLayout（边界布局)
JApplet
FlowLayout（流式布局）
中间容器
JPanel
FlowLayout（流式布局）
 
三、FlowLayout（流式布局）
使用FlowLayout布局方式的容器中组件按照加入的先后顺序按照设置的对齐方式（居中、左对齐、右对齐）从左向右排列，一行排满（即组件超过容器宽度后）到下一行开始继续排列。
1、流式布局特征如下：
l  组件按照设置的对齐方式进行排列
l  不管对齐方式如何，组件均按照从左到右的方式进行排列，一行排满，转到下一行。（比如按照右对齐排列，第一个组件在第一行最右边，添加第二个组件时，第一个组件向左平移，第二个组件变成该行最右边的组件，这就是从左向右方式进行排列）
 
2、流式布局FlowLayout类的常用构造函数和方法
构造函数
名称
用途
FlowLayout()    
构造一个新的 FlowLayout，它是默认居中对齐的，默认的水平和垂直间隙是5个像素
FlowLayout(int align)
构造一个新的 FlowLayout，它具有指定的对齐方式，默认的水平和垂直间隙是 5 个像素
五个参数值及含义如下：
0或FlowLayout.lEFT ，控件左对齐
1或FlowLayout.CENTER ，居中对齐
2或FlowLayout.RIGHT ，右对齐
3或FlowLayout.LEADING，控件与容器方向开始边对应
4或FlowLayout.TRAILING，控件与容器方向结束边对应
如果是0、1、2、3、4之外的整数，则为左对齐
FlowLayout(int align, int hgap, int vgap)     
创建一个新的流布局管理器，它具有指定的对齐方式以及指定的水平和垂直间隙。
方法
名称
用途
Void setAlignment(int align)
设置此布局的对齐方式。
void setHgap(int hgap)
设置组件之间以及组件与 Container 的边之间的水平间隙。
void setVgap(int vgap)
设置组件之间以及组件与 Container 的边之间的垂直间隙。
 
3、FlowLayout 布局应用代码段举例
1)        设置FlowLayout 布局
JFrame  fr=new JFrame( );
FlowLayout  flow=new FlowLayout( );
fr.setLayout(flow);
上面的语句可以简化成：
fr.setLayout(new FlowLayout());
2)        设置框架fr为组件左对齐的FlowLayout布局 
fr.setLayout(newFlowLayout(FlowLayout.LEFT));
3)        设置框架fr为组件左对齐的FlowLayout布局，并且组件的水平间距为20像素，垂直间距为40像素。
fr.setLayout(new  FlowLayout(FlowLayout.LEFT,20,40));
 
 
实例：对齐方式
// FlowLayoutDemo.java
importjavax.swing.*;
importjava.awt.*;
public classFlowLayoutDemo extends JFrame {
  public FlowLayoutDemo() {
         //设置窗体为流式布局，无参数默认为居中对齐
    setLayout(new FlowLayout());
         //设置窗体中显示的字体样式
    setFont(new Font("Helvetica",Font.PLAIN, 14));
         //将按钮添加到窗体中
    getContentPane().add(newJButton("Button 1"));
    getContentPane().add(new JButton("Button 2"));
    getContentPane().add(new JButton("Button3"));
    getContentPane().add(newJButton("Button 4"));
  } 
  public static void main(String args[]) {
    FlowLayoutDemo window = newFlowLayoutDemo();
    window.setTitle("流式布局");
          //该代码依据放置的组件设定窗口的大小使之正好能容纳你放置的所有组件
    window.pack();
    window.setVisible(true);
         window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         window.setLocationRelativeTo(null);                //让窗体居中显示
  }
}
 
         程序执行结果如下图所示，生成了一个居中显示的窗体，上面有四个按钮，留意按钮之间，按钮与窗体的上下左右边缘都是默认5个像素的间距。改变窗体大小，如下图所示，分别是原始界面、拉宽原始界面、拉窄原始界面，组件和界面的间距。
 
        
 
修改程序代码体会界面布局效果：
setLayout(newFlowLayout());
将上面源程序中的代码更改如下，然后做出如下更改：
setLayout(newFlowLayout(0));  //组件左对齐
setLayout(newFlowLayout(FlowLayout.RIGHT,10,15));  //组件右对齐,组件间水平间距为10像素，垂直间距为15像素


边界布局管理器把容器的的布局分为五个位置：CENTER、EAST、WEST、NORTH、SOUTH。依次对应为：上北（NORTH）、下南（SOUTH）、左西（WEST）、右东（EAST），中（CENTER），如下图所示。

特征：
l  可以把组件放在这五个位置的任意一个，如果未指定位置，则缺省的位置是CENTER。
l  南、北位置控件各占据一行，控件宽度将自动布满整行。东、西和中间位置占据一行;若东、西、南、北位置无控件，则中间控件将自动布满整个屏幕。若东、西、南、北位置中无论哪个位置没有控件，则中间位置控件将自动占据没有控件的位置。
l  它是窗口、框架的内容窗格和对话框等的缺省布局。
 
 
1、  常见的构建函数和方法
构造方法摘要
BorderLayout(): 构造一个组件之间没有间距(默认间距为0像素)的新边框布局。
 
BorderLayout(int hgap, int vgap) :  构造一个具有指定组件（hgap为横向间距，vgap为纵向间距）间距的边框布局。
 
方法摘要
int
getHgap() ：          返回组件之间的水平间距。
int
getVgap() ：          返回组件之间的垂直间距。
void
removeLayoutComponent(Component comp)： 从此边框布局中移除指定组件。
void
setHgap(int hgap)：          设置组件之间的水平间距。
void
setVgap(int vgap) ：          设置组件之间的垂直间距。
 
实例：
// BorderLayoutDemo.java
import javax.swing.*;
import java.awt.*;
public class BorderLayoutDemo extends JFrame {
  public BorderLayoutDemo(){        //构造函数，初始化对象值
     //设置为边界布局，组件间横向、纵向间距均为5像素
setLayout(new BorderLayout(5,5)); 
     setFont(new Font("Helvetica", Font.PLAIN, 14));
     getContentPane().add("North", new JButton("North"));     //将按钮添加到窗口中
     getContentPane().add("South", new JButton("South"));
     getContentPane().add("East",  new JButton("East"));
     getContentPane().add("West",  new JButton("West"));
     getContentPane().add("Center",new JButton("Center"));
  }  
  public static void main(String args[]) {
     BorderLayoutDemo f = new BorderLayoutDemo();
       f.setTitle("边界布局");
       f.pack();
       f.setVisible(true);
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);             //让窗体居中显示
    }
  }
 
程序执行结果如下所示：

 
依次注释掉东、西、南、北和中间位置添加按钮的语句，保留其它的的语句体会一下边框布局的特点。
 
         如果想要更复杂的布局可以在东、西、南、北和中间位置添加中间容器，中间容器中再进行布局，并添加相应的组件，已达到复制补间的效果。
 
实例二：在中间位置中添加9个按钮。
// BorderLayoutDemo1.java
import javax.swing.*;
import java.awt.*;
public class BorderLayoutDemo1 extends JFrame {
         JPanel p=new JPanel();
  public BorderLayoutDemo(){
     setLayout(new BorderLayout(5,5));
     setFont(new Font("Helvetica", Font.PLAIN, 14));
     getContentPane().add("North", new JButton("North"));
     getContentPane().add("South", new JButton("South"));
     getContentPane().add("East",  new JButton("East"));
     getContentPane().add("West",  new JButton("West"));
         //设置面板为流式布局居中显示，组件横、纵间距为5个像素
          p.setLayout(new FlowLayout(1,5,5));
          //使用循环添加按钮，注意每次添加的按钮对象名称都是b
//但按钮每次均是用new新生成的，所有代表不同的按钮对象。
          for(int i=1;i<10;i++){
                    //String.valueOf(i)，将数字转换为字符串
                   JButton b=new JButton(String.valueOf(i));
                   p.add(b);           //将按钮添加到面板中
          }
     getContentPane().add("Center",p);  //将面板添加到中间位置
  }  
  public static void main(String args[]) {
     BorderLayoutDemo1 f = new BorderLayoutDemo1();
       f.setTitle("边界布局");
       f.pack();  //让窗体自适应组建大小
       f.setVisible(true);
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setLocationRelativeTo(null);             //让窗体居中显示
    }
  }
 
程序执行效果:


     网格布局特点：
l  使容器中的各组件呈M行×N列的网格状分布。
l  网格每列宽度相同，等于容器的宽度除以网格的列数。
l  网格每行高度相同，等于容器的高度除以网格的行数。
l  各组件的排列方式为：从上到下，从左到右。
l  组件放入容器的次序决定了它在容器中的位置。
l  容器大小改变时，组件的相对位置不变，大小会改变。
l  设置网格布局行数和列数时，行数或者列数可以有一个为零。若rows为0，cols为3，则列数固定为3，行数不限，每行只能放3个控件或容器。若cols为0，rows为3，则行数固定为3，列数不限，且每行必定有控件，若组件个数不能整除行数，则除去最后一行外的所有行组件个数为：Math.ceil(组件个数/rows)。
Math.ceil(double x)：传回不小于x的最小整数值。比如行数为3，组件数为13个，则Math.ceil(13/3)=5，即第一行，第二行组件数各为5个，剩下的组件放在最后一行。
l  若组件数超过网格设定的个数，则布局管理器会自动增加网格个数，原则是保持行数不变。
 
 
构造方法摘要
GridLayout()： 创建具有默认值的网格布局，即每个组件占据一行一列。
GridLayout(int rows, int cols) :
创建具有指定行数和列数的网格布局。Rows为行数，cols为列数。
GridLayout(int rows, int cols, int hgap, int vgap) :
创建具有指定行数、列数以及组件水平、纵向一定间距的网格布局。
 
 
 
方法摘要
int
getColumns()  ：获取此布局中的列数。
int
getHgap()：获取组件之间的水平间距。
int
getRows() ：获取此布局中的行数。
int
getVgap()  ：获取组件之间的垂直间距。
void
removeLayoutComponent(Component comp) ：从布局移除指定组件。
void
setColumns(int cols)  ：将此布局中的列数设置为指定值。
void
setHgap(int hgap)：将组件之间的水平间距设置为指定值。
void
setRows(int rows)：将此布局中的行数设置为指定值。
void
setVgap(int vgap) ：将组件之间的垂直间距设置为指定值。
String
toString()：返回此网格布局的值的字符串表示形式。
 
实例一：
//GridLayoutDemo.java
import javax.swing.*;
import java.awt.*;
public class GridLayoutDemo extends JFrame {
  public GridLayoutDemo() {
     setLayout(new GridLayout(0,2));           //设置为网格布局，未指定行数
     setFont(new Font("Helvetica", Font.PLAIN, 14));
     getContentPane().add(new JButton("Button 1"));
     getContentPane().add(new JButton("Button 2"));
     getContentPane().add(new JButton("Button 3"));
     getContentPane().add(new JButton("Button 4"));
     getContentPane().add(new JButton("Button 5"));
  }
  public static void main(String args[]) {
    GridLayoutDemo f = new GridLayoutDemo();
    f.setTitle("GridWindow Application");
    f.pack();
    f.setVisible(true);
         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         f.setLocationRelativeTo(null);           //让窗体居中显示
  }
}
 
程序结果如下图所示：
 
 
 
实例二：布局一个简单的计算器
思路：对窗体应用边界布局，在NORTH上放置一个文本框，在CENTER上放置一个面板，面板上放置计算器的相应按钮
//GridFrame.Java
import java.awt.*;
import javax.swing.*;
class GridFrame extends JFrame{
         //定义面板，并设置为网格布局，4行4列，组件水平、垂直间距均为3
          JPanel p=new JPanel(new GridLayout(4,4,3,3));
          JTextArea t=new JTextArea();        //定义文本框
          //定义字符串数组，为按钮的显示文本赋值
         //注意字符元素的顺序与循环添加按钮保持一致
          String str[]={"7","8","9","/","4","5","6","*","1","2","3","-","0",".","=","+"};
     public GridFrame(String s){
                   super(s);  //为窗体名称赋值
        setLayout(new BorderLayout());     //定义窗体布局为边界布局
        JButton btn[];                             //声明按钮数组
        btn=new JButton[str.length];     //创建按钮数组
                   //循环定义按钮，并添加到面板中
        for(int i=0;i<str.length;i++){
               btn[i]=new JButton(str[i]);
               p.add(btn[i]);
         }
                    //将文本框放置在窗体NORTH位置
            getContentPane().add(t,BorderLayout.NORTH);     
            //将面板放置在窗体CENTER位置
            getContentPane().add(p,BorderLayout.CENTER);   
            setVisible(true);
            setSize(250,200);
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setLocationRelativeTo(null);               //让窗体居中显示
        }
      public static void main(String[] args){
         GridFrame gl=new GridFrame("网格布局计算机！");
         }
} 
 
程序执行结果如下图：
 
                  注意：这里一定要体会通过字符串数组和循环添加按钮的方法，以后添加菜单以及事件处理均采用这种方法，这种方法的好处在于，如果需要修改按钮顺序，直接修改字符串就可以了。而不需要改动添加按钮的代码。

 卡片布局能够让多个组件共享同一个显示空间，共享空间的组件之间的关系就像一叠牌，组件叠在一起，初始时显示该空间中第一个添加的组件，通过CardLayout类提供的方法可以切换该空间中显示的组件。
 
1、  CardLayout类的常用构造函数及方法
 
 
2、  使用CardLayout类提供的方法可以切换显示该空间中的组件
 
方法一步骤：
（1）      定义使用卡片布局的容器
例如：Panel cardPanel=new Panel();
（2）      定义卡片对象：CardLayout 布局对象名称=new CardLayout();
例如：CardLayout card=new CardLayout();
（3）      设置使用卡片布局的容器为卡片布局：
格式：容器名称.setLayout(布局对象名称);
例如：cardPanel.setLayout(card);
（4）      设置容器中显示的组件
例如：for (int i = 0; i < 5; i++) {
                            cardPanel.add(newJButton("按钮"+i));
                   }
（5）      定义响应事件代码，让容器显示相应的组件
格式：
n  布局对象名称.next(容器名称)   显示容器中当前组件之后的一个组件，若当前组件为最后添加的组件，则显示第一个组件，即卡片组件显示是循环的。
n  布局对象名称.first(容器名称)   显示容器中第一个组件
n  布局对象名称.last(容器名称)   显示容器中最后一个组件
n  布局对象名称.previous(容器名称)   显示容器中当前组件之前的一个组件，若当前组件为第一个添加的组件，则显示最后一个组件，即卡片组件显示是循环的。
 
例如：
card.next(cardPanel);
card.previous(cardPanel);
         card.first(cardPanel);      
         card.last(cardPanel);      
 
实例一：卡片的切换
窗体默认边界布局，一个面板以卡片布局，面板上添加五个按钮，该面板添加到CENTER位置，另一个面板添加两个按钮，两个按钮添加事件来切换显示CENTER位置中的面板的组件
 
// cardlayout.java
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;//引入事件包
 
//定义类时实现监听接口
public class cardlayout extendsJFrame implements ActionListener{
         JButton nextbutton;
         JButton preButton;
    Panel cardPanel=new Panel();
    Panel controlpaPanel=new Panel();
         //定义卡片布局对象
    CardLayout card=new CardLayout();
         //定义构造函数
         public cardlayout() {
                   super("卡片布局管理器");
                   setSize(300, 200);
                   setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                   setLocationRelativeTo(null);
                   setVisible(true);
 
                   //设置cardPanel面板对象为卡片布局
                   cardPanel.setLayout(card);    
 
                   //循环，在cardPanel面板对象中添加五个按钮
                   //因为cardPanel面板对象为卡片布局，因此只显示最先添加的组件
                   for (int i = 0; i < 5; i++) {
                            cardPanel.add(new JButton("按钮"+i));
                   }
                   //实例化按钮对象
                   nextbutton=new JButton("下一张卡片");
                   preButton=new JButton("上一张卡片");
 
                   //为按钮对象注册监听器
                   nextbutton.addActionListener(this);
                   preButton.addActionListener(this);
 
                   controlpaPanel.add(preButton);
                   controlpaPanel.add(nextbutton);
 
                   //定义容器对象为当前窗体容器对象
                   Container container=getContentPane();
 
                   //将 cardPanel面板放置在窗口边界布局的中间，窗口默认为边界布局
                   container.add(cardPanel,BorderLayout.CENTER);
                   // 将controlpaPanel面板放置在窗口边界布局的南边，
                   container.add(controlpaPanel,BorderLayout.SOUTH);
         }
 
         //实现按钮的监听触发时的处理
         public void actionPerformed(ActionEvent e){
                   //如果用户单击nextbutton，执行的语句
                   if (e.getSource()==nextbutton){
                            //切换cardPanel面板中当前组件之后的一个组件
                            //若当前组件为最后添加的组件，则显示第一个组件，即卡片组件显示是循环的。
                            card.next(cardPanel);     
                   }
                   if (e.getSource()==preButton){
                            //切换cardPanel面板中当前组件之前的一个组件
                            //若当前组件为第一个添加的组件，则显示最后一个组件，即卡片组件显示是循环的。
                            card.previous(cardPanel);
                   }
         }
         public static void main(String[] args) {
                   cardlayout kapian=new cardlayout();
                  
         }
 }
 
程序显示结果如下图所示，单击“上一张”、“下一张”等按钮可以上面的面板中显示不同的按钮来。
 
 
 
方法二步骤：
（1）      定义使用卡片布局的容器
例如：Panel cardPanel=new Panel();
（2）      定义卡片对象：CardLayout 布局对象名称=newCardLayout();
例如：CardLayout card=new CardLayout();
（3）      设置使用卡片布局的容器为卡片布局：
格式：容器名称.setLayout(卡片对象名称);
例如：cardPanel.setLayout(card);
（4）      设置容器中显示的组件,同时为组件命名对应的卡片名称
格式: 容器名称. Add(卡片名称,组件名称)
例如：for (int i = 0; i < 4; i++) {
                            cardPanel.add(“0”,newJButton("按钮"+i));
                   }
（5）      定义响应事件代码，让容器显示相应的组件
格式：卡片对象名称.show(容器名称,卡片名称)
例如：card.show(cardPanel,”0”);
 
         实例二：使用CardLayout类的show方法显示组件。
窗体默认边界布局，一个面板以卡片布局，面板上添加4个按钮，该面板添加到CENTER位置，另一个面板添加4个按钮，这4个按钮添加事件来切换显示CENTER位置中的面板的组件按钮。
 
// cardlayout1.java
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;//引入事件包
 
//定义类时 实现监听接口
public class cardlayout1 extends JFrameimplements ActionListener{
         JButton b0,b1,b2,b3;
    Panel cardPanel=new Panel();
    Panel controlpaPanel=newPanel();
         //定义卡片布局对象
    CardLayout card=newCardLayout();
         //定义字符数组，为卡片命名
         StringcardName[]={"0","1","2","3"};
         //定义构造函数
         public cardlayout1() {
                   super("卡片布局管理器");
                   setSize(400,200);
                   setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                   setLocationRelativeTo(null);
                   setVisible(true);
 
                   //设置cardPanel面板对象为卡片布局
                   cardPanel.setLayout(card);    
 
                   //循环，在cardPanel面板对象中添加4个按钮
                   //因为cardPanel面板对象为卡片布局，因此初始时显示最先添加的组件
                   for (int i = 0; i< 4; i++) {
                            //面板中添加的每个按钮对应设置一个卡片名
                            cardPanel.add(cardName[i],newJButton("按钮"+i));
                   }
                   //实例化按钮对象
                   b0=newJButton("0");
                   b1=newJButton("1");
                   b2=newJButton("2");
                   b3=newJButton("3");
 
                   //为按钮对象注册监听器
                   b0.addActionListener(this);
                   b1.addActionListener(this);
                   b2.addActionListener(this);
                   b3.addActionListener(this);
 
                   controlpaPanel.add(b0);
                   controlpaPanel.add(b1);
                   controlpaPanel.add(b2);
                   controlpaPanel.add(b3);
                   //定义容器对象为当前窗体容器对象
                   Containercontainer=getContentPane();
 
                   //将 cardPanel面板放置在窗口边界布局的中间，窗口默认为边界布局
                   container.add(cardPanel,BorderLayout.CENTER);
                   // 将controlpaPanel面板放置在窗口边界布局的南边，
                   container.add(controlpaPanel,BorderLayout.SOUTH);
         }
 
         //实现按钮的监听触发时的处理
         public voidactionPerformed(ActionEvent e){
                   //用户单击b0按钮时执行的语句
                   if(e.getSource()==b0){
                            //通过show()方法中的卡片名称，显示容器中的组件。
                            card.show(cardPanel,cardName[0]);     
                   }
                   if(e.getSource()==b1){
                            card.show(cardPanel,cardName[1]);     
                   }
                   if(e.getSource()==b2){
                            card.show(cardPanel,cardName[2]);     
                   }
                   if(e.getSource()==b3){
                            card.show(cardPanel,cardName[3]);     
                   }
         }
         public static voidmain(String[] args) {
                   cardlayout1kapian=new cardlayout1();
                  
         }
 }
 
程序执行结果：

一般容器都有默认布局方式，但是有时候需要精确指定各个组建的大小和位置，就需要用到空布局。
         操作方法：
1)       首先利用setLayout(null)语句将容器的布局设置为null布局（空布局）。
2)       再调用组件的setBounds(int x, int y, int width,int height)方法设置组件在容器中的大小和位置，单位均为像素。
x为控件左边缘离窗体左边缘的距离
y为控件上边缘离窗体上边缘的距离
width为控件宽度
height为控件高度
 
实例：使用空布局精确定位组件的位置
// NullLayoutDemo.java
import java.awt.*;
import javax.swing.*;
public class NullLayoutDemo{
  JFrame fr;
  JButton a,b;
  NullLayoutDemo() {
    fr = new JFrame();
    fr.setBounds(100,100,250,150);
         //设置窗体为空布局
    fr.setLayout(null);
    a=new JButton("按钮a");
    b=new JButton("按钮b");
    fr.getContentPane().add(a);
         //设置按钮a的精确位置
    a.setBounds(30,30,80,25);
    fr.getContentPane().add(b);
    b.setBounds(150,40,80,25);
    fr.setTitle("NullLayoutDemo");
    fr.setVisible(true);
         fr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         fr.setLocationRelativeTo(null);                  //让窗体居中显示
  }
  public static void main(String args[]){
    new NullLayoutDemo();
  }
}
 
程序运行结果如下：