精华内容
下载资源
问答
  • java中实现退出按钮功能的实现以及几种布局方式的简述------三种方法 今天看了布局管理器,写了如下代码: import java.awt.*; import java.awt.event.*; class myFrame {  public static void main(String ...

     java中实现退出按钮功能的实现以及几种布局方式的简述------三种方法

    今天看了布局管理器,写了如下代码:

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

    class myFrame {
     public static void main(String args[]){
      Frame f=new Frame("my first");
      Button btn1=new Button("north");//定义一个Button组件
      Button btn2=new Button("south");//定义一个Button组件
      Button btn3=new Button("west");//定义一个Button组件
      Button btn4=new Button("east");//定义一个Button组件
      Button btn5=new Button("Center");//定义一个Button组件
      f.setSize(600,400);//设定窗口大小
      f.setLocation(100, 100);//默认为(0,0),用于设定窗口开始是离左上角距离
      f.setBackground(Color.green);//设定颜色,这个方法内部是一个color类
      f.setForeground(Color.black);//设定字体颜色
      f.setLayout(new BorderLayout());//构造一个组件之间没有间距的新边界布局。
      //f.setLayout(new BorderLayout(20,10));//构造一个组件之间间距为水平为20,垂直为10的新边界布局。
      //f.setLayout(new FlowLayout(FlowLayout.CENTER,5,50));//流式布局管理器, 构造一个新的 FlowLayout,居中对齐,默认的水平和垂直间隙是 5 个单位。
      //f.setLayout(new GridLayout(3,2,10,30));
      //f.setLayout(new CardLayout(100,10));
      f.add(btn1,BorderLayout.NORTH);//把button放在north边
      //f.add(btn1);
      f.add(btn2,BorderLayout.SOUTH);
      f.add(btn3,BorderLayout.WEST);
      f.add(btn4,BorderLayout.EAST);
      f.add(btn5,BorderLayout.CENTER);
    }

    当我点击退出按钮是发现没有反应,不知道大家是否也遇到过这种情况。实际上我们可以用一下三种方法解决:

    方法一:定义一个MyWindowListener类,实现接口WindowListener,因为WindowListener类是抽象的,所以他的所有方法都要实现

    class MyWindowListener implements WindowListener//实现接口中所有的方法哦
    {
      public void windowOpened(WindowEvent e)
      {

      }
      public void windowClosing(WindowEvent e)
      {
        System.exit(0);
      }
      public void windowClosed(WindowEvent e)//用于点击关闭后进行的操作
      {
      }
      public void windowIconified(WindowEvent e)
      {

      }
      public void windowDeiconified(WindowEvent e)
      {

      }
      public void windowActivated(WindowEvent e)
      {

      }
      public void windowDeactivated(WindowEvent e)
      {

      }
    }

    写好后,我们只要在原代码中添加代码:f.addWindowListener(new MyWindowListener());就可以了

     

    方法二:这个方法需要用到适配器WindowAdapter,我们先定义一个HisWindowListener,定义如下:

    class HisWindowListener extends WindowAdapter{
     public void windowClosing(WindowEvent e){
      System.exit(0);
     }
    }

     然后我们只要在原代码中添加代码:f.addWindowListener(new HisWindowListener());就可以了

     

    方法三:其实这个方法和方法二类似,只是我们不用创建一个类,而是直接在原代码中添加代码:

    f.addWindowListener(new WindowAdapter(){
       public void windowClosing(WindowEvent e){
        System.exit(0);
       }
      });就可以了,因为WindowAdapter()是抽象类,所以我们必须实现它

     

     

    最后为了大家更好的理解,我把上面的所有整合到下述代码:

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

    class myFrame {
     public static void main(String args[]){
      Frame f=new Frame("my first");
      Button btn1=new Button("north");//定义一个Button组件
      Button btn2=new Button("south");//定义一个Button组件
      Button btn3=new Button("west");//定义一个Button组件
      Button btn4=new Button("east");//定义一个Button组件
      Button btn5=new Button("Center");//定义一个Button组件
      f.setSize(600,400);//设定窗口大小
      f.setLocation(100, 100);//默认为(0,0),用于设定窗口开始是离左上角距离
      f.setBackground(Color.green);//设定颜色,这个方法内部是一个color类
      f.setForeground(Color.black);//设定字体颜色
      f.setLayout(new BorderLayout());//构造一个组件之间没有间距的新边界布局。
      //f.setLayout(new BorderLayout(20,10));//构造一个组件之间间距为水平为20,垂直为10的新边界布局。
      //f.setLayout(new FlowLayout(FlowLayout.CENTER,5,50));//流式布局管理器, 构造一个新的 FlowLayout,居中对齐,默认的水平和垂直间隙是 5 个单位。
      //f.setLayout(new GridLayout(3,2,10,30));
      //f.setLayout(new CardLayout(100,10));
      f.add(btn1,BorderLayout.NORTH);//把button放在north边
      //f.add(btn1);
      f.add(btn2,BorderLayout.SOUTH);
      f.add(btn3,BorderLayout.WEST);
      f.add(btn4,BorderLayout.EAST);
      f.add(btn5,BorderLayout.CENTER);
      //f.addWindowListener(new MyWindowListener());
      f.addWindowListener(new HisWindowListener());
      f.addWindowListener(new WindowAdapter(){
       public void windowClosing(WindowEvent e){
        System.exit(0);
       }
      });
      f.setVisible(true);//用于显示窗口,如果参数改为false就不显示
     }

    }

    class MyWindowListener implements WindowListener//实现接口中所有的方法哦
    {
      public void windowOpened(WindowEvent e)
      {

      }
      public void windowClosing(WindowEvent e)
      {
        System.exit(0);
      }
      public void windowClosed(WindowEvent e)//用于点击关闭后进行的操作
      {
      }
      public void windowIconified(WindowEvent e)
      {

      }
      public void windowDeiconified(WindowEvent e)
      {

      }
      public void windowActivated(WindowEvent e)
      {

      }
      public void windowDeactivated(WindowEvent e)
      {

      }
    }
    class HisWindowListener extends WindowAdapter{
     public void windowClosing(WindowEvent e){
      System.exit(0);
     }
    }

     

     

    有问题的地方欢迎留言,我也希望和大家多多交流

     

     

     

     

     

    展开全文
  • Java实现窗口退出确认框,确认框取消按钮问题

    万次阅读 多人点赞 2018-10-13 17:42:47
    Java学习GUI时难免会遇到点击框架退出时需要弹出确认提示框的需求,废话不多说,直接上代码,下面是主程序,MenuFrame是继承JFame的类 public class Test_19 { public static void main(String[] args) { ...

    在Java学习GUI时难免会遇到点击框架退出时需要弹出确认提示框的需求,废话不多说,直接上代码,下面是主程序,MenuFrame是继承JFame的类

    public class Test_19 {
        public static void main(String[] args) {
            EventQueue.invokeLater(() -> {
                MenuFrame frame = new MenuFrame();
                //不执行任何操作;要求程序在已注册的 WindowListener 对象的 windowClosing 方法中处理该操作
                frame.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
                frame.addWindowListener(new WindowAdapter() {
                    @Override
                    public void windowClosing(WindowEvent e) {
                        int result = JOptionPane.showConfirmDialog(null, "确认退出?", "确认", 							JOptionPane.OK_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);
                        if(result == JOptionPane.OK_OPTION){
                            System.exit(0);
                        }
                    }
                });
                frame.setTitle("第二次作业");
                frame.setVisible(true);
            });
    
        }
    }

    代码是挺短的,逻辑也很简单,首先为frame添加了一个监听窗口事件的方法addWindowListener,然后使用了匿名内部类的方法,,将WindowAdapter的对象传给这个方法,然后在匿名类中重写了windowClosing的方法,接着在方法里面显示了确认的对话框,对确认按钮进行监听,并实现退出。

    上面代码亲测有效,不过有些坑我觉得还是得提出来,有些人可能会碰到某些问题,能够弹出确认框,但点击取消按钮后还是退出了程序,其实程序并没有结束,只是被隐藏了起来,如何解决呢?

    网上很多做法是直接删去下面这行代码:

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    这句代码是默认会结束程序,但我尝试后并没有解决问题,后来看来某百度知道才终于解决了问题

    JFrame的关闭不像Frame,点关闭按钮自己会关闭,但是那样做不好.可以用setDefaultCloseOperation(int operation);其中operation有以下几种:
    DO_NOTHING_ON_CLOSE(在 WindowConstants 中定义):不执行任何操作;要求程序在已注册的 WindowListener 对象的 windowClosing 方法中处理该操作。
    HIDE_ON_CLOSE(在 WindowConstants 中定义):调用任意已注册的 WindowListener 对象后自动隐藏该窗体。
    DISPOSE_ON_CLOSE(在 WindowConstants 中定义):调用任意已注册 WindowListener 的对象后自动隐藏并释放该窗体。
    EXIT_ON_CLOSE(在 JFrame 中定义):使用 System exit 方法退出应用程序。仅在应用程序中使用。
    默认情况下,该值被设置为 HIDE_ON_CLOSE。更改此属性的值将导致激发属性更改事件,其属性名称为 “defaultCloseOperation”。

    于是将setDefaultCloseOperation(int operation)的值更改为DO_NOTHING_ON_CLOSE后解决问题

    frame.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
    展开全文
  • Java有Stop按钮退出正在运行的程序

    千次阅读 2017-01-12 10:59:31
    1. 运行界面的主程序,注意 main4.run调用...importjava.awt.FlowLayout;  importjava.awt.event.ActionEvent;  importjava.awt.event.ActionListener; import java.io.IOException;   importjavax.swi

    1.       运行界面的主程序,注意 main4.run调用真正执行任务的程序

     

    importjava.awt.FlowLayout; 

    importjava.awt.event.ActionEvent; 

    importjava.awt.event.ActionListener;

    import java.io.IOException;

     

    importjavax.swing.JButton; 

    import javax.swing.JFrame; 

    importjavax.swing.JPanel; 

     

    public class Test extends JFrame { 

        SheThread thread = null

     

        public Test() { 

            try

                createFrame(); 

                } 

                catch(Exception e) { 

                e.printStackTrace(); 

            } 

        } 

     

        private void createFrame() throws IOException { 

     

            JPanel jp = new JPanel(new FlowLayout()); 

            this.add(jp); 

     

            JButton jbStart = new JButton("start "); 

            JButton jbEnd = new JButton("stop"); 

            //jp.add(jbStart); 

            jp.add(jbEnd); 

     

            this.setSize(300, 100); 

            this.setVisible(true); 

            this.setResizable(false); 

            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

     

            jbStart.addActionListener(new ActionListener() { 

                public voidactionPerformed(ActionEvent e) { 

                    if (thread != null

                        thread.stop()

                    thread = new SheThread(); 

                    thread.start(); 

                } 

            }); 

            jbEnd.addActionListener(new ActionListener() { 

                public voidactionPerformed(ActionEvent e) { 

                    if (thread != null

                        thread.stop();

                      System.exit(0);

                    thread = null

                } 

            }); 

           

            //需要执行的主程序

            Main4.run();

        } 

     

        public static void main(String[] args) { 

            new Test().show()

        } 

     

     

    class SheThread extends Thread { 

        public SheThread() { 

        } 

     

        public void run() { 

            while (true) { 

                try

                    sleep(1000); 

                } catch (InterruptedException e) { 

                } 

                System.out.println("this is a test!"); 

            } 

        } 

     

     

    2.      执行代码的真正程序

    public class Main4 {

        public static int Sub_ID = 0;

        public static String cliuid_2 = "";

        public static String unedname = "";

        public static String search_method = "";

        public static int rawID_Total = 0;

        public static JTextField filename = new JTextField("c:/p.xls");

        public static String URL = "";

        public static JFrame frame = new JFrame();

        public static PrintWriter writer;

        public static DB db;

        public static String str_SQL;

        public static String str_trim = "0000";

        public static String cliuid_2_unedname = "";

        public static String dirName = "";

        public static String fileName_final = "";

     

    ……

    ……

     

        public static void run() throws IOException {

            try {

                input();

                Sheet sheet;

                Workbook book;

                try {

                    book = Workbook.getWorkbook(new File(filename.getText()));

                    sheet = book.getSheet(0);

                    rawID_Total = sheet.getRows(); // 获取行数

                    for (int i = 1; i < rawID_Total; i++) {

                        readExcel(sheet, i);

                        initSearch(unedname, "bingSearch");

                        Sub_ID = 0;

                    }

                    book.close();

                } catch (Exception e) {

                    e.printStackTrace();

                }

            } catch (Exception e2) {

                JOptionPane.showMessageDialog(null, e2.getMessage());

            }

     

            System.exit(0);

        }

    ……

    ……

     

     

    }

     

                                                       

    展开全文
  • Java的GUI代码编写

    千次阅读 2019-08-25 10:13:15
    Java的GUI代码编写 AWT  所有的可以显示出来的图形元素都称为Component,Component代表了所有的可见的图形元素,Component里面有一种比较特殊的图形元素叫Container,Container(容器)在图形界面里面是一种可以...

    Java的GUI代码编写

    AWT

      所有的可以显示出来的图形元素都称为Component,Component代表了所有的可见的图形元素,Component里面有一种比较特殊的图形元素叫Container,Container(容器)在图形界面里面是一种可以容纳其它Component元素的一种容器,Container本身也是一种Component的,Container里面也可以容纳别的Container。

      Container里面又分为Window和Pannel,Window是可以独立显示出来的,平时我们看到的各种各样的应用程序的窗口都可以称为Window,Window作为一个应用程序窗口独立显示出来,Pannel也可以容纳其它的图形元素,但一般看不见Pannel,Pannel不能作为应用程序的独立窗口显示出来,Pannel要想显示出来就必须得把自己装入到Window里面才能显示出来。

      Pannel应用比较典型的就是Applet(JAVA的页面小应用程序),现在基本上已经不用了,AJAX和JAVASCRIPT完全取代了它的应用。

      Window本身又可以分为Frame和Dialog,Frame就是我们平时看到的一般的窗口,而Dialog则是那些需要用户进行了某些操作(如点击某个下拉菜单的项)才出现的对话框,这种对话框就是Dialog。

     

    组件和容器(Component和Container)

      

    Frame

      

    Frame范例:

     package cn.javastudy.summary;
     
     /**学习JAVA的GUI编程编写的第一个图形界面窗口*/
     import java.awt.*;
     
     public class TestFrame {
         public static void main(String args[]) {
             Frame f = new Frame("我的第一个JAVA图形界面窗口");
             /*
              * 这里只是在内存里面创建了一个窗口对象 还不能真正显示出来然我们看到
            */
             f.setBackground(Color.blue);// 设置窗体的背景颜色
             // blue是Color类里面的一个静态常量,可以使用“类名.静态常量名”来访问
             f.setVisible(true);// 设置窗体是否可见
             /*
              * 要想看到在内存里面创建出来的窗口对象, 必须调用setVisble()方法,并且把参数true传入才能看得见窗体 如果传入的参数是false,那么窗体也是看不见的
              */
             f.setSize(400, 400);// 设置窗体的初始大小
             f.setLocation(200, 200);// 设置窗体出现时的位置,如果不设置则默认在左上角(0,0)位置显示
             f.setResizable(false);
            /*
              * 设置窗体能否被改变大小,设置为false后表示不能改变窗体的显示大小 这里将窗体显示的大小设置为200X200,那么窗体的显示只能是这个大小了,不能再使用鼠标拖大或者缩小
              */
         }
     }

    运行结果如下:

     package cn.javastudy.summary;
     
     import java.awt.*;
     public class TestMultiFrame{
     public static void main(String args[]){
            MyFrame f1 = new MyFrame(100,100,200,200,Color.BLUE);
             MyFrame f2 = new MyFrame(300,100,200,200,Color.YELLOW);
             MyFrame f3 = new MyFrame(100,300,200,200,Color.GREEN);
             MyFrame f4 = new MyFrame(300,300,200,200,Color.MAGENTA);
         }
     }
     /*自定义一个类MyFrame,并且从Frame类继承
     这样MyFrame类就拥有了Frame类的一切属性和方法
     并且MyFrame类还可以自定义属性和方法
     因此使用从Frame类继承而来的自定义类来创建图形窗口比直接使用Frame类来创建图形窗口要灵活
     所以一般使用从Frame类继承而来的自定义类创建图形窗口界面比较好,
     不推荐直接使用Frame类来创建图形窗口界面
     */ class MyFrame extends Frame{
         static int id = 0;
         //定义一个静态成员变量id,用来记录创建出来的窗口的数目
         MyFrame(int x,int y,int w,int h,Color color){
             //自定义构成方法,在构造方法体内使用super调用父类Frame的构造方法
             super("MyFrame"+(++id));
             setBackground(color);
             /*使用从父类Frame继承而来的方法设置窗体的相关属性*/
             setLayout(null);
             setBounds(x,y,w,h);
             setVisible(true);
         }
     }

      

    运行结果:

      

    Panel

      

    Panel范例:

     package cn.javastudy.summary;
     
     import java.awt.*;
     public class TestPanel{
         public static void main(String args[]){
             Frame f = new Frame("JAVA Fram With Panel");
             Panel p = new Panel(null);
             f.setLayout(null);
             f.setBounds(300,300,500,500);//这里设置的坐标(300,300)是相对于整个屏幕的
             f.setBackground(new Color(0,0,102));//设置背景颜色时使用三基色(红,绿,蓝)的比例来调配背景色
             p.setBounds(50,50,400,400);//这里设置的坐标(50,50)是相对于Frame窗体的
             p.setBackground(new Color(204,204,255));
             f.add(p);//把Panel容器装入到Frame容器中,使其能在Frame窗口中显示出来
             f.setVisible(true);  
       }
     }

    运行结果如下:

      

     

    布局管理器

     

    第一种布局管理器——FlowLayout

      

      

    测试代码:

     package cn.javastudy.summary;
     
     import java.awt.*;
     
     public class TestFlowLayout {
         public static void main(String args[]) {
             Frame f = new Frame("FlowLayout");
             /*
              * 使用Button类创建按钮 按钮类的其中一个构造方法:Button(String label) label为按钮显示的文本
              */
             Button btn1 = new Button("button1");
             Button btn2 = new Button("button2");
             Button btn3 = new Button("button3");
            /* setLayout方法的定义:public void setLayout(LayoutManager mgr) */
             f.setLayout(new FlowLayout());// 使用流水(Flow)线般的布局
             /* 使用了布局管理器FlowLayout,这里的布局采用默认的水平居中模式 */
             // f.setLayout(new FlowLayout(FlowLayout.LEFT));
             /* 这里在布局的时候使用了FlowLayout.LEFT常量,这样就将按钮设置为左对齐 */
             // f.setLayout(new FlowLayout(FlowLayout.RIGHT));
             /* 这里在布局的时候使用了FlowLayout.RIGHT常量,这样就将按钮设置为右对齐 */
             f.add(btn1);// 把创建出来的按钮放置到Frame窗体中
             f.add(btn2); // 这里并没有设置按钮的大小与位置
             f.add(btn3); // 设置按钮的大小与位置都是由布局管理器来做的
             f.setVisible(true);
             f.setSize(200, 200);
         }
     }

    运行结果如下:

    第二种布局管理器——BorderLayout

      

       

    测试代码:

     package cn.javastudy.summary;
     
     import java.awt.*;
     
     public class TestBorderLayout {
         public static void main(String args[]) {
             Frame f = new Frame("BorderLayout");
            Button btnEast = new Button("East");
             Button btnWest = new Button("West");
             Button btnSouth = new Button("South");
            Button btnNorth = new Button("North");
             Button btnCenter = new Button("Center");
             /*
             * 把按钮放置到Frame窗体时按照东西南北中五个方向排列好 推荐使用这种方式去排列窗体元素,
             * 这样容易检查出错误 因为这样写如果写错了编译器会提示出错
              */
             f.add(btnEast, BorderLayout.EAST);
             f.add(btnWest, BorderLayout.WEST);
             f.add(btnSouth, BorderLayout.SOUTH);
            f.add(btnNorth, BorderLayout.NORTH);
            f.add(btnCenter, BorderLayout.CENTER);
             /*
             * 也可以使用这样的方式排列按钮 在把按钮放置到Frame窗体时使用方向定位的字符串指定按钮的放置位置 
             * 这种使用方向定位的字符串指定按钮的放置方式不推荐使用 一旦写错了方向字符串就不好检查出来
              *  因为即使是写错了仍然可以编译通过
              */
             /*
              * f.add(btnEast,"East"); 
              * f.add(btnWest,"West"); 
              * f.add(btnSouth,"South"); 
              * f.add(btnNorth,"North"); 
              * f.add(btnCenter,"Center");
              */
             f.setSize(200, 200);
             f.setVisible(true);
         }
     }

    运行结果:

    第三种布局管理器——GridLayout(表格布局管理器)

    测试代码:

    package cn.javastudy.summary;
     
      import java.awt.*;
     
     public class TestGridLayout {
        public static void main(String args[]) {
              Frame f = new Frame("GridLayout");
             Button btn1 = new Button("btn1");
             Button btn2 = new Button("btn2");
             Button btn3 = new Button("btn3");
             Button btn4 = new Button("btn4");
             Button btn5 = new Button("btn5");
             Button btn6 = new Button("bnt6");
             f.setLayout(new GridLayout(3, 2));
             /* 把布局划分成3行2列的表格布局形式 */
             f.add(btn1);
             f.add(btn2);
             f.add(btn3);
             f.add(btn4);
             f.add(btn5);
             f.add(btn6);
             f.pack();
             f.setVisible(true);
         }
     }

    运行结果:

    布局练习

    这几种布局管理器可以设置在Frame里面,也可以设置在Panel里面,而Panel本身也可以加入到Frame里面,因此通过Frame与Panel的嵌套就可以实现比较复杂的布局

    实现代码:

     package cn.javastudy.summary;
     
     import java.awt.*;
     public class TestTenButtons{
         public static void main(String args[]){
             /*这里主要是对显示窗体进行设置*/
            Frame f = new Frame("布局管理器的嵌套使用");
             f.setLayout(new GridLayout(2,1));//把整个窗体分成2行1列的表格布局
             f.setLocation(300,400);
             f.setSize(400,300);
             f.setVisible(true);
             f.setBackground(new Color(204,204,255));
             /*这里主要是对Panel进行布局的设置*/
             Panel p1 = new Panel(new BorderLayout());
             Panel p2 = new Panel(new GridLayout(2,1));//p2使用2行1列的表格布局
             Panel p3 = new Panel(new BorderLayout());
             Panel p4 = new Panel(new GridLayout(2,2));//p4使用2行2列的表格布局
             /*这里主要是把按钮元素加入到Panel里面*/
             p1.add(new Button("East(p1-东)"),BorderLayout.EAST);
             p1.add(new Button("West(p1-西)"),BorderLayout.WEST);
             p2.add(new Button("p2-Button1"));
             p2.add(new Button("p2-Button2"));
             /*p1里面嵌套p2,把p2里面的按钮作为p的中间部分装入到p1里面*/
             p1.add(p2,BorderLayout.CENTER);//把p2作为元素加入到p1里面
             
             p3.add(new Button("East(p3-东)"),BorderLayout.EAST);
             p3.add(new Button("West(p3-西)"),BorderLayout.WEST);
             for(int i=0;i<4;i++){
                     p4.add(new Button("p4-Button"+i));
                 }
             /*p3里面嵌套p4,把p4里面的按钮作为p的中间部分装入到p3里面*/
             p3.add(p4,BorderLayout.CENTER);
             
             f.add(p1);//把Panel装入Frame里面,以便于在Frame窗体中显示出来
             f.add(p3);
             
         } 
     }

    运行结果:

    布局管理器总结

     

    事件监听

      

    测试代码一:

     package cn.javastudy.summary;
     
     import java.awt.*;
     import java.awt.event.*;
     
     public class TestActionEvent {
         public static void main(String args[]) {
             Frame f = new Frame("TestActionEvent");
             Button btn = new Button("Press Me");
             Monitor m = new Monitor();/* 创建一个监听对象 */
             btn.addActionListener(m);
             /*
             * 把监听加入到按钮里面,监听按钮的动作, 当按钮触发打击事件时,就会返回一个监听对象e 然后就会自动执行actionPerformed方法
             */
           f.add(btn, BorderLayout.CENTER);
             f.pack();
             addWindowClosingEvent(f);
             /* 调用这个方法可以自动给Frame窗体里面的子图形元素一个合适的初始大小 */
             f.setVisible(true);
         }
        
        /**
          * 点击窗体上的关闭按钮关闭窗体
          * @param f
          */
         private static void addWindowClosingEvent(Frame f){
             f.addWindowListener(new WindowAdapter() {
                 @Override
                 public void windowClosing(WindowEvent arg0) {
                     System.exit(0);
                }
                 
             });
         }
     }
     
     /*
      * 自定义Monitor(监听)类实现事件监听接口ActionListener 一个类要想成为监听类,那么必须实现ActionListener接口
      */
     class Monitor implements ActionListener {
         /* 重写ActionListener接口里面的actionPerformed(ActionEvent e)方法 */
         public void actionPerformed(ActionEvent e) {
             System.out.println("A Button has been Pressed");
         }
     }

    测试代码二:

    package cn.javastudy.summary;
     
     import java.awt.*;
     import java.awt.event.*;
     public class TestActionEvent2{
         public static void main(String args[]){
             Frame f = new Frame("TestActionEvent");
             Button btn1 = new Button("start");
             Button btn2 = new Button("stop");
             Monitor2 m2 = new Monitor2();//创建监听对象
             btn1.addActionListener(m2);
             /*一个监听对象同时监听两个按钮的动作*/
             btn2.addActionListener(m2);
             btn2.setActionCommand("GameOver");//设置btn2的执行单击命令后的返回信息
             f.add(btn1,BorderLayout.NORTH);
             f.add(btn2,BorderLayout.CENTER);
             
             f.pack();
             f.setVisible(true);
         }
     }
     
     class Monitor2 implements ActionListener{
         public void actionPerformed(ActionEvent e){
             System.out.println("a button has been pressed,"+"the relative info is:\n"+e.getActionCommand());
             /*使用返回的监听对象e调用getActionCommand()方法获取两个按钮执行单击命令后的返回信息
             根据返回信息的不同区分开当前操作的是哪一个按钮,btn1没有使用setActionCommand()方法设置
             则btn1返回的信息就是按钮上显示的文本*/
         }
     }

    TextField事件监听

      

    测试代码:

      package cn.javastudy.summary;
     import java.awt.*;
     import java.awt.event.*;
     
     public class TestTextField {
         public static void main(String args[]) {
             new MyFrameTextField();
         }
     }  
     class MyFrameTextField extends Frame {
         MyFrameTextField() {
             TextField tf = new TextField();
             add(tf);
             tf.addActionListener(new Monitor3());
             tf.setEchoChar('*');
             /*
             * 这个setEchoChar()方法是设置文本框输入时显示的字符,这里设置为*, 
            * 这样输入任何内容就都以*显示出来,不过打印出来时依然可以看到输入的内容
              */
             setVisible(true);
             pack();
         }
     }
     
     class Monitor3 implements ActionListener {
         /*
          * 接口里面的所有方法都是public(公共的) 
          * 所以从API文档复制void actionPerformed(ActionEvent e)时 要在void前面加上public
          */
        public void actionPerformed(ActionEvent e) {
             /* 事件的相关信息都封装在了对象e里面,通过对象e的相关方法就可以获取事件的相关信息 */
             TextField tf = (TextField) e.getSource();
             /*
              * getSource()方法是拿到事件源,注意:拿到这个事件源的时候,
              * 是把它当作TextField的父类来对待 
              * getSource()方法的定义是:“public Object getSource()”返回值是一个Object对象,
              * 所以要强制转换成TextField类型的对象 
              * 在一个类里面想访问另外一个类的事件源对象可以通过getSource()方法
              */
             System.out.println(tf.getText());// tf.getText()是取得文本框里面的内容
             tf.setText("");// 把文本框里面的内容清空
         }
     }

    使用TextField类实现简单的计算器

     package cn.javastudy.summary;
     
     import java.awt.*;
     import java.awt.event.*;
    
     public class TestMath {
         public static void main(String args[]) {
             new TFFrame();
         }
     }
    
     /* 这里主要是完成计算器元素的布局 */
     class TFFrame extends Frame {
         TFFrame() {
             /*
              * 创建3个文本框,并指定其初始大小分别为10个字符和15个字符的大小 这里使用的是TextField类的另外一种构造方法 public TextField(int columns)
              */
             TextField num1 = new TextField(10);
             TextField num2 = new TextField(10);
             TextField num3 = new TextField(15);
             /* 创建等号按钮 */
             Button btnEqual = new Button("=");
             btnEqual.addActionListener(new MyMonitor(num1, num2, num3));
             /* 给等号按钮加上监听,让点击按钮后有响应事件发生 */
             Label lblPlus = new Label("+");
             /* “+”是一个静态文本,所以使用Label类创建一个静态文本对象 */
             setLayout(new FlowLayout());
             /* 把Frame默认的BorderLayout布局改成FlowLayout布局 */
             add(num1);
             add(lblPlus);
             add(num2);
             add(btnEqual);
             add(num3);
             pack();
             setVisible(true); 
         }
     }
     
     class MyMonitor implements ActionListener {
         TextField num1, num2, num3;
     
         /*
          * 为了使对按钮的监听能够对文本框也起作用, 
          * 所以在自定义类MyMonitor里面定义三个TextField类型的对象 num1,num2,num3,
          * 并且定义了MyMonitor类的一个构造方法 这个构造方法带有三个TextField类型的参数,
         * 用于接收 从TFFrame类里面传递过来的三个TextField类型的参数 
          * 然后把接收到的三个TextField类型的参数赋值给在本类中声明的 三个TextField类型的参数num1,num2,num3 然后再在actionPerformed()方法里面处理num1,num2,num3
         */
         public MyMonitor(TextField num1, TextField num2, TextField num3) {
             this.num1 = num1;
             this.num2 = num2;
             this.num3 = num3;
         }
     
         public void actionPerformed(ActionEvent e) {
             /* 事件的相关信息都封装在了对象e里面,通过对象e的相关方法就可以获取事件的相关信息 */
             int n1 = Integer.parseInt(num1.getText());/* num1对象调用getText()方法取得自己显示的文本字符串 */
             int n2 = Integer.parseInt(num2.getText());/* num2对象调用getText()方法取得自己显示的文本字符串 */
             num3.setText("" + (n1 + n2));/* num3对象调用setText()方法设置自己的显示文本 */
            num1.setText("");
             /* 计算结束后清空num1,num2文本框里面的内容 */
             num2.setText("");
             // num3.setText(String.valueOf((n1+n2)));
             /* 字符串与任意类型的数据使用“+”连接时得到的一定是字符串,
              * 这里使用一个空字符串与int类型的数连接,这样就可以直接把(n1+n2)得到的int类型的数隐式地转换成字符串了,
              * 这是一种把别的基础数据类型转换成字符串的一个小技巧。
              * 也可以使用“String.valueOf((n1+n2))”把(n1+n2)的和转换成字符串 
              */
         }
     }

    JAVA里面的经典用法:在一个类里面持有另外一个类的引用

     package cn.javastudy.summary;
     
     import java.awt.*;
     import java.awt.event.*;
     
      public class TestMath1 {
         public static void main(String args[]) {
             new TTMyFrame().launchFrame();
             /* 创建出TTMyFrame对象后调用lauchFrame()方法把计算器窗体显示出来 */
         }
     }
     
     /* 做好计算器的窗体界面 */
     class TTMyFrame extends Frame {
         /* 把设计计算器窗体的代码封装成一个方法 */
         TextField num1, num2, num3;
     
         public void launchFrame() {
             num1 = new TextField(10);
             num2 = new TextField(15);
             num3 = new TextField(15);
             Label lblPlus = new Label("+");
             Button btnEqual = new Button("=");
             btnEqual.addActionListener(new MyMonitorbtnEqual(this));
             setLayout(new FlowLayout());
             add(num1);
             add(lblPlus);
             add(num2);
             add(btnEqual);
             add(num3);
             pack();
             setVisible(true);
         }
     }
     
     /*
     * 这里通过取得TTMyFrame类的引用,然后使用这个引用去访问TTMyFrame类里面的成员变量 
     * 这种做法比上一种直接去访问TTMyFrame类里面的成员变量要好得多,
     * 因为现在不需要知道 TTMyFrame类里面有哪些成员变量了,
      * 现在要访问TTMyFrame类里面的成员变量,直接使用 TTMyFrame类对象的引用去访问即可,
     * 这个TTMyFrame类的对象好比是一个大管家, 而我告诉大管家,我要访问TTMyFrame类里面的那些成员变量,
      * 大管家的引用就会去帮我找,不再需要我自己去找了。 
      * 这种在一个类里面持有另一个类的引用的用法是一种非常典型的用法 
      * 使用获取到的引用就可以在一个类里面访问另一个类的所有成员了
      */
     class MyMonitorbtnEqual implements ActionListener {
         TTMyFrame ttmf = null;
     
         public MyMonitorbtnEqual(TTMyFrame ttmf) {
             this.ttmf = ttmf;
         }
     
        public void actionPerformed(ActionEvent e) {
             int n1 = Integer.parseInt(ttmf.num1.getText());
             int n2 = Integer.parseInt(ttmf.num2.getText());
             ttmf.num3.setText("" + (n1 + n2));
             ttmf.num1.setText("");
             ttmf.num2.setText("");
         }
     }

    运行结果如下:

     

    内部类

    内部类的使用范例:

     package cn.javastudy.summary;
     
     import java.awt.*;
     import java.awt.event.*;
     
     public class TestMath3 {
     
         public static void main(String args[]) {
             new MyMathFrame().launchFrame();
         }
     }
     
     class MyMathFrame extends Frame {
         TextField num1, num2, num3;
     
         public void launchFrame() {
            num1 = new TextField(10);     
            num2 = new TextField(15);
            num3 = new TextField(15);
             Label lblPlus = new Label("+");
             Button btnEqual = new Button("=");
             btnEqual.addActionListener(new MyMonitor());
             setLayout(new FlowLayout());
             add(num1);
            add(lblPlus);
             add(num2);
             add(btnEqual);
             add(num3);
             pack();
             setVisible(true);
         }
     
         /*
          * 这个MyMonitor类是内部类,它在MyFrame类里面定义 MyFrame类称为MyMonitor类的包装类
          */
         /*
          * 使用内部类的好处: 
          * 第一个巨大的好处就是可以畅通无阻地访问外部类(即内部类的包装类)的所有成员变量和方法 
          * 如这里的在MyFrame类(外部类)定义的三个成员变量num1,num2,num3, 
          * 在MyMonitor(内部类)里面就可以直接访问 
          * 这相当于在创建外部类对象时内部类对象默认就拥有了一个外部类对象的引用
         */
         private class MyMonitor implements ActionListener {
             public void actionPerformed(ActionEvent e) {
                 int n1 = Integer.parseInt(num1.getText());
                 int n2 = Integer.parseInt(num2.getText());
                 num3.setText("" + (n1 + n2));
                 num1.setText("");
                 num2.setText("");
             }
         }
     }

    内部类带来的巨大好处是:

    1. 可以很方便地访问外部类定义的成员变量和方法
    2. 当某一个类不需要其他类访问的时候就把这个类声明为内部类。

     

    Graphics 类

     测试代码:

    package cn.javastudy.summary;
     
     import java.awt.*;
     public class TestPaint{
         public static void main(String args[]){
             new MyPaint().launchFrame();
             /*在main()方法里面并没有显示调用paint(Graphics g)方法
             可是当创建出Frame窗体后却可以看到Frame窗体上画出了
             圆和矩形,这是因为paint()方法是一个比较特殊的方法
             在创建Frame窗体时会自动隐式调用         当我们把Frame窗体最小化又再次打开时,又会再次调用
             paint()方法重新把圆和矩形在Frame窗体上画出来
         即每次需要重画Frame窗体的时候就会自动调用paint()方法*/
         }
     }
     
     class MyPaint extends Frame{
         public void launchFrame(){
             setBounds(200,200,640,480);
             setVisible(true);
         }
         
         public void paint(Graphics g){
             /*paint(Graphics g)方法有一个Graphics类型的参数g
             我们可以把这个g当作是一个画家,这个画家手里拿着一只画笔
             我们通过设置画笔的颜色与形状来画出我们想要的各种各样的图像*/
             /*设置画笔的颜色*/
             g.setColor(Color.red);
             g.fillOval(100,100,100,100);/*画一个实心椭圆*/
             g.setColor(Color.green);
             g.fillRect(150,200,200,200);/*画一个实心矩形*/
             /*这下面的两行代码是为了写程序的良好编程习惯而写的
             前面设置了画笔的颜色,现在就应该把画笔的初始颜色恢复过来
             就相当于是画家用完画笔之后把画笔上的颜色清理掉一样*/
             Color c = g.getColor();
             g.setColor(c);
         }
     }

    运行结果:

     

    鼠标事件适配器

    测试代码:

     package cn.galc.test;
    
     import java.awt.*;
     import java.awt.event.*;
     import java.util.*;
     public class MyMouseAdapter{
       public static void main(String args[]) {
         new MyFrame("drawing...");
       }
     }
     
     class MyFrame extends Frame {
       ArrayList points = null;
       MyFrame(String s) {
         super(s);
         points = new ArrayList(); 
         setLayout(null);
         setBounds(300,300,400,300); 
         this.setBackground(new Color(204,204,255));
         setVisible(true);
         this.addMouseListener(new Monitor());
         }
         
         public void paint(Graphics g) {
         Iterator i = points.iterator();
         while(i.hasNext()){
           Point p = (Point)i.next();
          g.setColor(Color.BLUE);
           g.fillOval(p.x,p.y,10,10);
           
         }
     
      }
         public void addPoint(Point p){
        points.add(p);
       }
     }
     
     class Monitor extends MouseAdapter {
       public void mousePressed(MouseEvent e) {
         MyFrame f = (MyFrame)e.getSource();
         f.addPoint(new Point(e.getX(),e.getY()));
         f.repaint();
    }
     }

     

    window事件

    测试代码:

    package cn.galc.test;
      
      import java.awt.*;
      import java.awt.event.*;
      public class TestWindowClose{
          public static void main(String args[]){
              new WindowFrame("关闭WindowFrame");
          }
      }
     
     class WindowFrame extends Frame{
         public WindowFrame(String s){
           super(s);
             setBounds(200,200,400,300);
             setLayout(null);
             setBackground(new Color(204,204,255));
             setVisible(true);
             this.addWindowListener(new WindowMonitor());
     /*监听本窗体的动作,把所有的动作信息封装成一个对象传递到监听类里面*/
             
             this.addWindowListener(
             /*在一个方法里面定义一个类,这个类称为局部类,也叫匿名的内部类,
             这里的{……代码……}里面的代码很像一个类的类体,只不过这个类没有名字,所以叫匿名类
             在这里是把这个匿名类当成WindowAdapter类来使用,语法上这样写的本质意义是相当于这个匿名类
             从WindowAdapter类继承,现在new了一个匿名类的对象出来然后把这个对象当成WindowAdapter来使用
             这个匿名类出了()就没有人认识了*/
                 new WindowAdapter(){
                     public void windowClosing(WindowEvent e){
                         setVisible(false);
                         System.exit(-1);
                     }
                 }
             );
         }
         
         /*这里也是将监听类定义为内部类*/
         class WindowMonitor extends WindowAdapter{
             /*WindowAdapter(Window适配器)类实现了WindowListener监听接口
             重写了WindowListener接口里面的所有方法
             如果直接使用自定义WindowMonitor类直接去
             实现WindowListener接口,那么就得要重写WindowListener接口
             里面的所有方法,但现在只需要用到这些方法里面的其中一个方法
             所以采用继承实现WindowListener监听接口的一个子类
             并重写这个子类里面需要用到的那个方法即可
             这种做法比直接实现WindowListener监听接口要重写很多个用不到的方法要简洁方便得多*/
     /*重写需要用到的windowClosing(WindowEvent e)方法*/
             public void windowClosing(WindowEvent e){
                     setVisible(false);/*将窗体设置为不显示,即可实现窗体关闭*/
                     System.exit(0);/*正常退出*/
                 }
         }
     }

     

    键盘响应事件——KeyEvent

    测试代码:

    package cn.galc.test;
     
     import java.awt.*;
     import java.awt.event.*;
     public class TestKeyEvent{
         public static void main(String args[]){
             new KeyFrame("键盘响应事件");
         }
     }
     
     class KeyFrame extends Frame{
         public KeyFrame(String s){
                 super(s);
                 setBounds(200,200,400,300);
                 setLayout(null);
                 setVisible(true);
                 addKeyListener(new KeyMonitor());
             }
         /*把自定义的键盘的监听类定义为内部类
         这个监听类从键盘适配器KeyAdapter类继承
         从KeyAdapter类继承也是为了可以简洁方便
         只需要重写需要用到的方法即可,这种做法比
         直接实现KeyListener接口要简单方便,如果
         直接实现KeyListener接口就要把KeyListener
         接口里面的所有方法重写一遍,但真正用到的
         只有一个方法,这样重写其他的方法但又用不到
         难免会做无用功*/    
         class KeyMonitor extends KeyAdapter{
             public void keyPressed(KeyEvent e){
                     int keycode = e.getKeyCode();
                 /*使用getKeyCode()方法获取按键的虚拟码*/
                 /*如果获取到的键的虚拟码等于up键的虚拟码
                 则表示当前按下的键是up键
                 KeyEvent.VK_UP表示取得up键的虚拟码
                 键盘中的每一个键都对应有一个虚拟码
                 这些虚拟码在KeyEvent类里面都被定义为静态常量
                 所以可以使用“类名.静态常量名”的形式访问得到这些静态常量*/
                     if(keycode == KeyEvent.VK_UP){
                             System.out.println("你按的是up键");
                         }
                 }
             }
     }
     /*键盘的处理事件是这样的:每一个键都对应着一个虚拟的码,
     当按下某一个键时,系统就会去找这个键对应的虚拟的码,以此来确定当前按下的是那个键
    */

     

     

    展开全文
  • 贪吃蛇java代码

    千次阅读 多人点赞 2016-04-20 21:03:58
    贪吃蛇Java代码
  • Java连连看源代码

    千次阅读 2019-01-23 23:08:47
    下面是Java连连看代码,没有图片全部用数字代替十分简陋 package game; import javax.swing.*;  import java.awt.*;  import java.awt.event.*;  public class lianliankan implements ActionListener  {  ...
  • java代码(一)捉弄人小代码

    千次阅读 2019-09-09 20:41:20
    java代码(一)捉弄人小代码 ...捉弄人小代码功能:显示一个窗口,该窗口有一个问题,你点击窗口的叉号时会弹出一个消息框,但无法关闭程序窗口,当鼠标进入“不是”按钮时,按钮的坐标会发生...
  • java退出窗体Jfream操作区别

    千次阅读 2014-09-29 17:53:29
    System.exit(0)是退出整个程序,如果有多个窗口,全部都销毁退出。 frame.setDefaultCloseOperation()是设置用户在此窗体上发起 "close" 时默认执行的操作。必须指定以下选项之一: DO_NOTHING_ON_CLOSE(在 ...
  • Java 记事本代码

    千次阅读 2010-11-27 16:22:00
    Java 记事本源代码
  • JAVA记事本源代码 收藏

    万次阅读 2009-05-24 23:01:00
    JAVA记事本源代码 import java.awt.*; import java.awt.event.*; import java.text.*; import java.util.*; import java.io.*; import javax.swing.undo.*; import javax.swing.*; import javax.swing.event.*; ...
  • Java Web安全之代码审计

    千次阅读 2019-02-13 09:14:00
    通俗的说Java代码审计就是通过审计Java代码来发现Java应用程序自身中存在的安全问题,由于Java本身是编译型语言,所以即便只有class文件的情况下我们依然可以对Java代码进行审计。对于未编译的Java代码文件我们...
  • JAVA 代码

    千次阅读 2015-01-27 18:02:39
    这些源码反映了那时那景笔者对未来的盲目,对代码的热情、执着,对IT的憧憬、向往!此时此景,笔者只专注Android、Iphone等移动平台开发,看着这些源码心中有万分感慨,写此文章纪念那时那景! Java 源码包 ...
  • java聊天室代码

    千次阅读 2007-11-05 13:00:00
    import java.applet.*; import java.awt.*; import java.io.*; import java.net.*; import java.awt.event.*; public class ChatClient extends Applet{ protected boolean loggedIn;//登入状态 protected Frame cp;...
  • java连连看代码

    千次阅读 2007-04-19 10:56:00
    游戏按钮通过数组实现简化了代码. 3.按钮事件统一使用ACTIONLISTENER简化代码,提高事件响应速度. 4.记录按钮是否有被选中的变量使用STRING类型不妥,修改为布尔型. 5.值得提出的地方,数组初始化默认为0,不需要打上30...
  • JAVA贪吃蛇小游戏源代码系列

    万次阅读 多人点赞 2018-12-15 11:00:15
    Java贪吃蛇小游戏之启动界面 package snakeGame;... * 重启界面包括包括两个按钮和一个背景图片,点击重启游戏按钮游戏进入运行界面,点击退出按钮后结束游戏。 */ import java.awt.Color; import java....
  • java sql连接代码 sqlserver的jar包

    万次阅读 2019-05-02 12:10:51
    sql的jar包,把对应jar包放在web-inf的lib下 链接: ... java连接sql代码: package Model; import java.sql.*; public class testdao { public static void main(...
  • JAVA 如何改变按钮大小问题

    千次阅读 2020-02-18 21:35:42
    本人用java写一个小界面,现在有一个面板p1用来存放两个按钮 然后主框架要放三个按钮,并且要改变它的位置和大小使得看起来美观,但现在一使用setBounds方法父容器就要定义为null, 但一旦定义为null我的之前的面板...
  • java 仿QQ聊天代码

    千次阅读 2012-12-01 19:47:25
    本源码实现了群聊和私聊  截图如下: 代码文件清单如下: Client.java、ClientThread.java、Server.java、ServerThread.java共四个java...下面是Client.java代码内容: ======================================
  • 最短路径问题 java实现 源代码

    千次阅读 2010-11-28 14:07:00
    最短路径问题 java实现 源代码下载地址:http://download.csdn.net/source/246269用到的资源文件 文件名 shortPath.propertiesbegin=/u59CB/u53D1/u5730/uFF1A clear=/u6E05 /u9664 clearString=/u6E05/u695A/u7...
  • Java代码的登录界面

    万次阅读 多人点赞 2018-03-17 10:35:46
    Java代码的简单登录界面package loginwindow; import java.awt.Color; import java.awt.Container; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.*; import ...
  • 这样就使我的程序很墨迹~谢了两段重复的代码,请问各位前辈,如果想让按钮实现既可以点击触发又可以按Enter触发应该怎么办?我觉我这种方法很笨,一定不是最好的办法!在此请教各位前辈,谢谢啦!!!
  • Java代码覆盖工具

    千次阅读 2017-10-15 13:07:47
    代码覆盖(code coverage):为了全面地覆盖测试,必须测试程序的状态以及程序流程,设法进入和退出每一个模块,执行每一行代码,进入软件每一条逻辑和决策分支。——[Software Testing] Code coverage is An ...
  • [图片说明](https://img-ask.csdn.net/upload/201505/25/1432560447_766674.jpg)我添加了退出按钮的单击事件,想退出当期应用程序。 这个界面从JFrame继承过来的。setDefaultCloseOperation不管用。 ...
  • java实现中国象棋 源代码

    万次阅读 多人点赞 2019-09-30 18:24:31
    在网上找了很久中国象棋实现的源代码,终于找到了,下面就是源代码。 /* *中国象棋Java版V3.0 *源文件:Chess.java *添加功能:实现了当前棋局的保存 */ import java.awt.*; import java.awt.event.*; import ...
  • java调色板的代码

    千次阅读 2016-07-05 16:39:46
    最近写了一段调色板的代码import java.awt.*; import java.awt.event.*; import javax.swing.*; /*dkplus专业搜集和编写实用电脑软件教程, *搜集各种软件资源和计算机周边,独立制作视频和ppt和音频微信公众号,...
  • java简单五子棋源代码

    万次阅读 2015-12-01 12:48:09
    package com.renyou; import java.awt.Color; import java.awt.Dimension; import java.awt.FlowLayout; import java.awt.Graphics; import java.awt.event.ActionEvent; import java.awt.event.ActionLis
  • 1. 创建一个普通的Frame和然后添加一个按钮,参考教程 2.自制一个MyActionListener 的监听类 2.1 MyActionListener 需要实现implements接口ActionListener public class MyActionListener implements Acti...
  • 按二次返回键退出程序代码

    万次阅读 2015-03-05 09:48:53
    1.在Activity中重写...监听Android设备的返回按钮监听事件 @Override public boolean onKeyDown(int keyCode, KeyEvent event) { // TODO Auto-generated method stub if(keyCode == KeyEvent.KEYCODE_BACK){
  • Java飞机小游戏代码详解

    千次阅读 2019-02-20 23:47:36
    新创建一个窗口,f.launchFrame()用来对窗口的标题(setTitle)、可视化(setVisible)、窗口大小(setSize)、窗口位置(setLocation)信息的初始化以及重写windowClosing方法,确保点击关闭按钮后程序能够完全退出。...
  • Java课程设计- 记事本代码

    万次阅读 多人点赞 2015-12-11 21:43:23
    【1】文件: 新建 打开 保存 另存为 退出 【2】编辑: 剪切 复制 粘贴 删除 撤销 【3】格式: 自动换行 字体格式 字体颜色 查找||替换 【4】查看: 关于记事本 【5】帮助 :帮助选项 【6】显示当前时间 【使用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,943
精华内容 19,177
关键字:

java退出按钮的代码

java 订阅