精华内容
下载资源
问答
  • JDialog类和JFrame类都是Window的子类,实例都属于底层容器,唯一的区别就是对话框必须要依赖于某个窗口 同样也是不允许添加到其他容器中 JDialog类的构成方法 JDialog()//无参数的构造方法 JDialog(JFrame owner)//...

    JDialog类

    JDialog类和JFrame类都是Window的子类,实例都属于底层容器,唯一的区别就是对话框必须要依赖于某个窗口
    同样也是不允许添加到其他容器中

    JDialog类的构造方法

    • JDialog()//无参数的构造方法
    • JDialog(JFrame owner)//带依赖者的对话框
    • JDialog(JFrame owner,String title)//带依赖者带标题的对话框
    • JDialog(JFrame owner,String title,boolean modal)//带依赖者带标题的对话框,设置为哪个模式

    其余方法和JFrame类的大致上都可用,但有个是设置模式的

    • setModal(boolean)//设置模式

    对话框的模式

    • 有模式 //当对话框出现是不能再操作当前程序的其他窗口
    • 无模式 //当对话框出现时能自由操作(不阻塞)

    通过例子

    首先创建窗口

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    public class myWindow extends JFrame implements ActionListener {
        JButton jButton;
        JTextArea jTextArea;
        myDialog myDialog;
        myWindow(){
            setTitle("我的窗口");
            setBounds(400,400,400,500);
            setLayout(new FlowLayout());
            Container con = this.getContentPane();
            con.setBackground(new Color(0x366728));
            setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            setVisible(true);
            myDialog = new myDialog(this,"我是对话框",true); //对话框实例化
            jButton = new JButton("点击显示对话框");
            jButton.addActionListener(this);
            add(jButton);
            jTextArea = new JTextArea(10,30);
            add(new JScrollPane(jTextArea));
            validate();
        }
        @Override
        public void actionPerformed(ActionEvent actionEvent) {
            myDialog.setLocation(this.getX()+this.getWidth(),this.getY());  //设置位置
            myDialog.setVisible(true);   //从这里开始停止执行下列代码(阻塞)
            if(myDialog.getMessage() == 1){
                jTextArea.append("在对话框中点了YES\n");
            }
            else if (myDialog.getMessage() == 0){
                jTextArea.append("在对话框中点了NO\n");
            }
            else if (myDialog.getMessage() == -1){
                jTextArea.append("在对话框中点了关闭\n");
            }
        }
    }
    

    然后创建对话框

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    
    public class myDialog extends JDialog implements ActionListener {
        static final int YES = 1,NO = 0;
        int message = -1;
        JButton yes,no;
        myDialog(JFrame jFrame,String s,boolean boo){
            super(jFrame,s,boo);    //调用父类的构造方法
            setSize(200,200);
            setLayout(new FlowLayout());
            yes = new JButton("YES");
            yes.addActionListener(this);
            add(yes);
            no = new JButton(("NO"));
            no.addActionListener(this);
            add(no);
            addWindowListener(new WindowAdapter() {
                @Override
                public void windowClosing(WindowEvent e) {  //当删除对话框时将对话框消失
                    message = -1;
                    setVisible(false);  //不可见
                }
            });
        }
        @Override
        public void actionPerformed(ActionEvent actionEvent) {
            if (actionEvent.getSource() == yes){
                message = YES;
                setVisible(false);  //不可见
            }
            else if(actionEvent.getSource() == no){
                message = NO;
                setVisible(false);
            }
        }
        public int getMessage() {
            return message;
        }
    }
    

    最后进行测试

    public class Example11_1 {
        public static void main(String[] args) {
            myWindow myWindow = new myWindow();
        }
    }
    

    运行结果
    在这里插入图片描述

    • 要注意的是对话框是依赖于当前窗口的,应该在窗口中实例化

    输入/输出技术

    输入输出(I/O)系统是计算机与外界进行数据交换的通道

    1.接口的功能及分类

    接口又称为界面,世界两个相对独立的子系统之间的相连部分

    主要功能有

    • 地址译码功能
    • 在主机和I/O设备间交换数据/控制命令及状态信息
    • 支持主机采用程序查询/中断/DMA等访问方式
    • 提供主机和I/O设备所需的缓冲/暂存/驱动功能
    • 进行数据的类型/格式等方面的转换

    接口的分类

    • 按数据的传送格式分为并行接口和串行接口
    • 按主机访问I/O设备的控制方式,可分为程序查询接口,中断接口,DMA接口以及通道控制器,I/O处理机
    • 按时序控制方式可分为同步接口和异步接口

    2.主机和外设间的连接方式
    主机和外设见得连接方式常见的由总线型,星型,通道方式,和I/O处理机等,其中总线型方式是基本方式

    3.I/O接口的编址方式

    • 与内存单元统一编址
    • I/O接口单独编址

    4.CPU与外设之间的交换数据的方式

    1. 直接程序控制
    2. 中断方式
      所谓的中断就是当CPU正在执行程序的过程中,由于外部的事件发生使得CPU暂时中止正在执行的程序,转去执行另一事件,当事件执行完毕时再回过头来执行未完成的程序//引起中断的事件成为事件源,CPU内部发生的事件成为内部中断源,外部发生的事件成为外部中断源
      //当I/O接口准备好接收数据或准备好向CPU传送数据时,就发出中断信号通知CPU.//从而提高CPU的利用率
      //由于需要执行若干条指令才能处理一次中断事件,因此无法满足高速的批量数据传送要求,所以引入DMA方式
    3. 直接存储器存取方式(DMA)
      基本思想就是采用专用部件生成访存地址并控制访存过程
    4. 通道控制方式

    CSS

    CSS 导航条
    添加链接描述
    CSS 图像透明度

    JavaScript

    JavaScript 函数 Call
    JavaScript 函数 Apply
    JavaScript 闭包

    CET4P169

    industrial
    accord
    screen
    gratitude
    schedule
    preference
    limitation
    error
    disturb
    cancer

    展开全文
  • java 对话框小结

    2020-06-21 17:46:34
    **常用的对话框有 showconfirmdialog(询问一个确认的问题), showinputdialog (提示要求某些输出) , showmessagedialog (通知用户某事已经发生) showoptiondialog (上面的集大成者) , showinternallXxx (通常用于...

    **

    java 自学日记 —— 对话框小结**

     **常用的对话框有  showconfirmdialog(询问一个确认的问题), showinputdialog (提示要求某些输出)  , showmessagedialog (通知用户某事已经发生)  showoptiondialog (上面的集大成者) , showinternallXxx (通常用于内置对话框);** 
    
    1. showconfirmdialog
    	JOptionPane.showConfirmDialog(null, "你喜欢水果吗?","标题",JOptionPane.YES_NO_OPTION);
    

    在这里插入图片描述

    JOptionPane.showConfirmDialog(null," ", "picture ",JOptionPane.OK_CANCEL_OPTION, 
    				JOptionPane.PLAIN_MESSAGE, img);
    

    在这里插入图片描述

    2.showinputdialog

    JOptionPane.showInputDialog(null, "按某些要求来书写","write",JOptionPane.PLAIN_MESSAGE, 
    				img, a,a[1]);
    				String []a= {"aa","bb"};
    

    在这里插入图片描述

    JOptionPane.showInputDialog(null,"你喜欢什么水果");
    

    在这里插入图片描述

    1. showmessagedialog
    JOptionPane.showMessageDialog(null, "message");
    
    1. showoptiondialog
    JOptionPane.showOptionDialog(null, " ","  ",JOptionPane.DEFAULT_OPTION,JOptionPane.QUESTION_MESSAGE,
    				img, a, a[1]);
    

    在这里插入图片描述

    5.showinternalXxx

    test frame = new test();
    					frame.setVisible(true);
    					JInternalFrame ji = new JInternalFrame();
    					frame.add(ji);
    					ji.setVisible(true);
    					JOptionPane.showInternalMessageDialog(ji, "你是否爱好唱歌","爱好选择", JOptionPane.INFORMATION_MESSAGE);
    

    在这里插入图片描述

    参数 :
    1.parentcomponent :他作为此对话框的父对话框的component 该参数为NULL时默认Frame作为父级
    2.message 参数(不用多说,就是字面意思)
    3. icon:在对话框中显示的图标
    4. messagetype 参数: 只有固定5种;
    5. options 参数 : 对底部选项进行更详细的描述;
    6. initialvalue : 默认值;

    展开全文
  • java学习 ##java对话框实现复制功能通过学习文件输出流输入流以及运用swing,可以有效的完成。package hello; import java.io.FileInputStream; import javax.swing.JFileChooser; import javax.swing....

    java学习 ##java对话框实现复制功能

    通过学习文件输出流输入流以及运用swing,可以有效的完成。

    package hello;
    
    
    import java.io.FileInputStream;
    import javax.swing.JFileChooser;
    import javax.swing.filechooser.FileNameExtensionFilter;
    import java.io.*;
    
    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    
    /**
     *
     * @author Administrator
     */
    public class NJFrame extends javax.swing.JFrame {
    
        /**
         * Creates new form NJFrame
         */
        public NJFrame() {
            initComponents();
        }
    
        /**
         * This method is called from within the constructor to initialize the form.
         * WARNING: Do NOT modify this code. The content of this method is always
         * regenerated by the Form Editor.
         */
        @SuppressWarnings("unchecked")
        // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
        private void initComponents() {
    
            jLabel1 = new javax.swing.JLabel();
            jLabel2 = new javax.swing.JLabel();
            jTextField1 = new javax.swing.JTextField();
            jTextField2 = new javax.swing.JTextField();
            jButton1 = new javax.swing.JButton();
            jButton2 = new javax.swing.JButton();
            jButton3 = new javax.swing.JButton();
    
            setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
            setTitle("copy文件");
    
            jLabel1.setText("源文件");
    
            jLabel2.setText("目标位置");
    
            jTextField1.setToolTipText("");
            jTextField1.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    jTextField1ActionPerformed(evt);
                }
            });
    
            jTextField2.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    jTextField2ActionPerformed(evt);
                }
            });
    
            jButton1.setText("浏览");
            jButton1.addMouseListener(new java.awt.event.MouseAdapter() {
                public void mouseClicked(java.awt.event.MouseEvent evt) {
                    jButton1MouseClicked(evt);
                }
            });
            jButton1.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    jButton1ActionPerformed(evt);
                }
            });
    
            jButton2.setText("浏览");
            jButton2.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    jButton2ActionPerformed(evt);
                }
            });
    
            jButton3.setText("复制文件");
            jButton3.addMouseListener(new java.awt.event.MouseAdapter() {
                public void mouseClicked(java.awt.event.MouseEvent evt) {
                    jButton3MouseClicked(evt);
                }
            });
            jButton3.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent evt) {
                    jButton3ActionPerformed(evt);
                }
            });
    
            javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
            getContentPane().setLayout(layout);
            layout.setHorizontalGroup(
                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                .addGroup(layout.createSequentialGroup()
                    .addContainerGap(58, Short.MAX_VALUE)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                        .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                                .addComponent(jLabel2)
                                .addComponent(jLabel1))
                            .addGap(18, 18, 18)
                            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                                .addComponent(jTextField2, javax.swing.GroupLayout.DEFAULT_SIZE, 221, Short.MAX_VALUE)
                                .addComponent(jTextField1))
                            .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                            .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                                .addComponent(jButton1)
                                .addComponent(jButton2))
                            .addGap(33, 33, 33))
                        .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                            .addComponent(jButton3)
                            .addGap(166, 166, 166))))
            );
            layout.setVerticalGroup(
                layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                .addGroup(layout.createSequentialGroup()
                    .addGap(38, 38, 38)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                        .addComponent(jLabel1)
                        .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addComponent(jButton1))
                    .addGap(25, 25, 25)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(jButton2))
                        .addComponent(jLabel2))
                    .addGap(48, 48, 48)
                    .addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE, 38, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addContainerGap(105, Short.MAX_VALUE))
            );
    
            pack();
        }// </editor-fold>                        
    String s_FileName;
    String s_DFileName;
        private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
    JFileChooser chooser = new JFileChooser();
    FileNameExtensionFilter filter = new FileNameExtensionFilter(
    "文本文件(*.txt)", "txt");
    chooser.setFileFilter(filter);
    
    int returnVal = chooser.showOpenDialog(null);
    if(returnVal == JFileChooser.APPROVE_OPTION) {
        String filepath=chooser.getSelectedFile().getPath();
        jTextField1.setText(filepath);
        s_FileName=filepath;
        System.out.println( s_FileName);
       
    }        // TODO add your handling code here:
        }                                        
    
        private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {                                      
    JFileChooser chooser = new JFileChooser();
    FileNameExtensionFilter filter = new FileNameExtensionFilter(
    "JPG & GIF Images", "jpg", "gif");
    chooser.setFileFilter(filter);
    int returnVal = chooser.showOpenDialog(null);
    if(returnVal == JFileChooser.APPROVE_OPTION) {
    System.out.println("You chose to open this file: " +
    chooser.getSelectedFile().getName());
    }        // TODO add your handling code here:
        }                                     
    
        private void jButton3MouseClicked(java.awt.event.MouseEvent evt) {                                      
            // TODO add your handling code here:
        }                                     
    
        private void jTextField2ActionPerformed(java.awt.event.ActionEvent evt) {                                            
            // TODO add your handling code here:
        }                                           
    
        private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {                                         
    try{
    			//定义输入流
    			FileInputStream fis= new FileInputStream(s_FileName);//通过打开一个到实际文件的连接来创建一个 FileInputStream,
                            //该文件通过文件系统中的 File 对象 file 指定。
    			BufferedInputStream bis=new BufferedInputStream(fis);//创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数
    		    //定义输出流
    		    FileOutputStream fos=new FileOutputStream(s_DFileName);//创建一个新的缓冲输出流,以将数据写入指定的底层输出流。
                        //System.out.println("hello");
    		    BufferedOutputStream bos=new BufferedOutputStream(fos);//V创建一个新的缓冲输出流,以将数据写入指定的底层输出流。
    		    DataOutputStream dos=new DataOutputStream(bos);//创建一个新的数据输出流,将数据写入指定基础输出流。
    		    int b;
    		    while((b=bis.read())!=-1)
    		    {
    		    	dos.write(b);//将指定字节(参数 b 的八个低位)写入基础输出流
    		    }
    		    bis.close();
    		    dos.close();
    		}
    		catch(IOException e)
    		{
    			System.err.println(e);
    		}        // TODO add your handling code here:
        }                                        
    
        private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         
    
    
    //初始化文件选择框
    JFileChooser fDialog = new JFileChooser();
    //设置文件选择框的标题 
    fDialog.setDialogTitle("请选择文件");
    //弹出选择框
    fDialog.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
    int returnVal = fDialog.showOpenDialog(null);
    // 如果是选择了文件
    if(JFileChooser.APPROVE_OPTION == returnVal){
           //打印出文件的路径,你可以修改位 把路径值 写到 textField 中
    	 String filepath=fDialog.getSelectedFile().getPath();
             jTextField2.setText(filepath);
             s_DFileName=filepath;
    }        // TODO add your handling code here:
        }                                        
    
        private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {                                            
         // TODO add your handling code here:
        }                                           
    
        /**
         * @param args the command line arguments
         */
        public static void main(String args[]) {
            /* Set the Nimbus look and feel */
            //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
            /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
             * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
             */
            try {
                for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                    if ("Nimbus".equals(info.getName())) {
                        javax.swing.UIManager.setLookAndFeel(info.getClassName());
                        break;
                    }
                }
            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | javax.swing.UnsupportedLookAndFeelException ex) {
                java.util.logging.Logger.getLogger(NJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
            }
            //</editor-fold>
            
            //</editor-fold>
    
            /* Create and display the form */
            java.awt.EventQueue.invokeLater(() -> {
                new NJFrame().setVisible(true);
            });
        }
    
        // Variables declaration - do not modify                     
        private javax.swing.JButton jButton1;
        private javax.swing.JButton jButton2;
        private javax.swing.JButton jButton3;
        private javax.swing.JLabel jLabel1;
        private javax.swing.JLabel jLabel2;
        private javax.swing.JTextField jTextField1;
        private javax.swing.JTextField jTextField2;
        // End of variables declaration                   
    }
    
    

    实现效果:实现复制功能

    展开全文
  • Java 对话框/JDialog类/输入输出技术(20.5.8) Java文件对话框/消息对话框/指令系统简介(20.5.9) 等等… 创建对话框与创建窗口类似,通过建立JDialog的子类来建立一个对话框类,然后这个类的一个实例,即这个子类创建...

    对话框

    相关知识点

    同样地想要了解更多相关的对话框细节可以查看往日的博客
    Java 对话框/JDialog类/输入输出技术(20.5.8)
    Java文件对话框/消息对话框/指令系统简介(20.5.9)
    等等…

    创建对话框与创建窗口类似,通过建立JDialog的子类来建立一个对话框类,然后这个类的一个实例,即这个子类创建的一个对象,就是一个对话框。对话框分为无模式有模式两种。如果一个对话框是有模式的对话框,那么当这个对话框处于激活状态时,只让程序响应对话框内部的事件,程序不能再激活它所依赖的窗口或组件,而且它将堵塞其他线程的执行,直到该对话框消失不可见。无模式对话框处于激活状态时,程序仍能激活它所依赖的窗口或组件,它也不堵塞线程的执行

    import javax.swing.*;
    import java.awt.*;
    
    public class example_1 {
        public static void main(String[] args) {
            JFrame jFrame = new JFrame();
            jFrame.setBounds(500, 500, 500, 500);
            jFrame.setVisible(true);
            jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            JButton jButton = new JButton("打开对话框");
            jButton.addActionListener(e -> {
                JDialog jDialog = new JDialog();
                jDialog.setModal(true); //设置为有模式,默认是无模式的
                jDialog.setBounds(300, 300, 300, 300);
                jDialog.setVisible(true);
            });
            jFrame.add(jButton, BorderLayout.NORTH);
        }
    }
    

    在这里插入图片描述

    相关知识点2

    输入对话框含有供用户输人文本的文本框、“确定”和“取消”按钮,是有模式对话框。

    当输入对话框可见时,要求用户输人一个字符串。通vax.swing包中的JOptionPane类的静态方法:
    public static String showInputDialog(component parentComponent;Object message,String title,int messagerype)可以创建一个输人对话框。

    消息对话框是有模式对话框,进行一个重要的操作动作之前,最好能弹出一个消息对话框。
    可以用javax.swing包中JOptionPane类的静态方法:
    public static void showMessageDialog( Component parentcomponent,String message,String title,int messagerype)创建一个消息对话框。

    public class example_1 {
        public static void main(String[] args) {
            //JOptionPane.showConfirmDialog(null,"请输入一个数字","确认对话框",JOptionPane.YES_NO_OPTION);
            String s = JOptionPane.showInputDialog("请输入:"); //输入对话框
            System.out.println(s);
        }
    }
    

    如果消息对话框的第一个参数为null时,消息对话框会在屏幕正前方显示出来

    汇编程序原理

    汇编语言源程序由若干条语句组成,一个程序中可以有三类语句:指令语句伪指令语句宏指令语句。指令语句又称为机器指令语句,将其汇编后能产生相应的机器代码,这些代码能被CPU直接识别并执行相应的操作。伪指令语句指示汇编程序在汇编源程序时完成某些工作,比如给变量分配存储单元地址,给某个符号赋值等。

    在汇编语言中,将多次重复使用的程序段定义为宏。在程序的任意位置,若需要使用这些程序段,只要在相应的位置使用宏名,
    就相当于使用了这段程序。

    汇编程序的功能是将汇编语言所编写的源程序翻译成机器指令程序。其主要工作包括:将每一条可执行汇编语句转换成对应的机器指令;处理程序中出现的伪指令和宏指令一般需要两次扫描源程序才能完成翻译过程。

    CET4P216

    • bully
    • junk
    • proficinet
    • weird
    • gorgeous
    • commodity
    • overwhelm
    • banquet
    • biologist
    • proverb
    • banknote
    • sparkle
    展开全文
  • import javax.swing.JOptionPane; // import class JOptionPane public class Addition { public static void main( String args[] ) { ... String firstNumber, // first string entered by use...
  • private void build(File file) { // 创建一个ANT项目 Project p = new Project(); // 创建一个默认的监听器,监听项目构建过程中的日志操作 DefaultLogger consoleLogger = new DefaultLogger();...
  • 对话框输入输出

    2016-04-10 10:34:40
    java显示对话框选择文件输出 import java.util.*; import javax.swing.*;public class write { public static void main(String[] args) throws Exception { JFileChooser fileChooser = new JFileChoose
  • import java.util.*; import java.io.*; import javax.swing.JFileChooser; public class ReadFileUsingJFileChooser { /** * @param args * @throws Exception */ public ...
  • 文件对话框是一个从文件中选择文件的界面,也就是弹出一保存或者打开文件的对话框,想要真正打开或保存文件需要用到输入输出流 JFileChoose类可以创建文件对话框//创建的是有模式不可见得对话框//调用下面的方法就变得...
  • package com.zyq; import javax.swing.JFileChooser; import javax.swing.filechooser.FileNameExtensionFilter; ... //打开文件目录对话框的方法,直接运行即可 public static void main(Strin...
  • 实现方法分为两种: 一、直接在后台打印js对话框,原理如下: response.setContentType("text/html; charset=UTF-8"); //转码PrintWriter out = respon...
  • 输出对话框 JOptionPane.showMessageDialog(null,“对话框内容”,“对话框标题”,对话框图案) 可以只写null和对话框内容 即JOptionPane.showMessageDialog(null,“对话框内容”) 二.输入对话框 St...
  • Java中的Dialog、JOptionPane对话框

    千次阅读 2016-06-08 16:03:44
    Java图形化界面中的三大对话框:对话框类(Dialog)、对话框(JOptionPane)、文件对话框(FileDialog)。1、对话框(Dialog) 输出结果: 2、对话框(JOptionPane) 两种方法效果对比: 还是有些不同吧,大家择优选用吧。...
  • 输入信息或者输出信息的标准对话框 2.JoptionPane的类的常见方法: a. public static void showMessageDialog(Component parentComponent, Object message,String title,int messageType) ...
  • java后台 输出弹出框

    千次阅读 2014-03-13 15:29:35
    java在后台输出js弹出对话框 实现方法分为两种: 一、直接在后台打印js对话框,原理如下:  response.setContentType("text/html; charset=UTF-8"); //转码  PrintWriter out = response.getWriter();...
  • Java 输入输出框 JOptionPane 用法

    万次阅读 2013-09-16 22:39:10
    用消息对话框显示文本信息 importjavax.swing.JOptionPane; publicclass WelcomeInMessageDialogBox{ JOptionPane.showMessageDialog(null,”welcometo java”, ”DisplayMessage”,JOptionPane.INFORMATION_...
  • 怎样才能把java输出输出到打印机上呢? 问题补充: 这个不是我想要的。我是想把输出流连到打印机。就像在页面里右击--打印弹出打印对话框出来的效果一样。另外,javascript:window.print()只是打印所在页面。  ...
  • 看到一个代码  照着打完后再理解 ...import java.awt.event.ActionListener;...//通过数据流、序列化和文件系统提供系统输入和输出。 import java.awt.event.ActionEvent; import javax.swing.
  • 怎样才能把java输出输出到打印机上呢? 问题补充: 这个不是我想要的。我是想把输出流连到打印机。就像在页面里右击--打印弹出打印对话框出来的效果一样。另外,javascript:window.print()只是打印所在页面。  ...
  • 对话框输入输出 import java.text.DecimalFormat; import javax.swing.*; public class area { public static void main(String[] args) { DecimalFormat d=new DecimalFormat("0.00"); double length=...
  • 安装eclipse:下载压缩包解压后,运行程序,准备好使用工具,设置好首选项就可以新建Java项目了。 如果看不到要打开的视图,可以选择other,打开对话框。 调试运行程序,输出1000以内的所有奇数:使用for循坏 ...
  • 简单的对话框,相信android SDK提供的差不多可以...功能很简单,就是扫描目录下的文件,然后遍历输出对话框的listview上,加上些事件监听,就OK了,具体功能就不讲了,主要用到的类,就是java.io.File还有listview,

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 490
精华内容 196
关键字:

java对话框输出

java 订阅