`
dr2tr
  • 浏览: 142320 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

寒假AWT学习笔记

SwingF#算法JDKJ# 
阅读更多

Lesson08A-1.rmvb

基本:
Frame f = new Frame("head");
f.setVisible(true);
f.dispose();

为添加窗口关闭功能，实现WindowListener接口的WindowClosing函数，然后在Frame的对象里用addWinListener调用。
public class MyWindowListener implements WindowListener
WindowClosing(WindowEvent e){
 e.getWindow().setVisible(false);
 //((Window)e.getSource).setVisible(false);
 //((Window)e.getComponent).setVisible(false);
 e.getWindow().dispose();
 
 System.exit(0);

}

f.addWinListener(new MyWindowListner());


 

AWT2 06.1.23 10:00
Lesson08A-2.rmvb

Event Adapter
不是接口类（Listener），不需要实现其中所有实现，只需按照需要覆盖其中某个函数的实现。
所以只有一个函数的接口类（Listener）不需要适配器（Adapter）

WindowAdapter...

用Button关闭窗口的实现：ActionListener
问题：在程序一中，//b.addActionListener(mf);和b.addActionListener(new MyFrame());都是可以的，有什么区别吗？
试答：前者是正确的，后者虽然也行，但是有隐患。因为后者new MyFrame()只是生成了一个指向mf空间的对象指针，而非生成一个新的占有空间的对象实体。在本程序中，比较巧的是我们在用ActionPerformed关闭窗口时，其真正关闭的是new MyFrame()生成的空间，而非mf（因为两者都指向同一个空间，所以mf也被关闭了。）不然的话，比如，mf的定义与new MyFrame()不出现在同一段程序中的话，系统将会发生问题，即窗口根本不能被成功关闭。如程序二即是这种情况。（参看程序二的注释）

程序一：
import java.awt.Frame;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.EventListener;

public class MyFrame implements ActionListener {
 Frame f = new Frame("test");
  
 public static void main(String[] args)
 {
  Button b = new Button("exit");
  MyFrame mf = new MyFrame();
  mf.f.add(b);
  //b.addActionListener(mf);
  b.addActionListener(new MyFrame());
    
  //Frame f = new Frame("test");
  mf.f.setSize(200,200);
  mf.f.setVisible(true);
  //f.dispose();
  mf.f.addWindowListener(new YourListener());
  
  
 }

 /**
  * Method actionPerformed
  *
  *
  * @param e
  *
  */
 public void actionPerformed(ActionEvent e) {
  f.dispose();
  System.exit(0);
  // TODO: 在这添加你的代码
 }
 }

程序二：
import java.awt.Frame;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.EventListener;

public class MyFrame implements ActionListener {
 Frame f = new Frame("test");
 
 public void init(){
  Button b = new Button("exit");
  
  f.add(b);
  //b.addActionListener(f);       //ERROR!!!

  b.addActionListener(this); //这样写才是对的
  //b.addActionListener(new MyFrame());//与上面的写法比较，这种方法是错误的
    
  //Frame f = new Frame("test");
  f.setSize(200,200);
  f.setVisible(true);
  //f.dispose();
  f.addWindowListener(new YourListener());
 }
  
 public static void main(String[] args)
 {
  MyFrame mf = new MyFrame();
  mf.init();
  
 }

 /**
  * Method actionPerformed
  *
  *
  * @param e
  *
  */
 public void actionPerformed(ActionEvent e) {
  f.dispose();
  //System.exit(0);
  // TODO: 在这添加你的代码
 }
 }


除了如上所述的实现button关闭窗口的方法外，也可以通过用类中类的方法来实现。如程序四：
import java.awt.Frame;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.EventListener;

public class MyFrame {//implements ActionListener {
 Frame f = new Frame("test");
 
 public void init(){
  Button b = new Button("exit");
  
  f.add(b);
  //b.addActionListener(f);       //ERROR!!!
  b.addActionListener(new MyActionListener());
  //b.addActionListener(new MyFrame());
    
  //Frame f = new Frame("test");
  f.setSize(200,200);
  f.setVisible(true);
  //f.dispose();
  f.addWindowListener(new YourListener());
 }
  
 public static void main(String[] args)
 {
  MyFrame mf = new MyFrame();
  mf.init();
  
 }

 public class MyActionListener implements java.awt.event.ActionListener{ 
 /**
  * Method actionPerformed
  *
  *
  * @param e
  *
  */
 public void actionPerformed(ActionEvent e) {
  f.dispose();
  System.exit(0);
  // TODO: 在这添加你的代码
 }
 }
 }
甚至在使用类中类的时候，可以用匿名的类种类。即将上面b.addActionListener(new MyActionListener());改为：
b.addActionListener(new ActionListener(){
   public void actionPerformed(ActionEvent e) {
  f.dispose();
  System.exit(0);
  // TODO: 在这添加你的代码
 }
   });


缺：事件处理的多重运用。

 

 

 

AWT3 06.1.23 22:00
修改组件的默认事件处理方式
processEvent , processXxxEvent
enableEvents(long eventsToEnble) 不注册事件监听器也可对事件反应  ,
    eventsToEnable 是用位来表示的事件，一般被设定为常量

一般对某个组件（比如Button）的事件反应的代码的实现，通常是通过继承扩展该组件（如class MyButton extends Button），然后重写其processXxxEvent函数达到的。

通常，frame的setVisible(true)必须在组件的setVisible(true)之前，否则将会出现不可知的问题。一下摘录了一个程序，其主要功能是两个按钮，在鼠标到达某个按钮上时，隐藏该按钮显示另一个；请留意看注释：

MyButton.java  继承的新组件
-------------------------------
import java.awt.*;
import java.awt.event.*;
public class MyButton extends Button{
 private MyButton friend = null;//用friend表示第二个按钮
 
 public void setFriend (MyButton f){
  this.friend = f;
 }
 
 public MyButton (String title){
  super(title);
  this.enableEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);//允许AWTEvent.MOUSE_MOTION_EVENT_MASK事件的处理，使不注册事件监听器程序也可对事件反应
 }
 
 protected void processMouseMotionEvent(MouseEvent e){//该处理的主要功能就是隐藏被鼠标到达的按钮
          this.setVisible(false);
          friend.setVisible(true);
         }
}


AWT3Frame.java 新的Frame
-----------------------------------
import java.awt.*;
import java.awt.event.*;

public class AWT3Frame extends Frame {
   
    /**
     * The constructor.
     */ 
     public AWT3Frame() {
               
        MenuBar menuBar = new MenuBar();
        Menu menuFile = new Menu();
        MenuItem menuFileExit = new MenuItem();
       
        MyButton btn1 = new MyButton("btn1");
        MyButton btn2 = new MyButton("btn2");
       
        btn1.setFriend(btn2);
        btn2.setFriend(btn1);
       
        this.add(btn1,"North");
        this.add(btn2,"South");
       
        menuFile.setLabel("File");
        menuFileExit.setLabel("Exit");
       
        // Add action listener.for the menu button，这是简单的事件监听器的注册，由JC自动完成
        menuFileExit.addActionListener
        (
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    AWT3Frame.this.windowClosed();
                    //this.windowClosed();   //这样是不对的，为什么呢？**********************************************？
      //AWT3Frame.windowClosed();//这样也是不对的，为什么？********************************************？
                }
            }
        );
        menuFile.add(menuFileExit);
        menuBar.add(menuFile);
       
        setTitle("AWT3");
        setMenuBar(menuBar);
        setSize(new Dimension(400, 400));
       
        // Add window listener.
        this.addWindowListener
        (
            new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    AWT3Frame.this.windowClosed();                   
                }
            }
        );
       
        this.setVisible(true);   //这里如果顺序出错
        btn2.setVisible(false);  //将会导致不可预料的问题
    }
   
   
    /**
     * Shutdown procedure when run as an application.
     */
    protected void windowClosed() {
     
     // TODO: Check if it is safe to close the application
     
        // Exit application.
        System.exit(0);
    }
}

AWT3.java 主程序
public class AWT3 {
   
    public static void main(String[] args) {
        // Create application frame.
        AWT3Frame frame = new AWT3Frame();
       
        // Show frame
       // frame.setVisible(true);//为防止不可预料的问题，所以在上一个类中setVisible.##########?
      
    }
}

 
问题记录：
1、如上面标记*的两行
menuFileExit.addActionListener
        (
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    AWT3Frame.this.windowClosed();
                    //this.windowClosed();   //这样是不对的，为什么呢？**********************************************？
      //AWT3Frame.windowClosed();//这样也是不对的，为什么？********************************************？
                }
            }
        );

答：this.windowClosed表示匿名类ActionListener调用windowClosed函数
 而AWT3Frame.this.windowClosed();表示匿名类的外层（AW3Frame）调用windowClosed函数

2、如主程序中标记#的一行，因为“frame的setVisible(true)必须在组件的setVisible(true)之前，否则将会出现不可知的问题。”，但是在实现中，有时不得不把setVisible放在主程序中实现，这个矛盾怎么解决？另外，这个说法的原因也待考虑。


 

 

 

GUI组件上的图形操作
Graphics.drawString(String,x,y)   (x,y)是字符串的左下角坐标

在Frame上作图的基本步骤是：
1。获得Graphics对象 Graphics g = getGraphics();//(java.awt.Component.getGraphics() )
2.用获得的Graphics对象作画（drawString,drawLine等），并且可以设置各种属性（setFont,setColor等）

 

组件重绘
原先绘制的图画在经历最小化和最大化后会消失，所以要重绘。
可以通过paint(Graphics g)的重构实现重绘
一般可以把要重绘的各个图形单独建类，并在一个函数中设置各种绘画的属性供paint调用。另外，通常要用Vector、Enumeration记录已经画了的东西的参数（如位置，颜色等）。
在做完paint的重构后，可以通过调用repaint直接完成绘图部分的工作。（repaint = paint + update）

文件MyLine.java 要重绘的图形单独建类
-------------------------------
import java.awt.*;
public class MyLine {
 int orgX;
 int orgY;
 
 int endX;
 int endY;
 
 
 public MyLine(int x, int y, int xe, int ye){
  orgX = x;
  orgY = y;
  
  endX = xe;
  endY = ye;
 }
 
 public void drawMe(Graphics g){  //设置各种绘画的属性，绘图，供paint调用
  g.setColor(Color.RED);
          g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
          g.drawString(orgX + "," + orgY,
           orgX,orgY);
          g.drawString(endX + "," + endY,
           endX, endY);
          g.drawLine(
           orgX,orgY,endX,endY);
 }
}

 

文件DrawLineFrame.java 主体程序
--------------------------------------
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class DrawLineFrame extends Frame {
   
    int orgX;
    int orgY;
    int endX;
    int endY;
   
    Vector vLines = new Vector(); //用Vector记录已经画了的东西的参数
   
    public void paint(Graphics g){
     Enumeration e = vLines.elements(); //Enumeration列举Vector各项
     while(e.hasMoreElements()){
      MyLine line = (MyLine)e.nextElement();
      line.drawMe(g);
     //g.drawLine(orgX,orgY,endX,endY);
     }
     
    }
   
    /**
     * The constructor.
     */ 
     public DrawLineFrame() {
               
        MenuBar menuBar = new MenuBar();
        Menu menuFile = new Menu();
        MenuItem menuFileExit = new MenuItem();
       
        menuFile.setLabel("File");
        menuFileExit.setLabel("Exit");
       
        // Add action listener.for the menu button
        menuFileExit.addActionListener
        (
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    DrawLineFrame.this.windowClosed();
                }
            }
        );
        menuFile.add(menuFileExit);
        menuBar.add(menuFile);
       
        setTitle("DrawLine");
        setMenuBar(menuBar);
        setSize(new Dimension(400, 400));
       
        // Add window listener.
        this.addWindowListener
        (
            new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    DrawLineFrame.this.windowClosed();
                }
            }
        ); 
       
        this.addMouseListener(new MouseAdapter(){
                  
         public void mousePressed(MouseEvent e){
          orgX = e.getX();
          orgY = e.getY();
         }
         
         public void mouseReleased(MouseEvent e){
          endX = e.getX();
          endY = e.getY();
          
          /*这些都是可以用repaint()函数代替的代码
   Graphics g = getGraphics();
          g.setColor(Color.RED);
          g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
          g.drawString(orgX + "," + orgY,
           orgX,orgY);
          g.drawString(e.getX() + "," + e.getY(),
           e.getX(),e.getY());
          g.drawLine(
           orgX,orgY,e.getX(),e.getY());
   */
           
          vLines.add(new MyLine(orgX,orgY,endX,endY));  //把相关参数保存下来
          repaint();
         }
        }
        );
    }
   
   
    /**
     * Shutdown procedure when run as an application.
     */
    protected void windowClosed() {
     
     // TODO: Check if it is safe to close the application
     
        // Exit application.
        System.exit(0);
    }
}

 

 

 

 

 

 

GUI组件上的图像显示 06.1.26

Graphics.drawImage(Image img, int x, int y, ImageObserver observer)方法
   img：即使未被装载   observer：图像装载的进度信息

Image是抽象类，不能直接new产生该类对象，但可通过某个类的实例方法产生Image对象
可通过Toolkit的createImage或者getImage获得(其中，createImage的图像是非共享的，而getImage的获得的图像是可共享的)
（另外，Toolkit也是虚类，可通过Component.getToolkit方法获得Toolkit对象，然后用获得的Toolkit对象的getImage或createImage获得Image对象）

drawImage是一个异步方法，即即使img未被装载，函数也会立刻返回一个值（true or false）
解决这个问题，可以采用在paint()方法中写drawImage的方法


双缓冲区技术  组件表面图形的重绘
原理：用Component.createImage方法创建内存Image对象，重绘时可利用这个Image对象。

这个程序的尝试 失败 了，主要是在重绘时图像消失的问题

import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class DrawLine1 extends Frame {   
    int orgX;
    int orgY;
    int endX;
    int endY;
   
    Image oimg = null; //这是第二个缓冲的img对象
    Graphics og = null; //这是第二个缓冲用到的Graphics对象
   
    //Vector vLines = new Vector();
   
    public void paint(Graphics g){
     if (oimg != null)
      g.drawImage(oimg,0,0,this);
    // Enumeration e = vLines.elements();
    // while(e.hasMoreElements()){
    //  MyLine line = (MyLine)e.nextElement();
    //  line.drawMe(g);
     //g.drawLine(orgX,orgY,endX,endY);
    // }
     
     
    }
   
    /**
     * The constructor.
     */ 
     public DrawLine1() {
       setVisible(true);
      
         Dimension d = this.getSize();
       
        oimg = createImage(d.width,d.height);//初始化
        og = oimg.getGraphics();//初始化
       
        MenuBar menuBar = new MenuBar();
        Menu menuFile = new Menu();
        MenuItem menuFileExit = new MenuItem();
       
        menuFile.setLabel("File");
        menuFileExit.setLabel("Exit");
       
        // Add action listener.for the menu button
        menuFileExit.addActionListener
        (
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    DrawLine1.this.windowClosed();
                }
            }
        );
        menuFile.add(menuFileExit);
        menuBar.add(menuFile);
       
        setTitle("DrawLine");
        setMenuBar(menuBar);
        setSize(new Dimension(400, 400));
       
        // Add window listener.
        this.addWindowListener
        (
            new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    DrawLine1.this.windowClosed();
                }
            }
        ); 
       
        this.addMouseListener(new MouseAdapter(){
                  
     public void mousePressed(MouseEvent e){
          orgX = e.getX();
          orgY = e.getY();
         }
         
     public void mouseReleased(MouseEvent e){
          endX = e.getX();
          endY = e.getY();  
          
          Graphics g = getGraphics();
          
          g.setColor(Color.RED);
          g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
          g.drawString(orgX + "," + orgY,
           orgX,orgY);
          g.drawString(e.getX() + "," + e.getY(),
           e.getX(),e.getY());
          g.drawLine(
           orgX,orgY,e.getX(),e.getY());
          
          //以下是在缓冲区中写组件表面图形的Image对象
          og.setColor(Color.RED);
          og.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
          og.drawString(orgX + "," + orgY,
           orgX,orgY);
          og.drawString(e.getX() + "," + e.getY(),
           e.getX(),e.getY());
          og.drawLine(
           orgX,orgY,e.getX(),e.getY());
           
               }
        }
        );
    }
   
protected void windowClosed() {
        System.exit(0);
    }
}

 

 

 

 

菜单
MenuBar,Menu,MenuItem
将MenuItem加到Menu对象，将Menu加到MenuBar对象，将MenuBar加到Frame。
（TIPS：CheckboxMenuItem对象可建立可标记的MenuItem，addSeparator函数可用来添加分隔条）

对菜单时间可以用ActionListener监听处理单击事件
可用getActionCommand函数，判断其是否与菜单名称一致来实现事件处理，如：
if(e.getActionCommand().equals("open")) ....;
另外，不要忘记注册监听器。


可以用setActionCommand函数为菜单设置命令字符串，与getActionCommand对应，如果没有设定，则默认与菜单项名称相同。
这一点可用于程序的国际化；也可用于一个菜单项用于多种用途：
  如同一菜单项分别用于“连接”和“断开”

Container
Container是所有容器类的父类，Component的子类。组件如果在容器setVisible之后添加，是不会被显示出来的。

以下是一个简单的程序实例：
import java.awt.*;
import java.awt.event.*;

public class TestMenuFrame extends Frame {

     public TestMenuFrame() {
               
        MenuBar menuBar = new MenuBar();
        Menu menuFile = new Menu();
        Menu menuEdit = new Menu("edit");
       
        MenuItem menuFileExit = new MenuItem();
        MenuItem menuFileOpen = new MenuItem("open");
       
        Menu menuFilePrint = new Menu("print"); //print菜单是多级菜单，所以这里必须声明为Menu
       
        MenuItem printPreview = new MenuItem("preview");
       
        printPreview.addActionListener //添加事件响应
        (
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    System.out.println("preview");
                }
            }
        );
       
       
        MenuItem printSetting = new MenuItem("setting");
       
        menuBar.add(menuEdit);
       
        menuFile.add(menuFileOpen);
        menuFile.add(menuFilePrint);
       
        menuFilePrint.add(printPreview);
        menuFilePrint.add(printSetting);
       
        menuFile.setLabel("File");
        menuFileExit.setLabel("Exit");
       
        // Add action listener.for the menu button
        menuFileExit.addActionListener
        (
            new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    TestMenuFrame.this.windowClosed();
                }
            }
        );
        menuFile.add(menuFileExit);
        menuBar.add(menuFile);
       
        setTitle("TestMenu");
        setMenuBar(menuBar);
        setSize(new Dimension(400, 400));
       
        // Add window listener.
        this.addWindowListener
        (
            new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    TestMenuFrame.this.windowClosed();
                }
            }
        ); 
    }
   
   
    /**
     * Shutdown procedure when run as an application.
     */
    protected void windowClosed() {
     
     // TODO: Check if it is safe to close the application
     
        // Exit application.
        System.exit(0);
    }
}

 

 

 

 

  Lesson8d-1

Checkbox
创建多选Checkbox(String lable, boolean state)
创建单选Checkbox(String lable, boolean state, CheckboxGroup group)

单选及多选按钮的语义事件为ItemEvent, 监听器接口为ItemListener，该接口中只有一个itemStateChange方法


Choice 下拉列表框
语义事件为ItemEvent, 监听器接口为ItemListener


Panel与ScrollPane类
都是容器类，Panel不能独立存在，ScrollPane用于产生滚动窗口

 


记录问题：
一：Panel有什么用？
 JDK里说：Panel is the simplest container class. A panel provides space in which an application can attach any other component, including other panels. 它与Frame的区别是什么？
 
二：如程序：
 import java.awt.*;
import java.awt.event.*;

public class TestPanel extends Panel {
 Checkbox cb1 = new Checkbox("Like?",true);
 
 CheckboxGroup cbg = new CheckboxGroup();
 Checkbox cb21 = new Checkbox("Yes.", true, cbg);
 
 Checkbox cb22 = new Checkbox("no.", true, cbg);
 
 
 public TestPanel(){
  
  this.add(cb1);
  this.add(cb21);
  this.add(cb22);
  cb22.addItemListener(new ItemListener(){
  public void itemStateChanged(ItemEvent e){
   if(e.getStateChange() == ItemEvent.SELECTED){ //如果no被选中***************
    System.out.println("I'm sorry!!");
   };
   if(e.getStateChange() == ItemEvent.DESELECTED){ //如果选yes（no未被选中）***************
    System.out.println("I'm happy!!");
   };
   
  }
 }
 );
 
  /* #####################################################################################
   Button b = new Button("OK");
  
   this.add(b);
  
   b.addActionListener(new ActionListener(){
    public void actionPerformed(ActionEvent e){
     System.out.println("cb1:" + TestPanel.this.cb1.getState());
     System.out.println("cb2:" + TestPanel.this.cb21.getState());
     System.out.println("cb3:" + TestPanel.this.cb22.getState());
     
     System.out.println("cbg:" + cbg.getSelectedCheckbox().getLabel());
    }
    }
    );
  #########################################################################################*/

 }

}

 1。如上，注意*注释，上面的no被选中时，能够打印出"I'm sorry!!", 但是当选yes时（此时即no为DESELECTED），却不能打印出"I'm happy!!"。
 2。如#注释部分，这个程序是把cb1,cb21,cb22作为类成员变量来用了；但如果cb1,cb21,cb22只是构造函数里的局部变量，那么注释部分的TestPanel.this.cb1.getState()应该怎么改写呢？即如果匿名类位于一个函数内部，那么在匿名类的实现里如何调用函数的局部变量呢？用final似乎不好吧

 

 

 

 

  Lesson08D-2
布局管理器
可调用Container类的方法setLayout(layout_name)设置容器的布局管理器

AWT中的布局管理器类：
1.BorderLayout
 Window类（及其子类Frame, Dialog）的默认布局管理器，分容器为东西南北中。
2.FlowLayout
 Panel类的默认布局管理器。容器内的组件从左到右，从上到下排列。
3.GridLayout
 容器内的组件从左到右，从上到下排列，并且各组件大小平均。这种布局管理器还可设置每行每列可放置的组件数。
4.CardLayout
 可实现多个组件在同一容器区域内交替显示；但只有最上面的组件可见。CardLayout需要为每个组件设置一个关键字（字符串），在add(component, key)函数的key中指定。
5.GridBagLayout
比较复杂，较少使用。


取消布局管理器：
用Container.setLayout(null) 取消布局管理器，
并用Component.setBound(x1,y1,x2,y2)设定绝对坐标。

这样做的缺点是容器中组件的大小将无法随容器大小的变化而调整。

 

 

 

 

  Lession08D-3
Swing和JFC
Swing是JComponent类的子类，JComponent是java.awt.Container的子类
AWT组件在Swing中的名称是原名前加J（如Button->JButton）
JFC：Java Foundation Class ，包括Swing，java2d等

从AWT到javax.swing
1. JFrame：与java.awt.Frame相似。但是，JFrame上只能有一个唯一的组件：JRootPane，可用JFrame.getContentPane()获得JFrame内置的JRootPane对象。组件的增加和布局管理器的设定都要在JRootPane上进行。
 调用JFrame的setDefaultCloseOperation（TODO）方法，可设置单击关闭按钮后的事件处理方式。JFrame关闭按钮的默认事件处理方式是隐藏窗口（但不关闭），需要用JFrame.dispose()关闭退出。

2.JScrollPane：与ScrollPane对应
 分为JScrollBar和代表视图区域的JViewport。另外，需要用JViewport.getViewport.add方法添加子组件。（《Jave Tutorial》中有详细指导。）

3.Swing中的标准对话框：JOptionPane类提供了若干个showXxxDialog静态方法。如：showConfirmDialog(Component parentComponent（父窗口，可为null，这时为桌面）,Object message, String title, int optionType, int messageType);
 JFileChooser类提供了文件存取对话框。（JAVA_HOME\Demo\jfc\FileChooserDemo目录下有实例）

4.另外，新增BoxLayout...还有一些细节，比如JTextField的构造函数不带参数时，默认的列数为0。


注：这里比较重要的一点是JFrame和JScroll等容器，要向他们增加组建的话不能直接加，而必须间接执行（JFrame的JRootPane和JScrollPane的JViewport）。不知道JDK的设计者在设计时为什么这么考虑。

 

 

 

  Lesson08D-4

编写一个计算器，以下为GUI部分

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.event.ActionListener;
import java.util.EventListener;
import java.util.StringTokenizer;

/**
 * Sample application using Frame.
 *
 * @author
 * @version 1.00 06/02/03
 */
public class CaculatorFrame extends JFrame implements ActionListener {
    JTextField jtf = new JTextField();
    double firstNum = 0;
 double secondNum = 0;
 char operater = 0;
 double tempResult = 0;
 boolean flag = false; //flag for whether_has_computed
  
     public CaculatorFrame() {
               
        setSize(new Dimension(400, 400));
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jtf.setHorizontalAlignment(JTextField.RIGHT);
       
        Container c = this.getContentPane();
       
        JPanel jpl = new JPanel();
        c.add(jtf, BorderLayout.NORTH);
        c.add(jpl, BorderLayout.CENTER);
       
        jpl.setLayout(new GridLayout(4,4));
       
        JButton b = null;
        String bf = "123+456-789*.0/=";
        for(int i = 0; i<16; i++){
         b = new JButton(bf.charAt(i) + "") ;
         b.addActionListener(this);
         jpl.add(b);
         }
       
        /*/ Add window listener.
        this.addWindowListener
        (
            new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    CaculatorFrame.this.windowClosed();
                }
            }
        );*/ 
    }
   
   
   
    protected void windowClosed() {
     System.exit(0);
    }

 
 public void actionPerformed(ActionEvent e) {  
  //在这里实现计算器的具体算法
  
  //String c = e.getActionCommand();
  
  
 }  
 private boolean isNum(String s){
  for(int i = 0; i<10; i++){
   if(s.equals("" + i))
   return true;
  }
  return false;
 }
 
 private void doOperate(char op)
 {
  //某个可能用到的算法
 }
}

 

 

 

 

分享到：
| gcc常用的使用方法
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA AWT学习手册

    JAVA AWT学习手册 AWT（Abstract Window Toolkit），即抽象窗口工具包，是Java API为Java程序提供的建立图形用户界面的基本工具集，AWT可以用于Java Application和Java Applet的图形用户界面的创建。 AWT工具集...

    awt的学习心得

    学习AWT、Swing和SWT时，理解它们之间的关系和各自的优势至关重要。AWT是基础，Swing是其增强版，而SWT则提供了更接近原生体验的组件。在实际开发中，根据项目需求和性能要求，开发者可以选择适合的库。例如，如果...

    swing基础学习和awt的区别

    Swing和AWT是Java GUI（图形用户界面）编程中的两个重要框架，它们都是用于创建桌面应用程序的组件库。然而，两者在设计理念、组件类型、性能和外观方面存在显著差异。 首先，AWT（Abstract Window Toolkit）是Java...

    圣思园 awt.pdf

    AWT（Abstract Window Toolkit，抽象窗口工具包）是Java编程语言的一个基础图形用户界面工具包。AWT使得Java程序能够创建和管理GUI窗口和组件。为了理解AWT的核心概念，接下来将详细阐释AWT的相关知识点。 首先，...

    awt和swing学习实例大全

    ### AWT 和 Swing 学习实例详解 #### 一、AWT与Swing概述 AWT（Abstract Window Toolkit）和Swing是Java中用于构建图形用户界面（GUI）的两个重要工具包。AWT是由Sun Microsystems开发的第一代GUI库，而Swing则是...

    awt包java Android

    awt包java Android awt包java Android awt包java Android awt包java Android awt包java Android awt包java Android awt包java Android awt包java Android awt包java Android awt包java Android awt包java Android ...

    JAVA图形编程（AWT+SWING）

    通过`java图形编程1-AWT.chm`和`java图形编程2-Swing.chm`这两个文档，你可以深入学习AWT和Swing的使用方法，了解组件的创建、布局管理、事件处理、模型-视图-控制器模式，以及如何利用Swing的高级功能来构建复杂的...

    AWT与AWT事件处理

    什么是AWT 用AWT构建GUI 事件处理 AWT组件类库

    awt.rar_awt_java awt_java 画图

    Java AWT（Abstract Window Toolkit）是Java平台早期的图形用户界面（GUI）工具包，它为开发者提供了创建和管理窗口、按钮、文本框等组件的基本功能。在Java中，AWT是 Swing 的基础，虽然现在Swing更常用，但AWT仍然...

    awt.rar_awt_java awt_java绘图

    这个"awt.rar"压缩包显然是一个关于Java AWT绘图的学习资源，适合初学者了解和实践AWT模块的绘图功能。 在Java中，AWT绘图是通过`Graphics`类来实现的，它是所有可绘制对象的基础。当你创建一个AWT组件，如`Canvas`...

    j2se学习笔记和java学习笔记

    本学习笔记旨在深入理解J2SE的基础概念、核心特性以及实际应用。 一、Java基础 Java是一种面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）于1995年发布。它的主要特点包括跨平台性（Write Once, Run ...

    java学习笔记JDK6.0课件和代码

    这个压缩包中包含的"java学习笔记JDK6课件和课本代码"是学习JDK 6.0的重要参考资料，可以帮助你深入理解Java编程的核心概念和实践技巧。 1. **Java基础**：Java是一种面向对象的编程语言，它的基础包括类、对象、...

    Java的AWT包.pdf

    Java的Abstract Window Toolkit(AWT)包是Java标准版(Java SE)的一部分，它提供了一组基本的组件和接口，用于创建图形用户界面(GUI)。在Java编程中，如果你需要开发带有窗口、按钮、文本框等元素的应用程序，AWT就是...

    java学习笔记JDK6课件和课本代码.rar

    本压缩包"java学习笔记JDK6课件和课本代码.rar"中包含的资源，旨在帮助学习者深入理解Java编程，并掌握JDK 6的关键特性。以下是一些主要的知识点： 1. **基础语法**：Java的基础语法包括变量声明、数据类型、运算符...

    《Java JDK 6 学习笔记》配书示例

    《Java JDK 6 学习笔记》这本书很可能是为了帮助读者深入理解和掌握这个版本的Java编程语言及其开发环境。以下是一些关键知识点的详细说明： 1. **自动装箱与拆箱**：Java 6中引入了自动装箱和拆箱功能，使得基本...

    Swing,AWT.J2SE 学习帮助文档

    在J2SE的学习过程中，理解Swing和AWT之间的关系及其各自的优势是至关重要的。虽然AWT在某些情况下可能更适合对性能有极高要求的项目，但大多数现代的Java桌面应用开发倾向于使用Swing，因为它提供了更强大的功能和更...

    AWT和Swing笔记，java图形化界面编程

    学习并熟练掌握AWT和Swing，可以让Java程序员创建出具有吸引力和高效交互的图形用户界面，从而提高软件的用户体验。在实际开发中，可以根据需求选择使用AWT的原生感观或Swing的跨平台一致性，以达到最佳的设计效果。

Magicbox
Global site tag (gtag.js) - Google Analytics