精华内容
下载资源
问答
  • 1.摘要:为复习巩固Java语言的...利用Java Applet图形界面首先开始设计一个计算器的界面,定义计算器所需要的按钮并赋给其按钮名称,使得使用计算器简单明了,清晰可见,操作简单。本计算器是由java语言所设计的...

    1.摘要:

    为复习巩固Java语言的基础知识,进一步加深对java语言的理解和掌控。同过本课程设计使自身能够全面的掌握面向对象程序设计的有关概念和开发方法,以便能较全面地理解、掌握和综合运用所学的知识,提高自己的编程能力。利用Java Applet图形界面首先开始设计一个计算器的界面,定义计算器所需要的按钮并赋给其按钮名称,使得使用计算器简单明了,清晰可见,操作简单。本计算器是由java语言所设计的标准计算器,可以进行十进制下的四则运算、开方、立方以及常见的三角函数。界面类似Windows自带的计算器界面,java早期版本以来,抽象窗口工具包为用户界面组件提供了平台独立的API。在AWI中,每个组件都由一个原生的等同组件生成和控制,这个原生组件是由当前的图形窗口系统决定的。与此相对,Swing组件经常被描述为轻量级的,因为他们不需要操作系统本身所带窗口工具包的原生资源来生成。

    关键词:类、对象、窗口、事件源

    2.设计目的及思路

    1、使学生在巩固理论课知识的同时,加强实践能力的提高,理论联系实践。

    2、课程设计为大家提供了一个既动手又动脑,独立实践的机会,将课本上的理论知识和实际有机结合起来,锻炼我们的分析解决实际问题的能力。提高我们适应实际,实践编程的能力。给各个按钮进行算法,利用鼠标点击事件

    3、养成自己独立分析和解决问题的能力。培养在项目开发中创新意识及能力,提高面向对象及java语言的理解

    3.模块功能设计

    以下为多功能计算器的基本功能

    (1)加法

    两个数据进行加操作,可以为小数。

    (2)减法

    两个数据进行减操作,可以为负数相减。

    (3)乘法

    两个数相乘操作。

    (4)除法

    两个数相除操作。

    (5)开平方

    对任意一个数进行开方运算,可以是小数。

    (6)立方

    对任意一个数进行开方运算,可以是小数。

    (7)开根号

    对任意一个数进行开根号运算,可以是小数。

    (8)三角函数

    正弦、余弦、正切、余切的运算操作。

    图1 系统功能图

    4.程序中所用到的变量以及方法

    4.1程序中所用到的容器以及组件

    JFrame                 // 底层容器,常用来添加组件

    JLable                  //  定义标签为用户提供提示信息

    JtextField                //  允许用户在文本框中输入单行文本

    JtextArea                 //   允许用户可以在文本区输入多行文本

    Jpanel                   //   创建一个面板,再向这个面板添加组件,本设计中中视为中间容器

    JButton                   // 允许用户点击按钮

    setTitle                  //设置窗口标题

    setDefaultCloseOperation(int operation)   //设置关闭窗口程序做出怎样的处理

    4.2程序中所用到的容器布局

    FlowLayout();         //组件安装先后顺序从左向右一次排列,一行排满后转到下

    一行排列

    BorderLayout();              //把容器简单的分为东西南北中5个区域

    GridLayout();                //把容器划分为若干行乘若干列的网格区域

    null                      //把容器的布局设置为空布局

    setLayout(布局对象)                 //容器可以使用方法设置自己的布局

    4.3程序中用到的ActionEvent事件

    ActionEvent事件源 :文本框、按钮、菜单项、单选按钮都可以触发ActionEvent事件,即都可以成为ActionEvent事件源。如对于注册了监视器的按钮,如果用户单击按钮,就会触发ActionEvent事件

    注册监视器 :Java规定能触发ActionEvent事件的组件使用方法addActionListener(ActionListener listen)将实现ActionListener接口的类的实例注册为事件源的监视器。

    ActionListener 接口:ActionListener接口在java.awt.event包中,该接口中只有一个方法public void actionPerformed(ActionEvent e)。事件源触发ActionEvent事件后,监视器调用接口中的方法actionPerformed(ActionEvent e)对发生的事件做出处理。当监视器调用actionPerformed(ActionEvent e)方法时,ActionEvent类事先创建的事件对象就会传递给该方法的参数e。

    ActionEvent类本设计中用到 getSource()方法,ActionEvent事件对象调用该方法可以获取发生ActionEvent事件的事件源对象的引用,即getSource()方法将事件源上转型为Object对象,并返回这个上转型对象的引用。

    展开全文
  • java 编程一(计算器)(一)继承:extends: 延伸 拓展;*面向对象的编程中:extends 表示继承语法:子类 extends 父类解释:子类在继承父类已有功能后,可对现有的功能进行修改和新增;特点:1》继承具有传递性特点(一...

    java 编程一(计算器)

    (一)继承:

    extends: 延伸 拓展;

    *面向对象的编程中:extends 表示继承

    语法:子类 extends 父类

    解释:

    子类在继承父类已有功能后,可对现有的功能进行修改和新增;

    特点:

    1》继承具有传递性特点(一个子类继承父类后,也默认继承父类的子类)

    2》继承具有单根性特点:(一个子类只能继承一个父类 而一个父类可以有多个子类)

    说明:

    1》继承可以增强程序代码的可拓展性;

    2》继承是面向对象编程的三大特征之一(封装 继承 多态)

    (二)多态

    父类对象可以使用任意子类创建,而子类对象不能使用父类创建:

    计算器

    按钮:4类

    1>数字键按钮:(NumButton)

    2>运算符按钮:(OperButton)

    3>功能按钮:(ToolButton)

    1>NumButton:

    package com.yonyou.laoningteam.jsq.ui;

    import javax.swing.JButton;

    import event.NumButtonListener;

    public class NumButton extends JButton{

    public NumButton(String text){

    super(text);

    NumButtonListener l = new NumButtonListener();

    this.addMouseListener(l);

    }

    }

    2>OperButton

    package com.yonyou.laoningteam.jsq.ui;

    import javax.swing.JButton;

    import event.OperButtonListener;

    public class OperButton extends JButton {

    public OperButton(String text){

    super(text);

    OperButtonListener l = new OperButtonListener();

    this.addMouseListener(l);

    }

    }

    3>ToolButton

    package com.yonyou.laoningteam.jsq.ui;

    import javax.swing.JButton;

    import event.ToolButtonListener;

    public class ToolButton extends JButton {

    public ToolButton(String text){

    super (text);

    ToolButtonListener l = new ToolButtonListener();

    this.addMouseListener(l);

    }

    }

    展开全文
  • 利用Java Applet图形界面首先开始设计一个计算器的界面,定义计算器所需要的按钮并赋给其按钮名称,使得使用计算器简单明了,清晰可见,操作简单。本计算器是由java语言所设计的标准计算器,可以进行十进制下的四则...
  • 如果你是正在学习Java的初学者,或者打算转行学习Java编程的小白,那么你一定会对Java能够做什么项目...而且这个功能很简单,几乎是很学习Java编程的语言经常会去尝试的第一个小项目。虽然简单,可是能够做到也...

    如果你是正在学习Java的初学者,或者打算转行学习Java编程的小白,那么你一定会对Java能够做什么项目一定很感兴趣。一定希望对Java能够实现哪些东西有所了解。

    今天就为大家简单说一下一些可以用Java编程语言练手的项目。

    0.计算器

    可以用Java语言做一个手机上简单的计算器,可以做到加减乘除。而且这个功能很简单,几乎是很多学习Java编程的语言经常会去尝试的第一个小项目。虽然简单,可是能够做到也是会很有成就感的。

    1.日记软件

    可以用Java制作一个日记软件,可以实现用户的注册、登录以及对日记的各种操作。你可以用这个来实现对自己生活的记录,是一个真正的“日记本”。

    2. Java实现在线协作文档编辑

    多人在线协作文档编辑器是一个很常用的功能,适合小组内的文档编辑;使用java编写代码,应用非常流行的spring mvc框架,引入ckeditor插件,并加入localStorage缓存技术,最终利用Eclipse完成。非常适合Java学习者用于练手。

    e3ed90855b23af6e21befaf8fa9b6765.png

    3.自己的Java编辑器

    使用 Eclipse 开发,配合 Java 语言完成一个 Java 编辑器。它的主要功能:1、Java代码的编辑 2、编译及运行Java程序。

    4.数独计算器

    使用Java实现数独游戏的核心算法,在感受数独的魅力中通过Java编写桌面程序完成数独计算器,完成对Java基础知识点的学习和巩固。

    5.简单的支付平台业务流程

    模拟支付平台上买家付款到支付平台,卖家从支付平台取款的简单业务流程,最终结果以控制台输出形式展现。通过此流程,详细了解 Java 线程与同步。

    5ce96f8cf27000b716c2671a79584977.png

    6.基于 Servlet 的简单验证码图片生成

    通过在后台的 Servlet 生成验证码图片,传递到前台 HTML 页面展示。通过本教程的练习可以进一步熟悉 Servlet、Random 函数、StringBuffer 、OutputStream 等等,掌握基础的验证码生成。

    7.SSM + easyUI 搭建简易的人事管理系统

    SSM(Spring + Spring MVC + MyBatis)框架是媲美于 SSH 框架的轻量级 Java EE 框架。easyUI 是一组基于 jQuery 的 UI 插件集合体,它的目标就是帮助 web 开发者更轻松的打造出功能丰富并且美观的 UI 界面。

    以上几个就是一些学习Java编程过程中逐渐会做会去练习的项目。当然我还有五大企业级项目实战。想学?私信我,私信我,私信我。

    79167fc7a5d404dac34c9ec3c255db77.png

    私信“学习”,还送你《Java编程规划指导手册》,教你规划学习路线

    展开全文
  • 计算器实现了自定义左上角图标的功能。 关键词: 建造者模式 状态模式 命令模式 策略模式 单件模式 计算器 面板 标准型 科学型 程序员 特色型 初等函数 二进制 八进制 十六进制 分解质因数 最简二次根式 ...
  • Java界面编程之复杂计算器

    千次阅读 2019-09-15 20:58:42
    这是上学期Java的期末设计啦,给大家互相借鉴下,加上搜集资料和自己的理解整合处来的一个多功能计算器, 下面看图片及代码,还有有什么问题可以留言哦, 嗯,这里一共分为五个类来写,第一个来类是JSQ是主界面,...

    这是上学期Java的期末设计啦,给大家互相借鉴下,加上搜集资料和自己的理解整合处来的一个多功能计算器,

    下面看图片及代码,还有有什么问题可以留言哦,

    嗯,这里一共分为五个类来写,第一个来类是JSQ是主界面,然后剩下的类都是功能类

    package qm;
    
    import java.awt.*;
    import java.awt.event.*;
    
    import javax.swing.*;
    
    public class JSQ extends Frame implements ActionListener, WindowListener
    {
        private Container container;
        private GridBagLayout layout;
        private GridBagConstraints constraints; 
        private JTextField displayField;         //计算结果显示区
        private String lastCommand;           //保存+,-,*,/,=命令0
        private double result;               //保存计算结果
        private boolean start;           //判断是否为数字的开始
        private JMenuBar menubar;
        private JMenuItem m_exit;
        private JMenuItem m2_ejz;
        private JMenuItem m2_bjz;
        private Dialog dialog;
        private Label label_dialog;
        private JButton button_sqrt;
        private JButton button_plusminus;
        private JButton button_CE;
        private JButton button_cancel;
        private JButton button_1;
        private JButton button_2;
        private JButton button_3;
        private JButton button_4;
        private JButton button_5;
        private JButton button_6;
        private JButton button_7;
        private JButton button_8;
        private JButton button_9;
        private JButton button_0;
        private JButton button_plus;
        private JButton button_minus;
        private JButton button_multiply;
        private JButton button_divide;
        private JButton button_point;
        private JButton button_equal;
        private JButton button_log;
        private JButton button_tan;
        private JButton button_cos;
        private JButton button_sin;
        private JButton button_exp;
    
        public JSQ()       //构造方法设置布局、为按钮注册事件监听器
        {
            super( "科学计算器" );
            this.setLocation( 300,200 );
            this.setSize( 328,424);
            this.setResizable( true );
            this.setLayout( new GridLayout( 7,1 ) );//网格布局
            this.addmyMenu();                   //调用成员方法添加菜单
            displayField = new JTextField( 30 );
            displayField.setBackground(new Color(233,240,247));
            displayField.setForeground(new Color(30,57,91));
    
         // 设置outputField内的默认内容,应该显示为“0”
            displayField.setText("0");
            displayField.setFont(new Font("宋体",Font.BOLD,25));
         			// 禁止从界面(键盘)向outputField输入信息,其内容只能通过程序内部改变
           displayField.setEditable(false);
            this.setResizable(false);
           // displayField.setBackground(Color.blue);
            this.add( displayField );
            //displayField.setEditable( true );
    
            start = true;
            result = 0;
            lastCommand = "=";
    
            JPanel panel0 = new JPanel();
            
    
            panel0.setLayout( new GridLayout( 1,4,4,4 ) );
    
    
            JPanel panel1 = new JPanel();
            panel1.setLayout( new GridLayout( 1,5,4,4 ) );
            this.add( panel1 );
            button_sqrt = new JButton( "sqrt" );//根号
            button_sqrt.setBackground(new Color(233,240,247));
            //button_sqrt.setForeground(new Color(30,57,91));
           // button_sqrt.setBackground(Color.blue);
            button_plusminus = new JButton( "+/-" );
            button_plusminus.setBackground(new Color(233,240,247));
            //button_plusminus.setForeground(new Color(30,57,91));
           //button_plusminus.setBackground(Color.blue);
            button_exp = new JButton( "exp" );//底数e的n次幂
            button_exp.setBackground(new Color(233,240,247));
            //button_exp.setForeground(new Color(30,57,91));
           // button_exp.setBackground(Color.blue);
            button_CE = new JButton( "退位");
            button_CE.setBackground(new Color(233,240,247));
            button_CE.setForeground(new Color(30,57,91));
           // button_CE.setBackground(Color.blue);
            button_cancel = new JButton( "CE" );//清除
            button_cancel.setBackground(new Color(233,240,247));
            button_cancel.setForeground(new Color(30,57,91));
           // button_cancel.setBackground(Color.blue);
    
            JPanel panel2 = new  JPanel();
            panel2.setLayout( new GridLayout( 1,5,4,4 ) );
            this.add( panel2 );
            button_7 = new JButton( "7" );
            button_7.setBackground(new Color(233,240,247));
            button_7.setForeground(new Color(30,57,91));
           // button_7.setBackground(Color.blue);
            button_8 = new JButton( "8" );
            button_8.setBackground(new Color(233,240,247));
            button_8.setForeground(new Color(30,57,91));
    
           // button_8.setBackground(Color.blue);
            button_9 = new JButton( "9" );
            button_9.setBackground(new Color(233,240,247));
            button_9.setForeground(new Color(30,57,91));
    
          //  button_9.setBackground(Color.blue);
            button_log = new JButton( "log" );//对数
            button_log.setBackground(new Color(233,240,247));
            button_log.setForeground(new Color(30,57,91));
    
          //  button_log.setBackground(Color.blue);
            button_divide = new JButton( "/" );//除
            button_divide.setBackground(new Color(233,240,247));
            button_divide.setForeground(new Color(30,57,91));
    
          //  button_divide.setBackground(Color.blue);
    
            JPanel panel3 = new JPanel();
            panel3.setLayout( new GridLayout(1,5,4,4) );
            this.add( panel3 );
            button_4 = new JButton( "4" );
            button_4.setBackground(new Color(233,240,247));
            button_4.setForeground(new Color(30,57,91));
    
           // button_4.setBackground(Color.blue);
            button_5 = new JButton( "5" );
            button_5.setBackground(new Color(233,240,247));
            button_5.setForeground(new Color(30,57,91));
    
          //  button_5.setBackground(Color.blue);
            button_6 = new JButton( "6" );
            button_6.setBackground(new Color(233,240,247));
            button_6.setForeground(new Color(30,57,91));
    
           // button_6.setBackground(Color.blue);
            button_tan = new JButton( "tan" );//正切
            button_tan.setBackground(new Color(233,240,247));
            button_tan.setForeground(new Color(30,57,91));
    
           //.setBackground(Color.blue);
            button_multiply = new JButton( "*" );//乘法
            button_multiply.setBackground(new Color(233,240,247));
            button_multiply.setForeground(new Color(30,57,91));
    
          //  button_multiply.setBackground(Color.blue);
    
            JPanel panel4=new  JPanel();
            panel4.setLayout( new GridLayout( 1,5,4,4 ) );
            this.add(panel4);
            button_1 = new JButton( "1" );
            button_1.setBackground(new Color(233,240,247));
            button_1.setForeground(new Color(30,57,91));
    
          //  button_1.setBackground(Color.blue);
            button_2 = new JButton( "2" );
            button_2.setBackground(new Color(233,240,247));
            button_2.setForeground(new Color(30,57,91));
    
           // button_2.setBackground(Color.blue);
            button_3 = new JButton( "3" );
            button_3.setBackground(new Color(233,240,247));
            button_3.setForeground(new Color(30,57,91));
    
          //  button_3.setBackground(Color.blue);
            button_cos = new JButton( "cos");//余弦
            button_cos.setBackground(new Color(233,240,247));
            button_cos.setForeground(new Color(30,57,91));
    
           // button_cos.setBackground(Color.blue);
            button_minus = new JButton( "-" );
            button_minus.setBackground(new Color(233,240,247));
            button_minus.setForeground(new Color(30,57,91));
    
           // button_minus.setBackground(Color.blue);
    
            JPanel panel5 = new  JPanel();
            panel5.setLayout( new GridLayout( 1,5,4,4 ) );
            this.add( panel5 ); 
            
            button_point=new JButton( "." );
            button_point.setBackground(new Color(233,240,247));
            button_point.setForeground(new Color(30,57,91));
    
            button_0 = new JButton( "0" );
            button_0.setBackground(new Color(233,240,247));
            button_0.setForeground(new Color(30,57,91));
    
           // button_0.setBackground(Color.blue);
          //  button_point=new JButton( "." );
           // button_point.setBackground(new Color(233,240,247));
           // button_point.setForeground(new Color(30,57,91));
    
            //button_point.setBackground(Color.blue);
           
            button_equal = new JButton( "=" );
            button_equal.setBackground(new Color(233,240,247));
            button_equal.setForeground(new Color(30,57,91));
    
           // button_equal.setBackground(Color.blue);
            button_sin = new JButton( "sin" );//正弦
            button_sin.setBackground(new Color(233,240,247));
            button_sin.setForeground(new Color(30,57,91));
    
           // button_sin.setBackground(Color.blue);
            button_plus = new JButton( "+" );
            button_plus.setBackground(new Color(233,240,247));
            button_plus.setForeground(new Color(30,57,91));
    
           // button_plus.setBackground(Color.blue);
    
            panel1.add( button_sqrt );
            panel1.add( button_plusminus );
            panel1.add( button_exp );
            panel1.add( button_CE );
            panel1.add( button_cancel );
            panel2.add( button_7 );
            panel2.add( button_8 );
            panel2.add( button_9 );
            panel2.add( button_log );
            panel2.add( button_divide );
            panel3.add( button_4 );
            panel3.add( button_5 );
            panel3.add( button_6 );
            panel3.add( button_tan );
            panel3.add( button_multiply );
            panel4.add( button_1 );
            panel4.add( button_2 ); 
            panel4.add( button_3 );
            panel4.add( button_cos );
            panel4.add( button_minus );
            panel5.add( button_point );
            panel5.add( button_0 );
           // panel5.add( button_point );
            panel5.add( button_equal );
            panel5.add( button_sin );
            panel5.add( button_plus) ;
    
            button_sqrt.addActionListener( this );
            button_plusminus.addActionListener( this );
            button_exp.addActionListener( this );
            button_CE.addActionListener( this );
            button_cancel.addActionListener( this );
            button_7.addActionListener( this );
            button_8.addActionListener( this );
            button_9.addActionListener( this );
            button_log.addActionListener( this );
            button_divide.addActionListener( this );
            button_4.addActionListener( this );
            button_5.addActionListener( this );
            button_6.addActionListener( this );
            button_tan.addActionListener( this );
            button_multiply.addActionListener( this );
            button_1.addActionListener( this );
            button_2.addActionListener( this );
            button_3.addActionListener( this );
            button_cos.addActionListener( this );
            button_minus.addActionListener( this );
            button_0.addActionListener( this );
            button_point.addActionListener( this );
            button_equal.addActionListener( this );
            button_sin.addActionListener( this );
            button_plus.addActionListener( this );
    
            this.addWindowListener( new WinClose() );      //注册窗口监听器
            this.setVisible( true );
            
    		    }
       
    
        private void addmyMenu()        //菜单的添加
        {   
            JMenuBar menubar = new JMenuBar(); 
            this.add( menubar );
            JMenu m1 = new JMenu( "查看" );
            JMenu m2 = new JMenu( "进制转换" );
            
            
            JMenuItem m1_standardcalculator=new JMenuItem("标准型计算器");
            m1_standardcalculator.addActionListener(this);
            JMenuItem m1_exit = new JMenuItem( "退出" );
            m1_exit.addActionListener( this );
            JMenuItem m2_ejz = new JMenuItem( "二进制" );
            m2_ejz.addActionListener( this );
            JMenuItem m2_ternary=new JMenuItem("三进制");
            m2_ternary.addActionListener(this);
            JMenuItem m2_bjz = new JMenuItem("八进制");
            m2_bjz.addActionListener( this );
            JMenuItem m2_sljz = new JMenuItem("十六进制");
            m2_sljz.addActionListener( this );
    
            JMenu m3 = new JMenu( "帮助" ); 
            JMenuItem m3_Help = new JMenuItem( "用法" ); 
            m3_Help.addActionListener( this ); 
            
    
           // dialog = new Dialog( this, "提示" , true );     //模式窗口
           // dialog.setSize( 240,80 );
            //label_dialog = new Label("", Label.CENTER );   //标签的字符串为空,居中对齐
           // dialog.add( label_dialog ); 
            //dialog.addWindowListener( this );          //为对话框注册窗口事件监听器
            
            JMenu m4 =new JMenu("关于");
            JMenuItem m4_developer=new JMenuItem("开发者");
           
            m4_developer.addActionListener(this);
           // dialog =new Dialog(this,"",true);
           // dialog.setSize(380,100);
           // label_dialog =new Label("",Label.CENTER);
           // dialog.add(label_dialog);
            //dialog.addWindowListener(this);
            
            
            JMenuItem m4_developmentTime=new JMenuItem("开发时间");
            m4_developmentTime.addActionListener(this);
            dialog =new Dialog(this,"",true); //模式窗口
            dialog.setSize(380,100);
            label_dialog =new Label("",Label.CENTER); //标签的字符串为空,居中对齐
            dialog.add(label_dialog);
            dialog.addWindowListener(this);//为对话框注册窗口事件监听器
            
            
           
            JMenuItem m5_unitconversion = new JMenuItem( "单位转换器" ); 
            m5_unitconversion .addActionListener( this ); 
            
            JMenuItem m6_Temperature = new JMenuItem( "温度转换器" ); 
            m6_Temperature.addActionListener( this ); 
            m6_Temperature.setBackground(new Color(233,240,247));
            m6_Temperature.setForeground(new Color(30,57,91));
    
            m6_Temperature.setBackground(new Color(233,240,247));
            m6_Temperature.setForeground(new Color(30,57,91));
    
            m6_Temperature.setBackground(new Color(233,240,247));
            m6_Temperature.setForeground(new Color(30,57,91));
    
          
        
            
            m1.add(m1_standardcalculator);
            m1.add(m5_unitconversion); 
            m1.add(m6_Temperature);
            m1.add( m1_exit );  
           
            menubar.add( m1 );
            m2.add( m2_ejz );
            m2.add(m2_ternary);
            m2.add( m2_bjz );
            m2.add( m2_sljz );
            menubar.add( m2 );
            m3.add( m3_Help ); 
            menubar.add( m3 );  
            m4.add(m4_developer);
            m4.add(m4_developmentTime);
            menubar.add(m4);
            
            
            m6_Temperature.setBackground(new Color(233,240,247));
            m6_Temperature.setForeground(new Color(30,57,91));
    
          
        
        }
    
        public void actionPerformed(ActionEvent e)       //按钮的单击事件处理方法
        {
            if(
                    e.getSource().equals( button_1 )||e.getSource().equals( button_2 )|| 
                    e.getSource().equals( button_3 )||e.getSource().equals( button_4 )||
                    e.getSource().equals( button_5 )|| e.getSource().equals( button_6 )||
                    e.getSource().equals( button_7 )|| e.getSource().equals( button_8 )||
                    e.getSource().equals( button_9 ) ||e.getSource().equals( button_0 )||
                    e.getSource().equals( button_point )||e.getSource().equals( button_plusminus )||    
                    e.getSource().equals( button_cancel )||e.getSource().equals( button_CE )
              )
            {      //非运算符的处理方法
                String input = e.getActionCommand();
    
                if ( start )
                {
                    displayField.setText("");
                    start = false;
                    if( input.equals( "+/-" ) )
                        displayField.setText( displayField.getText()+ "-" ); 
                }
                if( !input.equals( "+/-" ) )
                {
                    String str = displayField.getText();
                    if( input.equals( "退位") )          //退格键的实现方法
                    {       
                        if( str.length() > 0 )
                            displayField.setText( str.substring( 0,str.length() - 1 ) );
                    }
                    else if( input.equals( "CE" ) )         //清零键的实现方法
                    {
                        displayField.setText( "0");
                        start = true;
                    }   
                    else
                        displayField.setText( displayField.getText() + input );
                }
            }
            else if ( e.getActionCommand()=="二进制")  //二进制的转换
            {
                int n = Integer.parseInt( displayField.getText() );
                displayField.setText(Integer.toBinaryString(n));
                
                //displayField.setText( Integer.toBinaryString( n ) );
            	//SysConvert2 a=new SysConvert2();
            	//a.main(null);
            	//SysConvert2 convert = new SysConvert2();
        		//convert.setVisible(true);
        		//this.dispose();
            }
            else if(e.getActionCommand()=="三进制")//三进制的转换
            {
            	int n=Integer.parseInt(displayField.getText());
            	displayField.setText(Integer.toString(n,3));
            }
            else if ( e.getActionCommand() == "八进制" )    //八进制的转换
            {
               int n = Integer.parseInt( displayField.getText() );
                displayField.setText( Integer.toOctalString( n ) );
            	//displayField.setText(Integer.toBinaryString(n));
                
            }
            else if ( e.getActionCommand() == "十六进制" )   //十六进制的转换
            {
                int n = Integer.parseInt( displayField.getText() );
                displayField.setText( Integer.toHexString( n ) );
            }
           
            else if(e.getActionCommand()=="标准型计算器")
            {
            	this.dispose();
            	StandardCalculator sc=new StandardCalculator();
            	sc.main(null);
            }
            
            else if(e.getActionCommand()=="单位转换器")
            {
            	this.dispose();
            	UnitTransfer un=new UnitTransfer();
            	un.main(null);
            	
            }
            
            else if(e.getActionCommand()=="温度转换器")
            {
            	WenDuChang  wd=new WenDuChang();
            	this.dispose();
            }
    
            else if ( e.getActionCommand() == "退出" )      //选项中退出的处理方法
            {
                System.exit( 0 );
            }
            
            else if ( e.getActionCommand() == "用法" )      //按下'帮助'菜单栏中用法的处理方法
            {   
                label_dialog.setText( "sqrt,exp等键是先输运算符再输数字,先输入数字再点进制转换\n" ); 
                dialog.setLocation( 400,250 );
                dialog.setVisible( true );  
            }
            
            else if(e.getActionCommand()=="开发者")
            {
                label_dialog.setText( "182017331,陈锦贤  182017505, 吴洪缤    182017190,王浩铸" ); 
                dialog.setLocation( 400,250 );
                dialog.setVisible( true );  
            }
            
            else if(e.getActionCommand()=="开发时间")
            {
            	label_dialog.setText( "开发于2019年6月17号" ); 
                dialog.setLocation( 400,250 );
                dialog.setVisible( true );  
             }
            
            else        //各运算符的识别
             {
                String command = e.getActionCommand();     
                
                if( start )
                {
                    lastCommand = command;
                }
                
                else
                {
                    calculate( Double.parseDouble( displayField.getText() ) );
                    lastCommand = command;
                    start = true;
                }
             }
        }
    
        public void calculate( double x )          //各运算符的具体运算方法
        {
            double d = 0;
            if ( lastCommand.equals( "+" ) ) 
                result += x;    
            
            else if (lastCommand.equals( "-" ) ) 
                result -= x;
            
            else if ( lastCommand.equals( "*" ) ) 
                result *= x;   
            
            else if ( lastCommand.equals( "/" ) ) 
                result /= x;
            
            else if ( lastCommand.equals( "=" ) ) 
                result = x;
            
            else if ( lastCommand.equals( "sqrt" ) ) 
            {
                d = Math.sqrt( x );
                result = d;
                
            }
            else if ( lastCommand.equals( "exp" ) )
            {
                d = Math.exp( x );
                result = d;
                
            }
            else if ( lastCommand.equals( "log" ) )
            {
                d = Math.log( x );
                result = d;
                
            }
            else if ( lastCommand.equals( "tan" ) )
            {
                d = Math.tan(x);
                result = d;
                
            }
            else if ( lastCommand.equals( "cos" ) )
            {
                d = Math.cos( x );
                result = d;
                
            }
            else if ( lastCommand.equals( "sin" ) )
            {
                d = Math.sin( x );
                result = d;
                
            }
            displayField.setText( ""+ result );
            
         }   
    
        public void windowClosing( WindowEvent e )
        {
            if( e.getSource() == dialog )
                dialog.setVisible( false );           //隐藏对话框
            else
                System.exit( 0 ); 
        }
    
        public void windowOpened( WindowEvent e )         {  }
        
        public void windowActivated( WindowEvent e )      {  }
        
        public void windowDeactivated( WindowEvent e )    {  }
        
        public void windowClosed( WindowEvent e )         {  }
        
        public void windowIconified( WindowEvent e )      {  }
        
        public void windowDeiconified( WindowEvent e )    {  }
    
        public static void main( String args[] )          
        {
            JSQ calculator = new JSQ();
        }
    }
    
    class WinClose implements WindowListener
    
    {
        public void windowClosing( WindowEvent e )    //单击窗口关闭按钮时触发并执行实现窗口监听器接口中的方法
        {
            System.exit( 0 );          //结束程序运行
            
        }
        public void windowOpened( WindowEvent e ){ }
        
        public void windowActivated( WindowEvent e ){}
        
        public void windowDeactivated( WindowEvent e){ }
        
        public void windowClosed( WindowEvent e ){ }
        
        public void windowIconified( WindowEvent e ){ }
        
        public void windowDeiconified( WindowEvent e ){ }
        
    }
    
    
    //第二个类
    package qm;
    
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.KeyAdapter;
    import java.awt.event.KeyEvent;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.math.BigDecimal;
    import javax.swing.*;
    import javax.swing.border.Border;
    import javax.swing.border.LineBorder;
    public class StandardCalculator extends JFrame{
    	private JTextField display1,display2,display3;
    	private JButton num[],operate[];
    	private String name[]={"MC","MR","MS","M+","M-","←","CE","C","±","√","7","8","9","/","%","4","5","6","*","1/x","1","2","3","-","=","0",".","+"};
    	private operateNum op1=new operateNum(),op2=new operateNum();//操作数1,操作数2
    	private storageField storage=new storageField();//存储区
    	private String action="op1";//表示要操作的对象  "op1"操作第一个操作数,"op2"操作第二个操作数
    	private String sign="";//运算符,默认为空
    	private String screen1,screen2;
    	private boolean Disable=false;
    	public StandardCalculator()
    	{
    		super("标准计算器");
    		this.setLayout(null);
    		this.setSize(328, 424);
    		this.setResizable(false);	  
             this.setLocation(300,200);
             this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
              display1=new JTextField(30);
            //  this.add(display1);
             // display1.setEditable(true);  
    		final StandardCalculator a = this;
    		JPanel jp=new JPanel(null);
    
    		//jp.setBounds(10,15,getWidth()-24,getHeight());
    		jp.setBounds(10,15,getWidth()-24,getHeight());
    		jp.setBackground(new Color(217,228,241));
    		this.getContentPane().setBackground(new Color(217,228,241));
    		/**显示屏**/
    		display1=new JTextField("");
    		display2=new JTextField("0");
    		display3=new JTextField("");
    		jp.add(display1);
    		jp.add(display3);
    		jp.add(display2);
    		this.add(jp);
    		display1.setEnabled(false);
    		display2.setEnabled(false);
    		display3.setEnabled(false);
    		display1.setBounds(0, 0, 200, 34);
    		display2.setBounds(20, 20, 180, 34);
    		display3.setBounds(0, 20, 30, 34);
    		
    		
    		display1.setHorizontalAlignment(JLabel.RIGHT);
    		display2.setHorizontalAlignment(JLabel.RIGHT);
    		display3.setHorizontalAlignment(JLabel.CENTER);
    		display1.setFont(new Font("宋体",Font.PLAIN,12));
    		display2.setFont(new Font("宋体",Font.BOLD,20));
    		display3.setFont(new Font("宋体",Font.PLAIN,20));
    		display1.setDisabledTextColor(Color.BLACK);
    		display2.setDisabledTextColor(Color.BLACK);
    		display3.setDisabledTextColor(Color.BLACK);
    		display1.setBorder(new LineBorder(new Color(242,247,252)));
    		display2.setBorder(new LineBorder(new Color(242,247,252)));
    		display3.setBorder(new LineBorder(new Color(242,247,252)));
    		display1.setBackground(new Color(242,247,252));
    		display2.setBackground(new Color(242,247,252));
    		display3.setBackground(new Color(242,247,252));
    		/**按钮 35px*29px 28个***/
    		int i;
    		operate=new JButton[28];
    		/**前24个**/
    		for(i=0;i<24;i++)
    		{
    			operate[i]=new JButton(name[i]);
    			operate[i].setMargin(new java.awt.Insets(0,0,0,0)); 
    			
    			operate[i].setBounds(i%5*(35+7+15), 60+i/5*(29+5+15)+5, 35, 29);
    			jp.add(operate[i]);
    		}
    		
    		JButton jb1= new JButton("返回");     //返回复杂计算器
    		jb1.setBackground(new Color(233,240,247));
            jb1.setForeground(new Color(30,57,91));
    
    		jb1.setVisible(true);
    		jb1.setBounds(210, 0, 110, 40);
    		jb1.addActionListener(new ActionListener()
    		{
    			@Override
    			public void actionPerformed(ActionEvent e) {
    				a.setVisible(false);
    				JSQ calculator = new JSQ();
    			
    			}
    		});
    		
    		jp.add(jb1);
    			
          //添加按钮
    	
    		/***=号***/
    		operate[i]=new JButton(name[i]);
    		operate[i].setMargin(new java.awt.Insets(0,0,0,0)); 
    		operate[i].setBounds(i%5*(35+7+15), 60+i/5*(29+5+15)+5, 35, 29*2+5);
    		jp.add(operate[i]);
    		i++;
    		/***0号***/
    		operate[i]=new JButton(name[i]);
    		operate[i].setMargin(new java.awt.Insets(0,0,0,0)); 
    		operate[i].setBounds(i%5*(35+7+15), 60+i/5*(29+5+15)+5, 35*2+7, 29);
    		jp.add(operate[i]);
    		/**前24个**/
    
    		for(i=i+1;i<name.length;i++)
    		{
    			operate[i]=new JButton(name[i]);
    			operate[i].setMargin(new java.awt.Insets(0,0,0,0)); 
    			operate[i].setBounds((i+1)%5*(35+7+15), 60+i/5*(29+5+15)+5, 35, 29);
    			jp.add(operate[i]);
    		}
    		
    		/**
    		 * 给按钮注册鼠标监听器,键盘监听器和背景
    		 */
    		mouseAdapter ml=new mouseAdapter();
    		keyAdapter kl=new keyAdapter();
    		
        //算法的介绍
    	         
    		for(i=0;i<name.length;i++)
    		{
    			operate[i].addMouseListener(ml);
    			operate[i].addKeyListener(kl);
    			operate[i].setBackground(new Color(233,240,247));
    			operate[i].setForeground(new Color(30,57,91));
    		}
    		jp.add(display1);
    		jp.add(display2);
    		jp.add(display3);
    		jp.addKeyListener(kl);
    		this.add(jp);
    		this.setVisible(true);	          
    	}
    	     
    	class mouseAdapter extends MouseAdapter{
    		public void mouseClicked(MouseEvent e)
    		{
    			
    			JButton operate=(JButton)e.getSource();
    			
    
    			if(Disable)//禁用按钮,点击C 恢复计算器
    			{
    				if(operate.getText()=="C")
    				{	clear();
    					Disable=false;
    				}
    				else
    					return;
    			}
    			if(operate.getText().equals("MC")){
    				mc();
    				//return;
    				
    			}
    			if(operate.getText().equals("MR")){
    				mr();
    				//return;
    				
    			}
    			if(operate.getText().equals("MS")){
    				ms();
    				//return;
    				
    			}
    			if(operate.getText().equals("M+")){
    				mAdd();
    				//return;
    				
    			}
    			if(operate.getText().equals("M-")){
    				mCut();
    				//return;
    				
    			}
    		   if(operate.getText().equals("←")){
    			   cutEnd();
    			  // return;
    				
    				
    			}
    		   if(operate.getText().equals("CE")){
    				cutNum();
    				//return;
    				
    			}
    		   if(operate.getText().equals("C")){
    				clear();
    				//return;
    				
    			}
    		   if(operate.getText().equals("±")){
    				revolt();
    				//return;
    				
    			}
    		   if(operate.getText().equals("√")){
    				sqrt();
    				//return;
    				
    			}
    		   if(operate.getText().equals("7")||operate.getText().equals("8")||operate.getText().equals("9")||operate.getText().equals("4")||operate.getText().equals("5")||operate.getText().equals("6")||operate.getText().equals("3")||operate.getText().equals("2")||operate.getText().equals("1")||operate.getText().equals("0")){
    			   read(Integer.parseInt(operate.getText()));
    				
    			}
    		   if(operate.getText().equals("/")){
    				divide();
    				
    			}			
    		   if(operate.getText().equals("%")){
    				mo();
    				
    			}
    		   if(operate.getText().equals("*")){
    				mul();
    			}
    		   if(operate.getText().equals("1/x")){
    				inverted();
    			}
    		   if(operate.getText().equals("-")){
    				cut();
    				
    			}
    		   if(operate.getText().equals("+")){
    				add();
    			}
    		   if(operate.getText().equals("=")){
    				sum();
    			}
    		   if(operate.getText().equals(".")){
    				dot();
    				
    			}
    //		   switch(operate.getText())	
    //			{
    //			case "MC":mc();break;
    //			case "MR":mr();break;
    //			case "MS":ms();break;
    //			case "M+":mAdd();break;
    //			case "M-":mCut();break;
    //			case "←":cutEnd();break;
    //			case "CE":cutNum();break;
    //			case "C":clear();break;
    //			case "±":revolt();break;
    //			case "√":sqrt();break;
    //			case "7":
    //			case "8":
    //			case "9":
    //			case "4":
    //			case "5":
    //			case "6":
    //			case "3":
    //			case "2":
    //			case "1":
    //			case "0":read(Integer.parseInt(operate.getText()));break;//将按键上的文本转化为Int型
    //			case "/":divide();break;
    //			case "%":mo();break;
    //			case "*":mul();break;
    //			case "1/x":inverted();break;
    //			case "-":cut();break;
    //			case "+":add();break;
    //			case "=":sum();break;
    //			case ".":dot();break;	
    //			}	
    		}
    		public void mouseEntered(MouseEvent e)
    		{
    			((JButton)e.getSource()).setBackground(new Color(255,211,113));
    			
    		}
    		public void mouseExited(MouseEvent e)
    		{
    			((JButton)e.getSource()).setBackground(new Color(233,240,247));
    		}
    	}
    	/*
    	 * MC  取消存储区,清空存储区数据
    	 */
    	public void mc()
    	{	
    		storage.storageNum=0;
    		storage.storageMode=false;
    		display3.setText(null);
    	}
    	/*
    	 * MR 读取存储器存储的数据
    	 */
    	public void mr()
    	{
    		op1.value=storage.storageNum;
    		screen2=""+op1.value;
    		if(op1.value==Math.floor(op1.value))
    			screen2=""+(int)op1.value;
    		display2.setText(screen2);
    		op1.clear=true;
    	}
    	/*
    	 * MS 保存数据到存储器
    	 */
    	public void ms()
    	{
    		storage.storageNum=op1.value;
    		display3.setText("M");//屏幕左下角显示M标志
    	}
    	/*
    	 * M+ 已经储存的数加上当前计算结果并将和存入存储器
    	 */
    	public void mAdd()
    	{
    		storage.storageNum=storage.storageNum+op1.value;		
    	}
    	/*
    	 * M- 已经储存的数减去当前计算结果并将差存入存储器
    	 */
    	public void mCut()
    	{
    		storage.storageNum=storage.storageNum-op1.value;	
    	}
    	/*
    	 * ← 输入的数去掉尾数
    	 * 
    	 */
    	public void cutEnd()
    	{
    		if(action=="op1"&&op1.value!=0)//表示对op1进行操作
    		{
    			if(op1.isFloat==false)//如果op1为整数
    			{
    				op1.value=(int)op1.value/10;
    				screen2=""+(int)op1.value;
    			}
    			else{//如果op1为小数
    				BigDecimal bd=new BigDecimal(op1.value);   
    				op1.value=bd.setScale(--op1.dotWei,BigDecimal.ROUND_DOWN).doubleValue();
    				screen2=""+op1.value;
    				if(op1.dotWei==0)//小数点后数位都去除掉后,变位整数,更新isFloat标记
    					op1.isFloat=false;
    			}
    		}
    		else if(action=="op2"&&op2.value!=0)//表示对op2进行操作
    		{
    			if(op2.isFloat==false)//如果op2位整数
    			{
    				op2.value=(int)op2.value/10;
    				screen2=""+(int)op2.value;
    			}
    			else{//如果op2为小数
    				BigDecimal  bd=new BigDecimal(op2.value);   
    				op2.value=bd.setScale(--op2.dotWei,BigDecimal.ROUND_DOWN ).doubleValue();
    				screen2=""+op2.value;
    				if(op2.dotWei==0)//小数点后数位都去除掉后,变位整数,更新isFloat标记
    					op2.isFloat=false;
    			}
    		}
    		display2.setText(screen2);//输出修改后的操作数
    	}
    	/*
    	 * CE 清空当前操作数操作数
    	 */
    	public void cutNum()
    	{
    		if(action=="op1")
    			op1.reset();
    		else if(action=="op2")
    			op2.reset();
    		display2.setText("0");//初始化显示屏2
    	}
    	/*
    	 * C 归零 重置计算器
    	 */
    	public void clear()
    	{
    		op1.reset();
    		op2.reset();
    		//初始化数据成员
    		action="op1";
    		sign="";
    		//初始化显示屏
    		display1.setText("");
    		display2.setText("0");
    	}
    	/*
    	 * ± 正负号
    	 */
    	public void revolt()
    	{
    		if(action=="op1")
    		{
    			op1.value=-op1.value;
    			screen2=""+op1.value;	
    		}
    		else if(action=="op2")
    		{
    			op2.value=-op2.value;
    			screen2=""+op2.value;
    		}
    		display2.setText(screen2);
    	}
    	/*
    	 * √ 根号
    	 */
    	public void sqrt()
    	{
    		double x;//临时变量
    		if(action=="op1")
    		{
    			op1.sqrtedString="sqrt("+op1.value+")";
    			op1.value=Math.sqrt(op1.value);
    			op1.isSqrted=true;
    			x=op1.value;	
    		}
    		else
    		{
    			op2.sqrtedString="sqrt("+op2.value+")";
    			op2.value=Math.sqrt(op2.value);
    			op2.isSqrted=true;
    			x=op2.value;
    		}
    		screen2=x+"";
    		if(x==Math.floor(x))//如果x为整数
    		{
    			screen2=(int)x+"";//则将浮点数x先转化为int再转化成字符串
    		}
    		display2.setText(screen2);
    		
    	}
    	/*
    	 * 按下数字键
    	 */
    	public void read(int value)
    	{
    		//display2.setFont(new Font("宋体",Font.BOLD,20));//默认字体大小
    		display2.setText(null);//清屏
    		if(op1.clear==true)
    			op1.reset();
    		if(op2.clear==true)
    			op2.reset();
    		if(action=="op1")//表示输数据给op1
    		{	
    			
    			if(op1.isFloat==true)//若op1为浮点数
    			{
    				int i=1;
    				double num=value;
    				++op1.dotWei;
    				while(i<=op1.dotWei)
    				{
    					num*=0.1;
    					i++;
    				}
    				op1.value=op1.value+num;//将新的小数点位添加到操作数op1中
    				//因为双精度浮点数 其精度比较高,而我们只需取它的op1.dotWei保存
    				op1.value=Double.parseDouble(String.format("%."+op1.dotWei+"f",op1.value));
    				//因为双精度浮点数 其精度比较高,而我们只需取它的op1.dotWei显示在屏幕上
    				display2.setText(String.format("%."+op1.dotWei+"f", op1.value));
    			}
    			else//op1为整数
    			{	
    				op1.value=op1.value*10+value;//将新的整数位加倒op1中
    				display2.setText((int)op1.value+"");//屏幕输出op1的值
    			}
    		}
    		else if(action=="op2")//表示输数据给op2
    		{
    			if(op2.isFloat==true)//若op2为浮点数
    			{
    				int i=1;
    				double num=value;
    				++op2.dotWei;
    				while(i<=op2.dotWei)
    				{
    					num*=0.1;
    					i++;
    				}
    				op2.value=op2.value+num;//将新的小数点位添加到操作数op2中
    				//因为双精度浮点数 其精度比较高,而我们只需取它的op2.dotWei保存
    				op2.value=Double.parseDouble(String.format("%."+op2.dotWei+"f",op2.value));
    				//因为双精度浮点数 其精度比较高,而我们只需取它的op2.dotWei显示在屏幕上
    				display2.setText(String.format("%."+op2.dotWei+"f", op2.value));
    			}
    			else//op2为整数
    			{
    				op2.value=op2.value*10+value;
    				display2.setText((int)op2.value+"");
    			}
    			
    		}
    	}
    	public void divide()
    	{
    		run("/");
    	}
    	public void mo()
    	{
    		run("%");
    	}
    	public void mul()
    	{
    		run("*");
    	}
    	/*
    	 * 1/x
    	 */
    	public void inverted()
    	{
    		double num;
    		String str;
    		if(action=="op1")
    		{
    			op1.invertedString="1/"+op1.value;//1/x形式字符串
    			op1.value=1/op1.value;
    			op1.isInverted=true;
    			num=op1.value;
    		}
    		else{
    			op2.invertedString="1/"+op2.value;//1/x形式字符串
    			op2.value=1/op2.value;
    			op1.isInverted=true;
    			num=op2.value;
    		}
    		str=num+"";
    		if(str.length()>=16)//计算器屏幕所能显示数据的最大长度
    		{
    			display2.setFont(new Font("宋体",Font.BOLD,14));//缩小字体输出
    			display2.setText(str.substring(0, 16));	
    		}
    		else
    			display2.setText(str);
    	}
    	public void cut()
    	{
    		run("-");
    	}
    	public void add()
    	{
    		run("+");
    	}
    	public void sum()
    	{
    		display2.setFont(new Font("宋体",Font.BOLD,20));
    		int d1=op1.dotWei,d2=op2.dotWei,i;
    		if(sign.equals("+")){
    			op1.value=op1.value+op2.value;
    			
    		}
    		if(sign.equals("-")){
    			op1.value=op1.value-op2.value;
    			
    		}
    		if(sign.equals("*")){
    			op1.value=op1.value*op2.value;
    			
    		}
    		if(sign.equals("/")){
    			op1.value=op1.value/op2.value;
    			
    		}
    		if(sign.equals("%")){
    			op1.value=op1.value%op2.value;
    			
    		}
    //		switch(sign)
    //		{ 	//运算后 结果保存到op1中
    //			case "+":op1.value=op1.value+op2.value;break;
    //			case "-":op1.value=op1.value-op2.value;break;
    //			case "*":op1.value=op1.value*op2.value;break;
    //			case "/":op1.value=op1.value/op2.value;break;
    //			case "%":op1.value=op1.value%op2.value;break;
    //		}
    		if(op2.value==0&&sign=="/")//除数为0
    		{
    			Disable=true;
    			display2.setText(op1.value+"");
    			display1.setText(null);
    			action="op1";
    			return ;
    		}
    		if(op1.value==Math.floor(op1.value))//结果为整数
    		{
    			display2.setText((int)op1.value+"");
    			op1.dotWei=0;
    			op1.isFloat=false;
    		}
    		else{//结果为小数
    			String str=op1.value+"";
    			//准确控制算术运算结果的精度,加,减,取模运算,小数点后的有效数字最多为max(d1,d2)位
    			if(sign.equals("+")||sign.equals("-")||sign.equals("%"))
    			{
    				i=d1>d2?d1:d2;
    				str=op1.value+"";
    				str=str.substring(0, str.indexOf(".")+i+1);//取i位输出
    			}
    			//准确控制算术运算结果的精度,乘法运算,小数点后的有效数字最多为d1+d2位
    			else if(sign.equals("*"))
    			{
    				i=d1+d2;
    				BigDecimal bd=new BigDecimal(op1.value); 
    				op1.value=bd.setScale(i,BigDecimal.ROUND_DOWN ).doubleValue();
    				str=op1.value+"";//更新修改后的str
    			}
    			//结果超过显示数据的最大长度
    			if(str.length()>=16)
    			{
    				display2.setFont(new Font("宋体",Font.BOLD,14));
    				str=str.substring(0, 16);
    			}
    				display2.setText(str);
    				op1.dotWei=str.length()-str.indexOf(".")-1;//更新op1w值
    		}		
     
    		display1.setText(null);
    		action="op1";
    		op1.clear=true;//开始新的表达式运算时,op1要先重置
    		op2.clear=true;//开始新的表达式运算时,op2要先重置
    		sign="";
    	}
    	public void dot()
    	{
    		if(action=="op1")
    			op1.isFloat=true;
    		else
    			op2.isFloat=true;
    		display2.setText(display2.getText()+".");
    	}
    	public void run(String SIGN)
    	{
    		display2.setFont(new Font("宋体",Font.BOLD,20));
    		action="op2";
    		int d1=op1.dotWei,d2=op2.dotWei,i;
    		if(!sign.equals(""))//检测是否为以为表达式的第一运算
    		{
    			if(sign.equals("+")){
    				op1.value=op1.value+op2.value;
    				
    			}
    			if(sign.equals("-")){
    				op1.value=op1.value-op2.value;
    				
    			}
    			if(sign.equals("*")){
    				op1.value=op1.value*op2.value;
    				
    			}
    			if(sign.equals("/")){
    				op1.value=op1.value/op2.value;
    				
    			}
    			if(sign.equals("%")){
    			  op1.value=op1.value%op2.value;
    			 
    			}
    //			switch(sign)
    //			{//运算后 结果保存到op1中
    //			case "+":op1.value=op1.value+op2.value;break;
    //			case "-":op1.value=op1.value-op2.value;break;
    //			case "*":op1.value=op1.value*op2.value;break;
    //			case "/":op1.value=op1.value/op2.value;break;
    //			case "%":op1.value=op1.value%op2.value;break;
    //			}
    		}
    		String temp=isSpecileHandle();
    		if(temp==null)
    			temp=display2.getText();//先保存display2文本框里的数据
    		if(op2.value==0&&sign=="/")//除数为0
    		{
    			Disable=true;
    			display2.setText(op1.value+"");
    			display1.setText(display1.getText()+op1.value);
    		}
    		if(op1.value==Math.floor(op1.value))//结果为整数
    		{
    			display2.setText((int)op1.value+"");
    			op1.dotWei=0;
    			op1.isFloat=false;
    		}
    		else{
    			String str=op1.value+"";
    			//准确控制算术运算结果的精度,加,减,取模运算,小数点后的有效数字最多为max(d1,d2)位
    			if(sign.equals("+")||sign.equals("-")||sign.equals("%"))
    			{
    				i=d1>d2?d1:d2;
    				BigDecimal bd=new BigDecimal(op1.value); 
    				op1.value=bd.setScale(i,BigDecimal.ROUND_DOWN ).doubleValue();
    				str=op1.value+"";//更新修改后的str
    			}
    			//准确控制算术运算结果的精度,乘法运算,小数点后的有效数字最多为d1+d2位
    			else if(sign.equals("*"))
    			{
    				i=d1+d2;
    				BigDecimal bd=new BigDecimal(op1.value); 
    				op1.value=bd.setScale(i,BigDecimal.ROUND_DOWN ).doubleValue();
    				str=op1.value+"";//更新修改后的str
    			}
    			//结果超过显示数据的最大长度
    			if(str.length()>=16)
    			{
    				display2.setFont(new Font("宋体",Font.BOLD,14));
    				str=str.substring(0, 16);
    			}
    			display2.setText(str);
    			op1.dotWei=str.length()-str.indexOf(".")-1;//每次加完后,如果结果op1的值为小数则更新op1w的值	
    		}		
    		sign=SIGN;
    		display1.setText(display1.getText()+temp+sign);
    		op2.value=op1.value;//运算后,操作数op2默认的值为op1的值	
    		op2.clear=true;//下一次键入数据,op2要重置
    		op1.clear=false;//下一次键入数据,op1不要重置
    	}
    	/*
    	 * isSpecileHandle() 
    	 * 操作数是否sqrt()或1/x过,
    	 * 如果有,则返回"sqrt(x)"或"1/x"字符串
    	 */
    	public String isSpecileHandle()
    	{
    		String temp=null;
    		if(op1.isSqrted)
    		{
    			temp=op1.sqrtedString;
    			op1.isSqrted=false;
    		}
    		else if(op2.isSqrted)
    		{
    			temp=op2.sqrtedString;
    			op2.isSqrted=false;
    		}
    		if(op1.isInverted)
    		{
    			temp=op1.invertedString;
    			op1.isInverted=false;
    		}
    		else if(op2.isInverted)
    		{
    			temp=op2.invertedString;
    			op2.isInverted=false;
    		}
    		return temp;
    	}
    	class keyAdapter extends KeyAdapter{
    		public void keyPressed(KeyEvent e)
    		{		
    			int keycode=e.getKeyCode();
    			if((keycode>=96&&keycode<=105)||(keycode>=48&&keycode<=57))//数字键
    			{
    				if(keycode>=96)
    					keycode-=48;
    				switch(keycode)
    				{
    				case 48:read(0);break;
    				case 49:read(1);break;
    				case 50:read(2);break;
    				case 51:read(3);break;
    				case 52:read(4);break;
    				case 53:read(5);break;
    				case 54:read(6);break;
    				case 55:read(7);break;
    				case 56:read(8);break;
    				case 57:read(9);break;
    				}
    			}
    			//运算符键+ - * / =和. 以及退格键(* =号)
    			else if((keycode==110||keycode==46)||(keycode==111||keycode==47)||(keycode==45||keycode==109)||keycode==107||keycode==106||keycode==61||keycode==10||keycode==8)
    			{
    				if((keycode==110||keycode==46))
    					dot();
    				else if(keycode==111||keycode==47)
    					run("/");
    				else if(keycode==45||keycode==109)
    					run("-");
    				else if(keycode==107)
    					run("+");
    				else if(keycode==106)
    					run("*");
    				else if(keycode==61||keycode==10)//=号
    					sum();
    				else if(keycode==8)
    					cutEnd();
    			}
    		}
    	}
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//StandardCalculator sc=new StandardCalculator();
    	}
    }
    
    
    //第三个类
    
    package qm;
    public class StandardCalculatorText {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//StandardCalculator sc=new StandardCalculator();
    	}
    }
    class operateNum {//操作数类
    	public double value;//操作数的实际值
    	public int dotWei;//操作数如果是小数,记录小数点后的位数
    	public String invertedString;//1/x字符串
    	public String sqrtedString;//sqrt(x)字符串
    	public boolean isSqrted,isInverted;//做标记是否√,1/x过,用于后续判断
    	public boolean clear;//clear为真表示是否重置操作数
    	public boolean isFloat;//isFloat为真,表示操作数是小数
    	public operateNum()
    	{
    		value=0;
    		dotWei=0;
    		sqrtedString=null;
    		invertedString=null;
    		isSqrted=false;
    		isInverted=false;
    		clear=false;
    		isFloat=false;
    	}
    	public void reset()//重置操作数
    	{
    		value=0;
    		dotWei=0;
    		sqrtedString=null;
    		invertedString=null;
    		isSqrted=false;
    		isInverted=false;
    		clear=false;
    		isFloat=false;
    	}
    }
    class storageField {//存储区
    	public double storageNum;//存储区存储的数据
    	public boolean storageMode;//是否启动存储区
    	public storageField()
    	{
    		storageNum=0;
    		storageMode=false;
    	}
    }
    
    //第四个类
    package qm;
    import javax.swing.*;
    import javax.swing.event.*;
    import java.awt.*;
    import java.awt.event.*;
    public class UnitTransfer extends JFrame{
        private final int WIDTH = 324, HEIGHT = 424;//窗口默认的宽度、高度
         
        private JLabel lblInUnit=new JLabel("输入单位");
        private JComboBox cboIn=new JComboBox(new String[]{"", ""});
        private JLabel lblIn=new JLabel("输入数值");
        private JTextField txtIn=new JTextField("10");
        
         
        private JLabel lblOutUnit=new JLabel("输出单位");
        private JLabel lblResult=new JLabel("显示结果");
        private JLabel txtResult=new JLabel("结果");
        private JComboBox cboOut=new JComboBox(new String[]{"", ""});
         
        private JButton btnTrans = new JButton("转换");
        private JButton btnClear = new JButton("清空");
        private JButton btnreturn=new JButton("返回");
       
    
    
         
        private JRadioButton rdLeng = new JRadioButton("长度");
        private JRadioButton rdWeig = new JRadioButton("时间");
        private String [] lengthUnit={"米", "分米", "厘米", "毫米"};
        private String [] timeUnit={"天", "时", "分", "秒"};
         
        public UnitTransfer(){
            super("单位转换器 ");
            this.setSize(WIDTH, HEIGHT);
            this.setLocation( 300,200 );
            this.setResizable(false);
            this.setLayout(null);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             
            ButtonGroup group = new ButtonGroup();
            group.add(rdLeng);
            group.add(rdWeig);
            this.getContentPane().add(rdLeng);
            this.getContentPane().add(rdWeig);
            this.getContentPane().add(btnTrans);
            this.getContentPane().add(btnClear);
            this.getContentPane().add(btnreturn);
            this.getContentPane().add(lblIn);
            this.getContentPane().add(txtIn);
            this.getContentPane().add(lblInUnit);
            this.getContentPane().add(cboIn);
     
            this.getContentPane().add(lblResult);
            this.getContentPane().add(txtResult);
            this.getContentPane().add(lblOutUnit);
            this.getContentPane().add(cboOut);
            
            
            txtIn.setFont(new Font("宋体",Font.BOLD,20));
            lblInUnit.setFont(new Font("宋体",Font.BOLD,15));
            lblIn.setFont(new Font("宋体",Font.BOLD,15));
            lblOutUnit.setFont(new Font("宋体",Font.BOLD,15));
            lblResult.setFont(new Font("宋体",Font.BOLD,15));
            btnTrans.setFont(new Font("宋体",Font.BOLD,15));
            btnClear.setFont(new Font("宋体",Font.BOLD,15));
            
            btnreturn.setBackground(new Color(233,240,247));
            btnreturn.setForeground(new Color(30,57,91));
            btnClear.setBackground(new Color(233,240,247));
            btnClear.setForeground(new Color(30,57,91));
            btnTrans.setBackground(new Color(233,240,247));
            btnTrans.setForeground(new Color(30,57,91));
            cboIn.setBackground(new Color(233,240,247));
            cboIn.setForeground(new Color(30,57,91));
            btnreturn.setBackground(new Color(233,240,247));
            cboOut.setForeground(new Color(30,57,91));
            
            this.setVisible(true);
            this.doLayout();
            btnTrans.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                    doConvert();
                }
            });
            btnClear.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                    txtIn.setText("0");
                    txtResult.setText("0");
                }
            });
          
            btnreturn.addActionListener(new ActionListener(){
            	@Override
                public void actionPerformed(ActionEvent e){
                	
                	JSQ calculator = new JSQ();
                	boolean flase = false;
                	setVisible(flase);
                }
            });
            rdLeng.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                    cboIn.setModel(new DefaultComboBoxModel(lengthUnit));
                    cboOut.setModel(new DefaultComboBoxModel(lengthUnit));
                }
            });
            rdWeig.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                    cboIn.setModel(new DefaultComboBoxModel(timeUnit));
                    cboOut.setModel(new DefaultComboBoxModel(timeUnit));
                }
            });
            rdLeng.setSelected(true);
            cboIn.setModel(new DefaultComboBoxModel(lengthUnit));
            cboOut.setModel(new DefaultComboBoxModel(timeUnit));
        }
        final int offX=100;
        public void doLayout(){
            super.doLayout();
             
            rdLeng.setBounds(offX, 15, 60, 20);
            rdWeig.setBounds(rdLeng.getX()+rdLeng.getWidth()+5, 15, 60, 20);
             
            lblInUnit.setBounds(offX, rdLeng.getY()+rdLeng.getHeight()+20, 80, 20);
            cboIn.setBounds(lblInUnit.getX()+lblInUnit.getWidth()+5, lblInUnit.getY(), 80, 20);
            lblIn.setBounds(offX, lblInUnit.getY()+lblInUnit.getHeight()+5, 80, 20);
            txtIn.setBounds(lblIn.getX()+lblIn.getWidth()+5, lblIn.getY(), 80, 20);
             
            lblOutUnit.setBounds(offX, lblIn.getY()+lblIn.getHeight()+30, 80, 20);
            cboOut.setBounds(lblOutUnit.getX()+lblOutUnit.getWidth()+5, lblOutUnit.getY(), 80, 20);
            lblResult.setBounds(offX, cboOut.getY()+cboOut.getHeight()+5, 80, 20);
            txtResult.setBounds(lblResult.getX()+lblResult.getWidth()+5, lblResult.getY(), 100, 20);
             
            int w=getWidth ();
            int x=(w-70*2-5)/2;//水平居中
            btnTrans.setBounds(x, lblResult.getY()+lblResult.getHeight()+30, 70, 25);
            btnClear.setBounds(btnTrans.getX()+btnTrans.getWidth()+3, btnTrans.getY(), 70, 25);
            //btnreturn.setBounds(x, lblResult.getY()+lblResult.getHeight()+80, 70, 65);
            btnreturn.setBounds(15,12, 70, 25);
            
    
            
        }
        public void doConvert(){
            double v=0;
            try{
                v= Double.parseDouble(txtIn.getText());
            }catch(Exception ex){
                txtIn.setText("0");
                return;
            }
            //"米", "分米", "厘米", "毫米"
            if(rdLeng.isSelected()){
                switch(cboIn.getSelectedIndex()){
                    case 0:
                        break;
                    case 1:
                        v=v/10;
                        break;
                    case 2:
                        v=v/100;
                        break;
                    case 3:
                        v=v/1000;
                        break;
                    default:
                        return;
                }
                //v 现在是标准单位:米
                switch(cboOut.getSelectedIndex()){
                    case 0:
                        break;
                    case 1:
                        v=v*10;
                        break;
                    case 2:
                        v=v*100;
                        break;
                    case 3:
                        v=v*1000;
                        break;
                    default:
                        return;
                }
                if(v<0.01){
                    txtResult.setText(String.format("%2.8f", v));
                }else{
                    txtResult.setText(String.format("%2.2f", v));
                }
            }else{
            //"天", "时", "分", "秒"
                switch(cboIn.getSelectedIndex()){
                    case 0:
                        v=v*24;
                        break;
                    case 1:
                        break;
                    case 2:
                        v=v/60;
                        break;
                    case 3:
                        v=v/3600;
                        break;
                    default:
                        return;
                }
                //v 现在是标准单位:小时
                switch(cboOut.getSelectedIndex()){
                    case 0:
                        v=v/24;
                        break;
                    case 1:
                        break;
                    case 2:
                        v=v*60;
                        break;
                    case 3:
                        v=v*3600;
                        break;
                    default:
                        return;
                }
                if(v<0.01){
                    txtResult.setText(String.format("%2.8f", v));
                }else{
                    txtResult.setText(String.format("%2.8f", v));
                }
            }
        }
         
        public static void main(String[] args){
            EventQueue.invokeLater(new Runnable()  {
                public void run()   {
                	//UnitTransfer un=  new UnitTransfer();
                }
            });
        }
    }
    
    //最后一个类
    package qm;
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    //import java.awt.Button;
    import java.text.DecimalFormat;
    
    
    public class WenDuChang extends JFrame implements ActionListener{
    	private JTextField textField;
    	private JTextField textField_1;
        private JLabel label;
        private JLabel label_1;
        private JLabel label_2;
        private JRadioButton[] radioButton;   
        private JButton button;
        private JButton button_1;
        private ButtonGroup bg;
        
        public static void main( String args[] )          
        {
        	//WenDuChang  wd=new WenDuChang();
        }
    	
    	public WenDuChang() {
    		//获取你的屏幕的宽和高
    		//int width = Toolkit.getDefaultToolkit().getScreenSize().width;
    	   // int height = Toolkit.getDefaultToolkit().getScreenSize().height;
    	   // setLocation(width/2-200, height/2-150);
    		
    	        
    	    setTitle("温度转换器");
    		getContentPane().setLayout(null);
    		
    	   textField = new JTextField();//摄氏温度
    		textField.setText("0.0");
    		 textField.setFont(new Font("宋体",Font.BOLD,20));
    		//textField.setBounds(50, 63, 84, 27);
    		textField.setBounds(170, 33, 104, 37);
    		getContentPane().add(textField);
    		textField.setColumns(10);
    		
    		label = new JLabel("摄氏温度");
    		//label.setBounds(137,69,54,15);
    		label.setBounds(60,35,104,37);
    		getContentPane().add(label);
    		
    		label_1 = new JLabel("<<==>>");
    		//label_1.setBounds(201, 69, 54, 15);
    		label_1.setBounds(130, 84, 104, 45);
    		getContentPane().add(label_1);
    		
    		textField_1 = new JTextField();//华氏温度
    		textField_1.setText("0.0");
    		 textField_1.setFont(new Font("宋体",Font.BOLD,20));
    		//textField_1.setBounds(, 66, 90, 24);
    		textField_1.setBounds(170, 140, 104, 37);
    		getContentPane().add(textField_1);
    		textField_1.setColumns(10);
    		
    		label_2 = new JLabel("华氏温度");
    		//label_2.setBounds(323, 69, 104, 37);
    		label_2.setBounds(60, 150, 54, 15);
    		getContentPane().add(label_2);
    		
    		radioButton = new JRadioButton[2];
    		radioButton[0] = new JRadioButton("摄氏转华氏",true);
    		//radioButton[0].setBounds(100, 142, 121, 23);
    		radioButton[0].setBounds(55, 210, 121, 23);
    		getContentPane().add(radioButton[0]);
    		
    		radioButton[1] = new JRadioButton("华氏转摄氏");
    		//radioButton[1].setBounds(223, 142, 121, 23);
    		radioButton[1].setBounds(180, 210, 121, 23);
    		getContentPane().add(radioButton[1]);
    		
    		
    		bg=new ButtonGroup(); 
    		bg.add(radioButton[0]);
    		bg.add(radioButton[1]);
    
    		
    		button = new JButton("温度转化");
    		//button.setBounds(100, 196, 93, 23);
    		button.setBounds(50, 270, 93, 23);
    	    button.setBackground(new Color(233,240,247));
            button.setForeground(new Color(30,57,91));
    
    		button.addActionListener(this);
    		getContentPane().add(button);
    		
    		button_1 = new JButton("返回");
    	   // button_1.setBounds(237,196,93,23);
    		button_1.setBounds(180,270,93,23);
    		button_1.setBackground(new Color(233,240,247));
            button_1.setForeground(new Color(30,57,91));
    
    		
    		button_1.addActionListener(this);
    		getContentPane().add(button_1);
    		
    		//setSize(450, 300);
    		 this.setLocation( 300,200 );
    	        this.setSize( 328,424);
    	        this.setResizable( true );
    		 this.setResizable(false);
    		 
    		setVisible(true);
    	}
    
    	
    	//用于温度转换的方法-----业务处理
    	public String WenDuChang(final double tc,final double tf,boolean flag){
    		double wdc=0.0;
    		//小数格式化,引号中的0.000表示保留小数点后二位(第四位四舍五入)
    		DecimalFormat df = new DecimalFormat("0.00");
    		
    		String str;
    		if(flag){			
    			wdc=9*(tc-10)/5+50;	//摄氏温度转化为华氏温度		
    		}
    		else{
    			wdc=5*(tf-50)/9+10;	//华氏温度转化为摄氏温度		
    		}
    		str=df.format(wdc);
    		return str;		
    	}
    	
    	
    	
    	@Override
    	public void actionPerformed(ActionEvent e) {
    		double tc = Double.parseDouble(textField.getText().trim());
    		double tf = Double.parseDouble(textField_1.getText().trim());
    		
    		if(e.getSource()==button){
    			//System.out.println("按钮被选中.....");
    			if(radioButton[0].isSelected()){//判断radioButton是否被选中
    				textField_1.setText(WenDuChang(tc,tf,true));
    			}
    			if(radioButton[1].isSelected()){
    				textField.setText(WenDuChang(tc,tf,false));			
    				
    			}
    			
    		}
    		if(e.getSource()==button_1){
    			//System.exit(0);
    			JSQ calculator = new JSQ();
    			this.dispose();
    		}
    		
    	}
    }
    	
    	
    	
    	
    

     

     

    展开全文
  • 当你学一些可视化程序设计语言时,老师经常会让你设计并且编程做出一个计算器,这时也许你会仿照windows系统自带的计算器外观和功能去设计,但是现在老师要你做出一个有新功能计算器,实现当输入一个数时,能够...
  • 如果你是正在学习Java的初学者,或者打算转行学习Java编程的小白,那么你一定会对Java能够做什么项目...而且这个功能很简单,几乎是很学习Java编程的语言经常会去尝试的第一个小项目。虽然简单,可是能够做到也...
  • 当你学一些可视化程序设计语言时,老师经常会让你设计并且编程做出一个计算器,这时也许你会仿照windows系统自带的计算器外观和功能去设计,但是现在老师要你做出一个有新功能计算器,实现当输入一个数时,能够...
  • 当你学一些可视化程序设计语言时,老师经常会让你设计并且编程做出一个计算器,这时也许你会仿照windows系统自带的计算器外观和功能去设计,但是现在老师要你做出一个有新功能计算器,实现当输入一个数时,能够...
  • 1 功能确定 首先来看一下科学计算器的样子。这是市面上CASIO计算器,可谓功能十分强大,我们要用labview实现...程序设计分析更的考察个人的编程思想,与采用什么编程语言不是太相关,即使是开发java、C#等其他...
  • 算式计算器

    2015-03-03 16:41:49
    很多年前刚接触编程时候写的计算器代码。 支持加减乘数、多层括号嵌套、开次方、开负方、平方、阶乘、log、三角函数、对数、绝对值。含“π”“E”。支持算式格式模糊和化简,还有出错提示。可能还有其他功能,记...
  • 如果你是正在学习Java的初学者,或者打算转行学习Java编程的小白,那么你一定会对Java能够做什么项目一定很感兴趣。...而且这个功能很简单,几乎是很学习Java编程的语言经常会去尝试的第一个小项目。虽然简单,可...
  • Java经典编程300例(code)

    千次下载 热门讨论 2013-01-09 10:26:53
    实例247 使用线程池优化线程编程 346 实例248 哲学家的就餐问题 348 第16章 网络通信 350 实例249 获得内网的所有IP地址 351 实例250 获取网络资源的大小 352 实例251 解析网页中的内容 354 实例252 网络资源的单...
  • 用代码编写一个简单的计算器程序是很多编程语言对初学者做的一个要求,现在用java来编写,使用最简单的while循环语句实现功能,如下: import java.util.Scanner; public class JiSuanQi { public static void ...
  • 1 功能确定 首先来看一下科学计算器的样子。这是市面上CASIO计算器,可谓功能十分强大,我们要用labview实现...程序设计分析更的考察个人的编程思想,与采用什么编程语言不是太相关,即使是开发java、C#等其他...
  • 本文阐述了利用Visual C++软件实现一个类MATLAB的功能强大的科学计算器内核的一般实现原理,包括设计目标相关问题探讨、算法分析、各功能子模块设计、用户实现接口定义等软件工程开发中的主要步骤,着重解答内核...
  • 前言这个也是Java实验课程的一个作业,和Java实现简单的图形界面计算器一起做的,因为以前没有做过GUI编程,所以做的非常简陋,还有很BUG,但是感觉当个作业也够了。程序功能和截图这里的添加是直接添加到文件中,...
  • 前言这个也是Java实验课程的一个作业,和Java实现简单的图形界面计算器一起做的,因为以前没有做过GUI编程,所以做的非常简陋,还有很BUG,但是感觉当个作业也够了。程序功能和截图这里的添加是直接添加到文件中,...
  • 前言这个也是Java实验课程的一个作业,和Java实现简单的图形界面计算器一起做的,因为以前没有做过GUI编程,所以做的非常简陋,还有很BUG,但是感觉当个作业也够了。程序功能和截图这里的添加是直接添加到文件中,...
  • 相信很学习编程的人,不管是学习C,C++,JAVA,还是iOS开发用的Objective-C,入门不久就迫切地想写点看得见的界面玩玩。当然了解诸如iOS架构,系统层次这些是非常必要的,但是作为入门案例,我们不妨从最直观的...
  • Java实现简易的界面通讯录

    万次阅读 多人点赞 2018-06-11 09:53:30
    这个也是Java实验课程的一个作业,和Java实现简单的图形界面计算器一起做的,因为以前没有做过GUI编程,所以做的非常简陋,还有很BUG,但是感觉当个作业也够了。 程序功能和截图 这里的添加是直接添加到文件中...
  • java开源包1

    千次下载 热门讨论 2013-06-28 09:14:34
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...
  • java开源包12

    热门讨论 2013-06-28 10:14:45
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...
  • Java资源包01

    2016-08-31 09:16:25
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...
  • java开源包101

    2016-07-13 10:11:08
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...
  • java开源包11

    热门讨论 2013-06-28 10:10:38
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...
  • java开源包6

    热门讨论 2013-06-28 09:48:32
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...
  • java开源包10

    热门讨论 2013-06-28 10:06:40
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...
  • java开源包8

    热门讨论 2013-06-28 09:55:26
    Java Remote Desktop 是一个Java 的远程桌面软件,支持很特性例如文件传输、数据压缩、颜色转换、键盘鼠标事件转换等等。 最短路径算法实现 k-shortest-paths 这是一个实现了 Yen 的排名算法的无环路径的项目 ...

空空如也

空空如也

1 2 3 4
收藏数 72
精华内容 28
关键字:

多功能计算器java编程

java 订阅