精华内容
下载资源
问答
  • Java多功能计算器程序

    千次阅读 2019-03-17 14:37:18
    Java多功能计算器程序(附界面) 早期写的计算器,现在看来还是挺粗糙的,各个控件应该用数组来初始化和排版,懒得改凑合看吧。功能挺全的,求根加减乘除百分制删除清空,和实体简易计算器几乎一致 package ...

    Java多功能计算器小程序(附界面)

    早期写的计算器,现在看来还是挺粗糙的,各个控件应该用数组来初始化和排版,懒得改凑合看吧。功能挺全的,求根加减乘除百分制删除清空,和实体简易计算器几乎一致

    package calculator;
    import java.awt.*
    import javax.swing.*
    
    public class CalculatorJPanel extends JFrame implements ActionListener{
    	private JTextField text_show;
    	private JButton button_sqrt,button_mark,button_CE,button_C,
    	                button_7,button_8,button_9,button_divide,
    	                button_4,button_5,button_6,button_multiply,
    	                button_1,button_2,button_3,button_minus,
    	                button_0,button_dot,button_equal,button_plus;
    	private JPanel jpanel;
    	
        private char sign;
    	private double v1;
    	private double v2;
    	private boolean reop;
    	
    	
    	public CalculatorJPanel(){
    		this.setTitle("计算器");
    		this.setBounds(700,400,300,324);
    		this.setBackground(Color.lightGray);
    		this.setFont(new Font("Arial",Font.BOLD,18));
    		JFrame f=new JFrame();
    		f.setLayout(new BorderLayout());
    		text_show=new JTextField("",100);
    		jpanel=new JPanel();
    		
    		Container container=getContentPane();
    		container.add(text_show, BorderLayout.NORTH);
    		container.add(jpanel, BorderLayout.CENTER);
    		
    		
    		text_show.setEditable(false);
    		text_show.setHorizontalAlignment(JTextField.RIGHT);
    		jpanel.setLayout(new GridLayout(5,4));
    		
    		
    		
    		
    		button_sqrt=new JButton("sqrt");button_mark=new JButton("%");
    		button_CE=new JButton("CE");button_C=new JButton("C");
            button_7=new JButton("7");button_8=new JButton("8");
            button_9=new JButton("9");button_divide=new JButton("/");
            button_4=new JButton("4");button_5=new JButton("5");
            button_6=new JButton("6");button_multiply=new JButton("*");
            button_1=new JButton("1");button_2=new JButton("2");
            button_3=new JButton("3");button_minus=new JButton("-");
            button_0=new JButton("0");button_dot=new JButton(".");
            button_equal=new JButton("=");button_plus=new JButton("+");
    		
    		
            button_sqrt.addActionListener(this);
            button_mark.addActionListener(this);
            button_CE.addActionListener(this);
            button_C.addActionListener(this);
            button_7.addActionListener(this);
            button_8.addActionListener(this);
            button_9.addActionListener(this);
            button_divide.addActionListener(this);
            button_4.addActionListener(this);
            button_5.addActionListener(this);
            button_6.addActionListener(this);
            button_multiply.addActionListener(this);
            button_1.addActionListener(this);
            button_2.addActionListener(this);
            button_3.addActionListener(this);
            button_minus.addActionListener(this);
            button_0.addActionListener(this);
            button_dot.addActionListener(this);
            button_equal.addActionListener(this);
            button_plus.addActionListener(this);
    		
    		
    		
    		jpanel.add(button_sqrt);
    		jpanel.add(button_mark);
    		jpanel.add(button_CE);
    		jpanel.add(button_C);
    		
    		jpanel.add(button_7);
    		jpanel.add(button_8);
    		jpanel.add(button_9);
    		jpanel.add(button_divide);
    		
    		jpanel.add(button_4);
    		jpanel.add(button_5);
    		jpanel.add(button_6);
    		jpanel.add(button_multiply);
    		
    		jpanel.add(button_1);
    		jpanel.add(button_2);
    		jpanel.add(button_3);
    		jpanel.add(button_minus);
    		
    		jpanel.add(button_0);
    		jpanel.add(button_dot);
    		jpanel.add(button_equal);
    		jpanel.add(button_plus);
    		
    		
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	    this.setVisible(true);
    		
    	}
    	public void actionPerformed(ActionEvent ev){
    		double value=0;
    	    char operator=0;
    	    if(reop)
            {
                text_show.setText("");
                reop = false;
            }
    		if(ev.getSource()==button_0){
    			String str=text_show.getText();
    			if(str.equals(""))
    				return;
    			text_show.setText(str+'0');
    			}
    		if(ev.getSource()==button_1){
    			String str=text_show.getText();
    			text_show.setText(str+'1');
    		}
    		if(ev.getSource()==button_2){
    			String str=text_show.getText();
    			text_show.setText(str+'2');
    		}
    		if(ev.getSource()==button_3){
    			String str=text_show.getText();
    			text_show.setText(str+'3');
    		}
    		if(ev.getSource()==button_4){
    			String str=text_show.getText();
    			text_show.setText(str+'4');
    		}
    		if(ev.getSource()==button_5){
    			String str=text_show.getText();
    			text_show.setText(str+'5');
    		}
    		if(ev.getSource()==button_6){
    			String str=text_show.getText();
    			text_show.setText(str+'6');
    		}
    		if(ev.getSource()==button_7){
    			String str=text_show.getText();
    			text_show.setText(str+'7');
    		}
    		if(ev.getSource()==button_8){
    			String str=text_show.getText();
    			text_show.setText(str+'8');
    		}
    		if(ev.getSource()==button_9){
    			String str=text_show.getText();
    			text_show.setText(str+'9');
    		}
    		
    		if(ev.getSource()==button_dot){
    			String str=text_show.getText();
    			text_show.setText(str+'.');
    		}
    		if(ev.getSource()==button_C){
    			text_show.setText("");
    			return;
    		}
    		if(ev.getSource()==button_plus){
    			operator='+';
    		}
    		if(ev.getSource()==button_minus){
    			operator='-';
    		}
    		if(ev.getSource()==button_multiply){
    			operator='*';
    		}
    		if(ev.getSource()==button_divide){
    			operator='/';
    		}
    		if(ev.getSource()==button_equal){
    			operator='=';
    		}
    		if(ev.getSource()==button_mark){
    			operator='%';
    		}
    		if(ev.getSource()==button_sqrt){
    			operator='^';
    		}
    		if(ev.getSource()==button_CE){
    			operator='e';
    		}
    		switch(operator){
    		case'e' :
    		          String s=text_show.getText();
    		          text_show.setText(s.substring(0,s.length()-1));
    		          break;
    		case'^' :
    			      v1=Double.parseDouble(text_show.getText());
    			      value=Math.sqrt(v1);text_show.setText(String.valueOf(value));reop = true;
    			      break;
    		case'%' : 
    		          v1=Double.parseDouble(text_show.getText());
                      value=v1/100;text_show.setText(String.valueOf(value));reop = true;
                      break;
    		case'+' : 
    		          v1=Double.parseDouble(text_show.getText());
    		          text_show.setText("");sign='+';break;
    		case'-' : 
    				  v1=Double.parseDouble(text_show.getText());
                      text_show.setText("");sign='-';break;
    		case'*' : 
    	              v1=Double.parseDouble(text_show.getText());
    	              text_show.setText("");sign='*';break;
    	    case'/' : 
    			      v1=Double.parseDouble(text_show.getText());
                      text_show.setText("");sign='/';break;
    	    case'=' : 
    	    	      reop = true;
    	    	      v2=Double.parseDouble(text_show.getText());
    		          switch(sign){
    		          case'+' : 
    			          value=v1+v2;break;
    			      case'-' : 
    			    	  value=v1-v2;break;
    			      case'*' : 
    			    	  value=v1*v2;break;
    		          case'/' : 
    		        	  value=v1/v2;break;
    		        	  default:value=v1;
    		          }
    		          String str=String.valueOf(value);
    		          text_show.setText(str);
    		          break;
                      default:;  
    		
    		}
    		
    	}
    	
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		new CalculatorJPanel();
    
    	}
    }
    版权声明:本文为博主原创文章,博客地址:http://blog.csdn.net/qq_37808895,未经博主允许不得转载。
    

    程序结果图 如下

    在这里插入图片描述

    展开全文
  • 小型的计算器,包含多种运算,结构层次明确,运用内部类...
  • Java多功能计算器

    2011-11-04 12:07:54
    Java多功能计算器.。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
  • 多功能计算器 原生Android计算器应用程序具有5个主要功能。 科学计算器 提示计算器 价格变化计算器 按位计算器 单位换算器(货币汇率每天从欧洲中央银行更新)
  • java多功能计算器

    2011-03-10 09:15:43
    用jcreator编写的java多功能计算器,能实现一般计算器的所有功能。
  • Java程序设计多功能计算器
  • 同过本课程设计使自身能够全面的掌握面向对象程序设计的有关概念和开发方法,以便能较全面地理解、掌握和综合运用所学的知识,提高自己的编程能力。利用Java Applet图形界面首先开始设计一个计算器的界面,定义...
  • 计算器实现了自定义左上角图标的功能。 关键词: 建造者模式 状态模式 命令模式 策略模式 单件模式 计算器 面板 标准型 科学型 程序员 特色型 初等函数 二进制 八进制 十六进制 分解质因数 最简二次根式 ...
  • 带刮号 可转进制 可退格 无异常 多功能 实现多步运算 任意输入无错误 带刮号 可转进制 可退格 无异常 多功能 实现多步运算 任意输入无错误
  • 完整实现Java开发的例如Windows 下面的calc.exe的计算器程序,内含详细的注释说明,namespace功能稍有点欠缺,其它都比较详细
  • 多功能科学计算器(包括进制转换,三角函数,四则运算等

    qwe.jpg

    多功能科学计算器(包括进制转换,三角函数,四则运算等)

    Basic Framework

    屏幕快照 2017-12-06 08.45.28.png

    calculator.java

    package myCalculator;
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    
    public class calculator 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 calculator()       //构造方法设置布局、为按钮注册事件监听器
        {
            super( "My Calculator" );
            this.setLocation( 350,150 );
            this.setSize( 450,400 );
            this.setResizable( true );
            this.setLayout( new GridLayout( 7,1 ) );
            this.addmyMenu();                   //调用成员方法添加菜单
            displayField = new JTextField( 30 );
            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_plusminus = new JButton( "+/-" );
            button_exp = new JButton( "exp" );//底数e的n次幂
            button_CE = new JButton( "退位");
            button_cancel = new JButton( "c" );//清除
    
            JPanel panel2 = new  JPanel();
            panel2.setLayout( new GridLayout( 1,5,4,4 ) );
            this.add( panel2 );
            button_7 = new JButton( "7" );
            button_8 = new JButton( "8" );
            button_9 = new JButton( "9" );
            button_log = new JButton( "log" );//对数
            button_divide = new JButton( "/" );//除
    
            JPanel panel3 = new JPanel();
            panel3.setLayout( new GridLayout(1,5,4,4) );
            this.add( panel3 );
            button_4 = new JButton( "4" );
            button_5 = new JButton( "5" );
            button_6 = new JButton( "6" );
            button_tan = new JButton( "tan" );//正切
            button_multiply = new JButton( "*" );//乘法
    
            JPanel panel4=new  JPanel();
            panel4.setLayout( new GridLayout( 1,5,4,4 ) );
            this.add(panel4);
            button_1 = new JButton( "1" );
            button_2 = new JButton( "2" );
            button_3 = new JButton( "3" );
            button_cos = new JButton( "cos");//余弦
            button_minus = new JButton( "-" );
    
            JPanel panel5 = new  JPanel();
            panel5.setLayout( new GridLayout( 1,5,4,4 ) );
            this.add( panel5 ); 
            button_0 = new JButton( "0" );
            button_point=new JButton( "." );
            button_equal = new JButton( "=" );
            button_sin = new JButton( "sin" );//正弦
            button_plus = new JButton( "+" );
    
            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_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_exit = new JMenuItem( "退出" );
            m1_exit.addActionListener( this );
            JMenuItem m2_ejz = new JMenuItem( "二进制" );
            m2_ejz.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 );          //为对话框注册窗口事件监听器
    
            m1.add( m1_exit );  
            menubar.add( m1 );
            m2.add( m2_ejz );
            m2.add( m2_bjz );
            m2.add( m2_sljz );
            menubar.add( m2 );
            m3.add( m3_Help ); 
            menubar.add( m3 );  
        }
    
        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( "C" ) )         //清零键的实现方法
                    {
                        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 ) );
            }
            else if ( e.getActionCommand() == "八进制" )    //八进制的转换
            {
                int n = Integer.parseInt( displayField.getText() );
                displayField.setText( Integer.toOctalString( n ) );
            }
            else if ( e.getActionCommand() == "十六进制" )    //十六进制的转换
            {
                int n = Integer.parseInt( displayField.getText() );
                displayField.setText( Integer.toHexString( n ) );
            }
    
            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        //各运算符的识别
            {
                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[] )          
        {
            calculator calculator = new calculator();
        }
    }
    
    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 ){ }
    }

    Running Effect

    屏幕快照 2017-12-06 08.48.57.png
    屏幕快照 2017-12-06 08.49.15.png

    Source Download

    Please click the address->My Calculator

    Summarize

    1. 运用两个面板的叠加做出界面。
    2. 通过在按钮的单击事件处理方法中调用类的成员方法calculate()来进行简易计算器的各种运算,并正确实现运算功能。
    3. 调用Math包中的方法实现各函数功能。
    4. 添加菜单条,列出‘选项’、‘进制转换’、‘帮助’等菜单选项,并分别实现‘选项’中‘退出’的功能,通过调用Integer包中的方法实现二进制、八进制、十六进制的转换,‘帮助’菜单栏中‘用法’的提示对话框。
    5. 整个程序对话框可实现最小化、最大化、关闭。

    原文地址:www.iooy.com

    展开全文
  • Java实现计算器

    2018-11-28 13:18:45
    Java实现的简易计算器 Java课程作业 ;三个JTextField显示的分别是:储存的数,计算表达式,计算结果;计算顺序:不论优先级,一律按照从左到右的顺序计算,跟Windows自带的计算器一样;清除键:清除表达式和计算...
  • Java编程是SUN公司推出的一种面向对象的编程语言,特别适合于计算机应用程序的开发,它具有与生俱来的联系各个网络平台的能力,是一种真正实现了网络实践性的编程语言。目前世界最常用的两种互联网浏览器软件中都有...

    Java编程是SUN公司推出的一种面向对象的编程语言,特别适合于计算机应用程序的开发,它具有与生俱来的联系各个网络平台的能力,是一种真正实现了网络实践性的编程语言。

    目前世界最常用的两种互联网浏览器软件中都有一个Java虚拟机,而几乎所有的操作系统中都有Java编译程序,可见Java已经得到了普遍的认可,为此,笔者来简单谈一谈Java语言和它的发展。

    8329ae220328750ea7b25951f6b1b849.png

    java语言概述

    Java在实际应用中具有较高的稳定性和可靠性,Java技术考虑到互联网的安全因素,其内部的安全设置相对比较完善,受到广大计算机软件系统开发设计人员的喜爱。

    Java技术和普通计算机语言类型不同,在计算机程序设计时主要是面向对象,并且利用其独特可移植性,可以为不同计算机应用程序提供便利,有效简化应用程序设计,支持多线程。

    这种可移植性和面向对象性可以很容易的实现不同软件系统平台的兼容,给予软件系统程序开发设计人员很大的帮助,并且Java技术应用独特的安全设置方式,可以有效的规避一些恶意的计算机程序代码,对提高计算机软件系统的安全性和稳定性有着重要意义。

    474c11b817eb3a516f8bb6d6fde45dcd.png

    Java特征

    程序设计语言是表达软件的工具,是面向机器的人工语言。Java作为一种高级的程序语言,在实际应用中拥有面向对象,简单性,可移植性,分布性,动态性,健壮性,体系结构中立性,安全性等多种优点。这里就选择其3个特点加以描述:

    7b8587656f950b8e2f32278624e30046.png

    (1)简单性:Java语言是对C++语言的升华,又不同于C++语言,它在C++语言的基础上进行了很大的改进,在保留了C++语言的精华部分的同时也放弃了C++语言中不常用、不易于理解、繁杂的部分。因为Java是在C++语言的基础上发展的,所以懂得C++语言的人如果学Java就会很简单,同时,学习Java也不需要C++的基础。

    (2)面向对象:Java语言虽然是杂合语言,但它是纯面向对象的编程语言。除了基本的数据类型外,为了使程序语言更容易理解,Java程序语言的编写思想是纯粹面向对象的。

    (3)可移植性:体系结构的中立性使Java程序可以在不同的平台上运行,但Java语言的文本是统一的,在面对不同的机器结构时,整数32位,长整数64位保持不变。Java系统提供的类库是可以访问任意不同的平台的,Java语言的可移植性实现了软件的“一次开发,处处运行”。

    42878e3ce0c762710315beea785aea24.png

    Java应用

    (1)由于Java语言的面向目标的特性,越来越多的人在用O-O开发时都在选择使用Java技术与方法来开发,这与Java的面向对象特性、模块化特性、安全性以及适应IT技术发展密不可分。

    (2)目前Java产品主要有基于WEB的实时信息发布系统,WEB邮件系统,用于企业分布式计算的消息传输系统,基于servlet/jsp/ejb开发的电子商务平台,提供servlet/jsp/ejb开发和运行环境的应用服务器、结合CORBA/XML等技术开发的分布计算支撑平台等等。另外用Java开发的多媒体软件可以实现集可视化、可听化、可操作化为一体的效果。

    Java发展前景

    目前,据网络数据分析显示:“Java语言市场占有率达20%,为世界第一编程语言。我国软件行业每年所需的Java人才达30万,并且每年以22%左右的速度增长。”由此可见Java发展市场无限大,发展前景十分理想。

    由于Java语言的优秀特性,所以其应用前景必然美好,未来发展肯定会与互联网的发展需求绑定。

    208962c7e330d2c3f3b78dfca881036d.png

    另一方面,Java在手机领域的应用从非智能时代的简单Java小游戏到现在智能机对Java的支持,Java在手机领域已经得到了很好的发展,很多手机类型、系统平台上都能看到Java的身影,目前手机已经进入智能机时代,各大不同智能系统之间抢占市场,这之中当然是以谷歌主导推出的安卓系统占据半壁江山,它给Java的发展也带来不了广阔的前景。

    总结

    60f19750539405a913419ccf2d87c4a1.png

    Java编程是一门随着计算机技术的发展而发展起来的计算机语言程序,它展现了程序编写的精髓,在我国已经有了良好的应用并得到了普遍的好评,很多企业也建立了相关的Java语言技术研究组来进一步钻研其更广泛的应用范围,预计在不久的将来,Java语言能更具实用性以及规模化,Java必将焕发新的活力,有更加辉煌的发展前景。

    共享时刻

    如果你处于想学java或者正在学习java,java的教程肯定是少不了的。说不定你学了可能是两年前人家就学过的内容,在这小编分享一波2020最新的java全套教程,共计约300集,另附面试题和毕业设计资料,希望能帮助到正在学习的你。

    能用到这些资料的可以关注下小编,并在后台私信小编:“Java”即可领取。希望能帮助到各位。也希望每位用心学习Java的朋友,日后都能成为一名合格的程序员。

    展开全文
  • 存档资料 成绩 课 程 设 计 报 告 书 ( 2010-- 2011年度第 2 学期) 所属课程名称 Java 面向对象程序设计 题 目 设计一个多功能计算器 分 院 电 信 分 院 专业班级 09 信管班 学 号 指导教师 2011 年06 23 日 课 程 ...
  • JAVA编写计算器

    千次阅读 多人点赞 2019-05-23 22:32:02
    JAVA编写一个实现加减乘除运算的计算器 1.实现加减乘除以及乘方运算; 2.C是清除键,清除之前输入所有数据,计算结果归零。 3.CE也是清除键,清除上一个输入的数据。 思路就是创建一个窗口,然后给窗口添加容器或...

    用JAVA编写一个实现加减乘除运算的计算器

    1.实现加减乘除以及乘方运算;
    2.C是清除键,清除之前输入所有数据,计算结果归零。
    3.CE也是清除键,清除上一个输入的数据。

    思路就是创建一个窗口,然后给窗口添加容器或组件,然后给组件添加监视器,检测事件的发生,然后进行相应的事件处理。
    主要知识点:窗口建立,添加组件,布局,事件处理。

    图片:在这里插入图片描述

    PS:总的来说这是java的入门,初学者的话遇到这个实验不要慌,没有多难。其实就相当于修房子一样,你首先得打地基(这里就是窗口),然后在这个基础上添砖加瓦(这里可以当做容器和组件)。弄好以后根据你的需求让房子里面的器件实现你的功能,给电器(组件)安装一个开关,当你按下开关以后就根据相应操作做出相应的反应(就是给事件源添加一个监视器,一旦监视器监视到事件源做出反应,就进行相应的事件处理)。

    来吧,见代码:

    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    public class CaculatorDemo {
    	public static void main(String[] args) {
    		JS win=new JS();
    	}
    }
    class JS extends JFrame implements ActionListener{
    	private StringBuilder sBuilder = new StringBuilder();  //利用StringBuilder类来显示,以及区分两个操作数
    	JTextArea text=new JTextArea();
    	double a,b;
    	Double sum;
    	int i;
    	public JS()
    	{
    		setBounds(100,100,400,400);
    		setTitle("计算器");
    		JMenuBar menubar=new JMenuBar();//创建菜单条
    		JMenu menu1=new JMenu("查看(V)");//创建和设置菜单名
    		JMenu menu2=new JMenu("编辑(E)");//创建和设置菜单名
    		JMenu menu3=new JMenu("帮助(H)");//创建和设置菜单名
    		menubar.add(menu1);//将菜单加入到菜单条中
    		menubar.add(menu2);
    		menubar.add(menu3);
    		this.setJMenuBar(menubar);//将设置好的菜单条放在窗口中
    		this.setLayout(new BorderLayout());//添加文本框
    		JPanel p1=new JPanel();
    		JPanel p2=new JPanel();
    		text.setPreferredSize(new Dimension (370,60));//设置组件大小
    		p2.setLayout(new FlowLayout());
    		p1.add(text);
    		this.add(p1,BorderLayout.NORTH);
    		
    		
    		p2.setLayout(new GridLayout(5,4));	//添加按钮
    		JButton button[]=new JButton[20];
    		button[0]=new JButton("C");		//清空
    		button[1]=new JButton("CE");	//清除之前输入的一个数据
    		button[2]=new JButton("%");		//取余
    		button[3]=new JButton("÷");   //除法
    		button[4]=new JButton("7");
    		button[5]=new JButton("8");
    		button[6]=new JButton("9");
    		button[7]=new JButton("x");  //乘号
    		button[8]=new JButton("4");
    		button[9]=new JButton("5");
    		button[10]=new JButton("6");
    		button[11]=new JButton("—");  //减号
    		button[12]=new JButton("1");
    		button[13]=new JButton("2");
    		button[14]=new JButton("3");
    		button[15]=new JButton("+");  //加号
    		button[16]=new JButton("e");	//乘方
    		button[17]=new JButton("0");
    		button[18]=new JButton(".");  //小数点
    		button[19]=new JButton("="); //等于
    		
    		for(int i=0;i<button.length;i++ )	//将组件加入容器
    			p2.add(button[i]);
    		button[19].setBackground(Color.ORANGE);//设置按钮的背景颜色为橙色
    		p2.add(button[19]);
    		add(p2,BorderLayout.CENTER);
    		
    		for(int i=0;i<button.length;i++)	//为每一个事件(按钮)添加监视器
    			button[i].addActionListener(this);
    		this.setVisible(true);
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //点击X号可以关闭程序
    	}
    	
    	public void actionPerformed(ActionEvent e) //事件处理
    	{
    		// TODO Auto-generated method stub
    		String lab=e.getActionCommand();			//得到当前的按钮字符,后面进行匹配
    		
    		if(lab.equals("0"))								//处理按钮 0~9
    		{
    			sBuilder.append("0");		//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据
    		}
    		else if(lab.equals("1"))
    		{
    			sBuilder.append("1");		//利用StringBuilder类的对象调用方法,将数据存起来			
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据	
    		}
    		else if(lab.equals("2"))
    		{
    			sBuilder.append("2");		//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());	 //显示之前所有输入的数据
    		}
    		else if(lab.equals("3"))
    		{
    			sBuilder.append("3");		//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据
    		}
    		else if(lab.equals("4"))
    		{
    			sBuilder.append("4");					
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("5"))
    		{
    			sBuilder.append("5");				
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("6"))
    		{
    			sBuilder.append("6");				
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("7"))
    		{
    			sBuilder.append("7");					
    			text.setText(sBuilder.toString());	
    		}
    		
    		else if(lab.equals("8"))
    		{
    			sBuilder.append("8");						
    			text.setText(sBuilder.toString());	
    		}
    		else if(lab.equals("9"))
    		{
    			sBuilder.append("9");		//利用StringBuilder类的对象调用方法,将数据存起来		
    			text.setText(sBuilder.toString());	//显示之前所有输入的数据
    		}
    		
    		else if(lab.equals("CE"))    				//处理"CE"按钮事件   即清除当前的输入的数据
    		{
    			sBuilder.deleteCharAt(sBuilder.length() - 1);	//StringBuilder的实例化对象调用方法下标减1即可
    			text.setText(sBuilder.toString());
    		}
    		else if(lab.equals("C"))                   //处理"CE"按钮事件   即清除之前的输入所有的数据
    		{
    			sBuilder = new StringBuilder();						//重新创建即可清除之前的输入所有的数据
    			text.setText(sBuilder.toString());
    		}
    		else if(lab.equals("."))						// 处理按钮 "." 事件
    		{
    			sBuilder.append(".");						//利用StringBuilder类的对象调用方法,将数据存起来
    			text.setText(sBuilder.toString());			//显示之前输入的数据
    		}
    		
    		else if(lab.equals("+"))	//处理+"按钮乘法
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将 运算符 之前的数据 作为第一个操作数 a
    			i=0;
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("+");
    		}
    		else if(lab.equals("—"))		//处理"—"按钮乘法
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=1;												//标记运算类型  即"÷"之前的数据即将作为因数
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b									
    			text.setText("—");
    		}
    		else if(lab.equals("x"))    	//处理"x"按钮乘法
    		{										
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=2;											//标记运算类型  即"÷"之前的数据即将作为因数
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("x");
    		}
    		else if(lab.equals("÷"))		//处理"÷"按钮事件
    		{
    			i=3;											//标记运算类型  即"÷"之前的数据即将作为被除数
    			a = Double.parseDouble(sBuilder.toString());	//将除法的输入的数 作为第一个操作数a
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("÷");
    		}
    		
    		else if(lab.equals("%"))	//处理取余运算
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=4;											//标记取余运算
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("%");
    		}
    		else if(lab.equals("e"))	//处理取余运算
    		{
    			a = Double.parseDouble(sBuilder.toString());	//将前面的输入的数 作为第一个操作数a
    			i=5;											//标记取余运算
    			sBuilder = new StringBuilder();					//将数组清空来存储第二个操作数 b
    			text.setText("e");
    		}
    		else if(lab.equals("="))
    		{
    			b = Double.parseDouble(sBuilder.toString());	//一遇到"=",我们就能得到第二个操作数b
    			if (i == 0)			//加法 a+b
    				{
    					sum=a+b;
    					text.setText(sum.toString());		//输出第二个操作数已经输入的数据
    					sBuilder = new StringBuilder();		//清空数据,为后面的操作数留空间
    					sBuilder.append(sum);
    				} 
    			else if (i == 1) 	//加法  a-b
    				{
    					sum = a - b;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();		//清空数据,为后面的操作数留空间
    					sBuilder.append(sum);
    				}
    			else if (i == 2) 	//乘法  a*b
    				{
    					sum = a * b;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			else if (i == 3) 	//除法 a÷b
    				{
    					sum = a / b;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			else if (i == 4)	 //	取余      a%b
    				{
    					sum=a % b;
    					int m=(int)a;
    					int n=(int)b;
    					sum=(double)m % n;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			else if (i == 5) 	//	次幂      a是底数	 b是指数
    			 {
    				 sum=1.0;
    				 if(b==0)
    					 sum=1.0;
    				 else
    					 for(int i=1;i<=b;i++)
    					  sum=sum*a;
    					text.setText(sum.toString());
    					sBuilder = new StringBuilder();
    					sBuilder.append(sum);
    				} 
    			 else 
    				text.setText(sBuilder.toString());
    		}
    	}
    }
    
    
    
    
    
    
    展开全文
  • 多功能计算器--java

    2008-12-14 00:43:35
    /***** ***** ***** 欢迎使用多功能计算器 v1.0 Beta ***** ***** *****/ ------meteor /***** ***** ***** ***** ***** 软件说明 ***** ***** ***** ***** *****/ 1.开发环境 Windows XP + eclipse 3.32 + JDK ...
  • 方法一: package First; import javax.swing.*; import java.awt.*; import java.awt.event.*;... new MyCalculator("计算器v1.1"); } } class MyCalculator extends JFrame{ //创建面板 JPanel jp1,
  • 网上有很关于计算器的代码,但是大都是界面设计和监听事件都放在一个Calculator类中实现的逻辑,我将这种实现进行了拆分。 这样做的好处在于,将界面设计和具体业务逻辑相分离,降低耦合度,有利于程序的可扩展性...
  • Java GUI实现的计算器

    2020-09-17 19:43:43
    (1)具备基本的加减乘除功能;支持由括号和运算符组成的表达式运算; (2)使用GUI界面元素设计用户友好的界面; (3)能够存储个计算结果,并提取出来作为下一个计算的操作数; (4)能够处理计算过程中的异常...
  • 51多功能计算器 液晶显示,里面有很详细的解说,程序的注解很清晰,压缩包里附带相关软硬件资料。值得一下的好资料。
  • Java语言编写计算器

    万次阅读 多人点赞 2018-03-15 15:52:51
    本文讲述Java图形用户界面的编写,重点讲述一个简单计算器的实现。文中程序的运行环境为Windows10 ,编译环境为MyEclipse 8.5。一个简单的计算器主要实现一下功能和要求:一:输入,输出 ①输入:允许输入带有括号...
  • Java课程设计时做的一个项目,基本功能如下: 1、能输入算术表达式,表达式用的是数学符号表示,不是计算机专业符合,如乘是符合“X”,而不是“*”; 2、能保存和浏览计算记录,并能选择某条记录重新计算; 3、能...
  • 这是本人结合C和Java的比较分析后,敲了一个基于Java API的接口实现了一个计算器四则运算功能计算器功能比较简单,但对于初学者来说,是个不错的理解Java语言编程主要概念的基础操作,可以借用此代码了解到代码...
  • #带界面的计算机: JAVA编写。 先挂着有时间来写过程。 代码文件附上链接:https://github.com/ALiangJie/SimpleCalculator
  • java实现计算器.zip

    2019-12-16 17:21:13
    1、参照Windows计算器功能,实现加、减、乘、除运算; 2、声明为按钮数组; 3、对0~9数字操作,采用相同的算法; 4、解决除数为零的问题; 5、具有清除一个数字、全部清除、开平方和平方功能。 6、计算结果保留...
  • JAVA 实现高级计算器程序

    千次阅读 2018-11-17 18:35:05
    JAVA编写了一个高级计算器程序,可以实现带括号的四则运算,如同数据结构书上所讲,可以利用栈将中缀表达式转换为后缀表达式,再利用栈计算后缀表达式。中缀表达式符合人的思维习惯,但计算机却容易理解后缀表达式...
  • JAVA编写计算器程序(模拟Windows计算器
  • Java界面编程之复杂计算器

    千次阅读 多人点赞 2019-09-15 20:58:42
    这是上学期Java的期末设计啦,给大家互相借鉴下,加上搜集资料和自己的理解整合处来的一个多功能计算器, 下面看图片及代码,还有有什么问题可以留言哦, 嗯,这里一共分为五个类来写,第一个来类是JSQ是主界面,...
  • 这个计算器只有加法功能 import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; class Calculator extends Frame { public void claculator() { //三个文本框 ...
  • ② 实现多用能计算器,分别实现数值型(标量、向量和矩阵)计算、非数值型(字符串和图形)计算功能。其中,图形仅包含正方形、圆形和等边三角形三类,该功能为选做题。功能详细描述如下。 标量计算器:加、减、乘、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,859
精华内容 7,543
关键字:

多功能计算器java编程

java 订阅