精华内容
下载资源
问答
  • import javax.swing.*; public class Calendar { public static void main(String[] args) { // Prompt the user to enter input ... String yearInput = JOptionPane.showInputDialog("Enter a year:");...
  • Java对话框形式的输入

    千次阅读 2018-09-28 10:05:19
    //导入javax.swing包中的JOptionPane类,可以获取输入,类似Scanner public class ComputeLoanUsingDialog { public static void main(String[] args) { // TODO 自动生成的方法存根 ...
    
    import javax.swing.JOptionPane;               //导入javax.swing包中的JOptionPane类,可以获取输入,类似Scanner
    
    public class ComputeLoanUsingDialog {
    
    	public static void main(String[] args) {
    		// TODO 自动生成的方法存根
          String annualInterestRateString = JOptionPane.showInputDialog(
        		  "Enter yearly interest rate, for example 8.25: ");  //showinputdialog显示对话框,返回值是以一个字符串变量,赋给annualInterestRateString
          
          double annualInterestRate = Double.parseDouble(annualInterestRateString);  //将字符串类型转换为double类型
          
          double monthlyInterestRate = annualInterestRate/1200;
          
          String numberOfYearsString = JOptionPane.showInputDialog(
        		  "Enter number of years as an integer,\nfor example 5:");
          
          int numberOfYears = Integer.parseInt(numberOfYearsString);
          String loanString = JOptionPane.showInputDialog(
        		  "Enter loan amount, for exmaple 1200000.95:");
          
          double loanAmount = Double.parseDouble(loanString);
          
          double monthlyPayment = loanAmount * monthlyInterestRate / ( 1 - 1 / Math.pow ( 1 + monthlyInterestRate , numberOfYears * 12 ) );
          
          double totalPayment = monthlyPayment*numberOfYears*12;
          
          monthlyPayment=(int)(monthlyPayment*100)/100.0;
          totalPayment = (int)(totalPayment * 100) / 100.0;
          
          String output="The monthly payment is " + monthlyPayment + "\nThe total payment is "+totalPayment;
         
          JOptionPane.showMessageDialog(null,output);
          
    	}
    
    }
    
    

    要注意字符串类型向浮点型的转化以及类的使用写法

    展开全文
  • 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对话框总结

    2017-07-08 20:36:00
    输入 2,选择图标:错误,信息。警告。问题,无或者自己定义 3,选择消息:字符串,图标。自己定义组件或者他们的集合 4。对于确认对话框,选择选项类型(默认,Yes/No,Yes/No/Cancel或者OK/Cancel) 5,对于选项...

    这里写图片描写叙述
    这里写图片描写叙述

    总结起来非常easy:
    1,对话框类型:消息。确认,选项。输入
    2,选择图标:错误,信息。警告。问题,无或者自己定义
    3,选择消息:字符串,图标。自己定义组件或者他们的集合
    4。对于确认对话框,选择选项类型(默认,Yes/No,Yes/No/Cancel或者OK/Cancel)
    5,对于选项对话框,选择选项(字符串,图表或者自己定义组件)和默认选项
    6.对于输入框,选择文本框或者输入框。

    转载于:https://www.cnblogs.com/lytwajue/p/7137932.html

    展开全文
  • 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                   
    }
    
    

    实现效果:实现复制功能

    展开全文
  • 1、 让用户输入三个对话框,前两个对话框输入操作数,第三个对话框输入运算符。运算符包括:加、减、乘、除、取模、自增(++)、自减(–)和字符串相加(+); 2、 第四个对话框让用户选择是否继续。若点击“Yes”...
  • Java 对话框/JDialog类/输入输出技术(20.5.8) Java文件对话框/消息对话框/指令系统简介(20.5.9) 等等… 创建对话框与创建窗口类似,通过建立JDialog的子类来建立一个对话框类,然后这个类的一个实例,即这个子类创建...
  • Java输入对话框 输入对话框只有"确认"和"取消"按钮,通过点击确定按钮后返回输入框中的字符串,否则返回null 使用JOptionPane类的静态方法进行创建 public static String showInputDialog(Component parentComponent,...
  • Java对话框(JDialog类和JOptionPane类)

    千次阅读 2018-02-06 16:49:52
    对话框是一个临时窗口,可以在其中放置用于得到用户输入的控件。在Swing中,有两个对话框类,它们是JDialog类和JOptionPane类。JDialog类提供构造并管理通用对话框;JOptionPane类给一些常见的对话框提供许多便于...
  • Swing中提供了JOptionPane类来实现类似Windows平台下的MessageBox的功能,同样在Java中也有,利用JOptionPane类中的各个static方法来生成各种标准的对话框,实现显示出信息、提出问题、警告、用户输入参数等功能。...
  • 对话框是一个临时窗口,可以在其中放置用于得到用户输入的控件。在Swing中,有两个对话框类,它们是JDialog类和JOptionPane类。JDialog类提供构造并管理通用对话框;JOptionPane类给一些常见的对话框提供许多便于...
  • 对话框输入输出

    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
  • 详细的展现了系统自带的对话框的常用的方法,得到用户不同的选择,或输入的内容。
  • Java输入对话框

    千次阅读 2016-05-16 16:23:35
    public static void showInputDialog(Componet parentComponent,String message,String title,int messageType) 其中messageType的取值有如下: JOptionPane.INFORMATION_MESSAGE JOptionPane.WARNING_MESSAGE ...
  • Swing中提供了JOptionPane类来实现类似Windows平台下的MessageBox的功能,同样在Java中也有,利用JOptionPane类中的各个static方法来生成各种标准的对话框,实现显示出信息、提出问题、警告、用户输入参数等功能。...
  • Swing中提供了JOptionPane类来实现类似Windows平台下的MessageBox的功能,同样在Java中也有,利用JOptionPane类中的各个static方法来生成各种标准的对话框,实现显示出信息、提出问题、警告、用户输入参数等功能。...
  • 1 import javax.swing.JOptionPane; 2 public class ComputeLoanUsingInputDialog { 3 public static void main(String[] args) { 4 String annualInterestRateString = JOptionPane.showInputDial...
  • import javax.swing.JOptionPane; public class InputDialogTest{ public static void main(String...String inputString=JOptionPane.showInputDialog(null,"请输入一个英文单词","输入",JOptionPane.QUESTION_M
  •  JDialog类和JFrame都是Windows的子类,二者的实例都是底层容器,但二者有相似之处也有不同的地方,主要区别是JDialog类创建的对话框必须要依靠于某个窗口。  创建对话框与创建窗口类似,通过建立JDialog的子类来...
  • 文件对话框是一个从文件中选择文件的界面,也就是弹出一保存或者打开文件的对话框,想要真正打开或保存文件需要用到输入输出流 JFileChoose类可以创建文件对话框//创建的是有模式不可见得对话框//调用下面的方法就变得...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,545
精华内容 618
关键字:

java对话框输入

java 订阅