精华内容
下载资源
问答
  • Java程序的输出结果txt文件中的方法 将输出结果输出到txt文件 直接安排代码: //导包 import java.io.FileNotFoundException; import java.io.PrintStream; public class Test { public static void main...

    将Java程序的输出结果写到txt文件中的方法

    1.将输出结果输出到txt文件

    直接安排代码:

    //导包
    import java.io.FileNotFoundException;
    import java.io.PrintStream;
    
    public class Test {
        public static void main(String[] args) throws FileNotFoundException {
            // 创建一个打印输出流,输出的目标是D盘下的1.txt文件
            PrintStream ps = new PrintStream("D:\\1.txt");
            //可能会出现异常,直接throws就行了
            System.setOut(ps);
            //把创建的打印输出流赋给系统。即系统下次向 ps输出
            System.out.println("看看我在哪里?");
            System.out.println("==============");
            System.out.println("我在D盘下的1.txt文件中去了。");
            ps.close();
        }
    }
    
    

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

    2.将输出结果重新输出到屏幕

    其实代码跟前面只有一点出入。
    强调:
    在把系统的输入方向改变时,如果还要重新回到系统默认输出的话,就一定要在改变之前保存原来系统的输出方向。

    //导包
    import java.io.FileNotFoundException;
    import java.io.PrintStream;
    
    public class Test {
        public static void main(String[] args) throws FileNotFoundException {
            // 创建一个打印输出流,输出的目标是D盘下的1.txt文件
            PrintStream out = System.out;
            // 先保存系统默认的打印输出流缓存
            //一定要先保存系统最初的打印输出,不然后面就改不回来了!!!
            PrintStream ps = new PrintStream("D:\\1.txt");
            //可能会出现异常,直接throws就行了
            System.setOut(ps);
            //把创建的打印输出流赋给系统。即系统下次向 ps输出
            System.out.println("看看我在哪里?");
            System.out.println("==============");
            System.out.println("我在D盘下的1.txt文件中去了。");
            ps.close();
            System.setOut(out);//把打印输出流还给系统
            System.out.println("我又回到屏幕啦!");
            System.out.println("哈哈哈哈哈啊哈");
        }
    }
    

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

    展开全文
  • 简单的Java计算器示例

    千次阅读 2019-12-21 17:11:46
    Java简易计算器(大佬止步)概要:这是一个简单的Java计算器示例简单介绍效果图片所有代码结语 概要:这是一个简单的Java计算器示例 本计算器代码均未参考和复制任何现成的源代码,所有代码均为本超级菜鸟历经通宵...

    概要:这是一个简单的Java计算器示例

    本计算器代码均未参考和复制任何现成的源代码,所有代码均为本超级菜鸟历经通宵所写。以下代码原本是为实现加、减、乘、除连 续运算以及按优先级运算所设计。目前成功实现了不同运算混合连续运算, 而若要实现按加、减、乘、除的优先级运算,只需增添少量代码即可。本人 对JAVA的学习水平不高,代码混乱,算法复杂、啰嗦,望各位见谅!

    简单介绍

    为了操作方便起见,本次编程在eclipse应用程序内进行:

    1. 导入相关Java类包
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import javax.swing.*;
    
    1. 添加GUI组件与相关布局(部分代码示例如下):
       JButton button;
       JButton buttonzero=new JButton("0");
       JButton surebutton=new JButton("清除");
       JButton buttonend=new JButton("=");
       JButton buttonadd=new JButton("+");
       JButton buttoncut=new JButton("-");
       JButton buttonmul=new JButton("×");
       JButton buttonmod=new JButton("÷");
       JTextField text=new JTextField();
    
    1. 为相关组件设置监听(部分代码示例如下):
         for(int i=1;i<=9;i++){
       		String buttons=String.valueOf(i);
       		button=new JButton(buttons);
       		button.addActionListener(this);
       		panel1.add(button);
       	}
       	buttonzero.addActionListener(this);
       	panel1.add(buttonzero);
       	buttonadd.addActionListener(this);
       	panel1.add(buttonadd);
       	buttoncut.addActionListener(this);
       	panel1.add(buttoncut);
       	buttonmul.addActionListener(this);
       	panel1.add(buttonmul);
       	buttonmod.addActionListener(this);
       	panel1.add(buttonmod);
       	buttonend.addActionListener(this);
       	panel1.add(buttonend);
    
    1. 简易计算功能的实现(部分代码示例如下):
       public void calculate(String s,Double num,Double save,boolean flag){
       	 if(flag){
       		result=num;
       		flag=false;
       	 }
       	 if(!flag){
       	   if(s.equals("+")){
       	    result+=save;
       	    text.setText(""+result);
       	    System.out.println(result);
       	   }
       	   if(s.equals("-")){
       	    result-=save;
       	    System.out.println(result);
       	    text.setText(""+result);
       	   }
       	   if(s.equals("×")){
       	     result*=save;
       	     text.setText(""+result);
       	     System.out.println(result);
       	   }
       	   if(s.equals("÷")){
       	        if(save==0.0){String msg=String.format("错误,分母为零!"); JOptionPane.showMessageDialog(this, msg);}
       		    else{
       		        result/=save;
       		  	    System.out.println(result);
       		    }
       	   }
       	   if(s.equals("=")){
       		   text.setText(""+result);
       	   }
       	 }	
       }    
    

    效果图片

    运算图片
    简易计算器效果图
    在这里插入图片描述

    在这里插入图片描述

    所有代码

    以下是上Java只有12次课菜鸟的悲哀

    //                         代码说明                              //
    //     本人郑重声明:本计算器代码均未参考和复制任何现成的源代码,     //
    //所有代码均为本人历经通宵所写。以下代码原本是为实现加、减、乘、除连  //
    //续运算以及按优先级运算所设计。目前成功实现了不同运算混合连续运算,  //
    //而若要实现按加、减、乘、除的优先级运算,只需增添少量代码即可。本人  //
    //对JAVA的学习水平不高,代码较为混乱,算法较为复杂、啰嗦,望各位谅解!//
    
    package 上机实验2;          //代码文件所在包名
    
    //--代码运行时,可能输出报错信息,但不会影响计算器功能的实现。--//
    
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import javax.swing.*;
    
    class CalculateWin extends JFrame implements ActionListener{
    	String str="";
    	String nu="";
    	int i=0;
    	boolean flag=true;
    	Double before[];
    	String array1[];
    	String array[];
    	Double store=0.0;
    	Double save=0.0;
    	Double value=null,num=0.0,result=0.0;
    	JButton button;
    	JButton buttonzero=new JButton("0");
    	JButton surebutton=new JButton("清除");
    	JButton buttonend=new JButton("=");
    	JButton buttonadd=new JButton("+");
    	JButton buttoncut=new JButton("-");
    	JButton buttonmul=new JButton("×");
    	JButton buttonmod=new JButton("÷");
    	JTextField text=new JTextField();
    	
    	CalculateWin(){
    		init("便捷计算器");
    		setLocation(500,200);
    		setSize(400,400);
    		setVisible(true);
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);	
    	}
        void init(String s){
    		setTitle(s);
    		JPanel panel1=new JPanel();
    		panel1.setSize(800,100);
    		for(int i=1;i<=9;i++){
    			String buttons=String.valueOf(i);
    			button=new JButton(buttons);
    			button.addActionListener(this);
    			panel1.add(button);
    		}
    		buttonzero.addActionListener(this);
    		panel1.add(buttonzero);
    		buttonadd.addActionListener(this);
    		panel1.add(buttonadd);
    		buttoncut.addActionListener(this);
    		panel1.add(buttoncut);
    		buttonmul.addActionListener(this);
    		panel1.add(buttonmul);
    		buttonmod.addActionListener(this);
    		panel1.add(buttonmod);
    		buttonend.addActionListener(this);
    		panel1.add(buttonend);
    		buttonend.setBackground(Color.red);
    		buttonend.setForeground(Color.white);
    		GridLayout grid=new GridLayout(5,3,5,5);
    		GridLayout grid2=new GridLayout(1,2,5,5);
    		panel1.setLayout(grid);
    		add(panel1,BorderLayout.CENTER);
    		JPanel panel2=new JPanel();	
    		text.setColumns(10);
    		panel2.add(text);
    		surebutton=new JButton("清除");
    		surebutton.addActionListener(this);
    		surebutton.setBackground(Color.pink);
    		panel2.add(surebutton);
    		panel2.setLayout(grid2);
    		add(panel2,BorderLayout.NORTH);
    		text.addActionListener(this);
    	}
        public String clean(String s){
        	s="";
        	return s;
        }
        public void calculate(String s,Double num,Double save,boolean flag){
        	 if(flag){
        		result=num;
        		flag=false;
        	 }
        	 if(!flag){
        	   if(s.equals("+")){
        	    result+=save;
        	    text.setText(""+result);
        	    System.out.println(result);
        	   }
        	   if(s.equals("-")){
        	    result-=save;
        	    System.out.println(result);
        	    text.setText(""+result);
        	   }
        	   if(s.equals("×")){
        	     result*=save;
        	     text.setText(""+result);
        	     System.out.println(result);
        	   }
        	   if(s.equals("÷")){
        	        if(save==0.0){String msg=String.format("错误,分母为零!"); JOptionPane.showMessageDialog(this, msg);}
        		    else{
        		        result/=save;
        		  	    System.out.println(result);
        		    }
        	   }
        	   if(s.equals("=")){
        		   text.setText(""+result);
        	   }
        	 }	
        }    
    	public void actionPerformed(ActionEvent e){
    		if(!e.getActionCommand().equals("清除")  ){
    		  str=str+e.getActionCommand();
    		  if(str.equals("+") || str.equals("-") || str.equals("×") || str.equals("÷") || str.equals("=")){String msg=String.format("运算数字不合法!请清空重新输入!"); JOptionPane.showMessageDialog(this, msg);}
    		  text.setText(str);                                                //在文本框输出监听到的除"清除"以外的所有按钮标签
    		  array=str.split("[^\\d]");                                        //数组array用于存储运算数字
    		  save=Double.parseDouble(array[array.length-1]);                   //save为最后一个数
    		  num=Double.parseDouble(array[0]);                                 //num为第一个数
    		  array1=str.split("[\\d]");                                        //数组array1用于存储运算符
    		}
    		if(e.getActionCommand().equals("清除")){str=clean(str);text.setText(str);num=0.0;value=null;flag=true;array=null;array1=null;result=0.0;}
    		if(num==save && array==null && array1==null){                       //如果只输入一个数,就不做运算
    			if(e.getActionCommand().equals("="))text.setText(""+Double.parseDouble(array[0]));
    		}
    		else if(!(num==save || array==null || array1==null)){               //不写会报错--点击清除会报错:说什么空指针
    		 int k=0;
    		 for(int j=0;j<=array1.length-1 && k+1<=array.length-1;++j){        //遍历array1中存储的运算符
    		   while(array1[j].length()<=0)j+=1;                                //跳过array1得到的str用数字分割后的空字符
    		   if(e.getActionCommand().equals("=") && k+1<=array.length-1){     //如果监听到了"=",执行计算
    			  String store=array1[j];
    			  calculate(store,Double.parseDouble(array[0]),Double.parseDouble(array[k+1]),flag);       //运算
    			  k=k+1;                                                                                  //以遍历array存储的所有数字
    			  if(e.getActionCommand().equals("="))text.setText(""+result);
    			  flag=false;                                                                             //解决对result第一次赋值问题
    		   }
    		   if(e.getActionCommand().equals("="))text.setText(""+result);
    		 }
    		}
    	}
    }
    
    public class task2 {
    	public static void main(String args[]){
    		CalculateWin calculatewin=new CalculateWin();
    	}
    }
    

    结语

    代码虽烂,但含本人心血,未经本人允许,禁止转载或复制。希望这篇博客能够帮到您,如果不喜欢,望大佬海涵,请勿喷本超级菜鸟,谢谢!

    展开全文
  • Java计算器V2.0

    2017-04-20 00:54:05
    1.0版的计算器使用中发现了大量bug,比如数字大计算会溢出等,故经过改进后发布2.0版本如下: 先上效果图 代码如下:import java.awt.Color; import java.awt.Dimension; import java.awt.EventQueue; import java...

    1.0版的计算器使用中发现了大量bug,比如数字大计算会溢出等,故经过改进后发布2.0版本如下:
    先上效果图
    这里写图片描述

    代码如下:

    import java.awt.Color;
    import java.awt.Dimension;
    import java.awt.EventQueue;
    import java.awt.Toolkit;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.math.BigDecimal;
    import java.math.RoundingMode;
    import java.text.DecimalFormat;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JMenu;
    import javax.swing.JMenuBar;
    import javax.swing.JMenuItem;
    import javax.swing.JOptionPane;
    import javax.swing.JPanel;
    import javax.swing.SwingConstants;
    
    class Ans {
        private String num1 = "", num2 = ""; // num1、num2分别表示输入的第1、2个数,计算结果将刷新num1
        // 赋值与返回num1 num2
    
        public String getNum1() {
            return num1;
        }
    
        public void setNum1(String num1) {
            this.num1 = num1;
        }
    
        public String getNum2() {
            return num2;
        }
    
        public void setNum2(String num2) {
            this.num2 = num2;
        }
    
    
    
        // 判断进行了什么运算
        private int operation = 0,equals=0;//运算符   是否按过等号
    
        public int getOperation() {
            return operation;
        }
    
        public void setOperation(int operation) {
            this.operation = operation;
        }
    
        public int getEquals() {
            return equals;
        }
    
        public void setEquals(int equals) {
            this.equals = equals;
        }
    
    
    
    
    }
    
    public class MyCalculator {
    
        private JFrame frame;
    
        /**
         * Launch the application.
         */
        public static void main(String[] args) {
            EventQueue.invokeLater(new Runnable() {
                public void run() {
                    try {
                        MyCalculator window = new MyCalculator();
                        window.frame.setVisible(true);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    
        /**
         * Create the application.
         */
        public MyCalculator() {
            initialize();
        }
    
        /**
         * Initialize the contents of the frame.
         */
        private void initialize() {
            Dimension ScreenSize = Toolkit.getDefaultToolkit().getScreenSize();
            double scrh = ScreenSize.getHeight(), scrw = ScreenSize.getWidth();
            int frameh = 307, framew = 450;
    
            frame = new JFrame();
            frame.setTitle("计算器");
            frame.setBounds((int) (scrw - framew) / 2, (int) (scrh - frameh) / 2, frameh, framew);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            JPanel panel = new JPanel();
            panel.setLayout(null);
            frame.setContentPane(panel);
    
            JMenuBar bar = new JMenuBar();
            frame.setJMenuBar(bar);
    
            JMenu caidan = new JMenu("菜单");
            bar.add(caidan);
    
            JMenuItem exit = new JMenuItem("退出");
            caidan.add(exit);
            exit.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    int xz = JOptionPane.showConfirmDialog(frame, "要退出计算器吗?", "确定退出", JOptionPane.YES_NO_OPTION);
                    if (xz == 0)
                        System.exit(0);
                }
            });
    
            JMenu bangzhu = new JMenu("帮助");
            bar.add(bangzhu);
    
            JMenuItem sm=new JMenuItem("说明");
            bangzhu.add(sm);
            sm.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                    String shuoming="Ⅰ.每次运算以等号结束,连续按等号可以连续运算,但按等号后不按数字按运算符无效\nⅡ.最高精确到小数点后16位,数字不要超过10^99999\nⅢ.正负号按钮和百分号运算均不会结束一次运算";
                    JOptionPane.showMessageDialog(frame, shuoming,"操作说明",JOptionPane.PLAIN_MESSAGE);}
            });
    
            JMenuItem gy = new JMenuItem("关于");
            bangzhu.add(gy);
            gy.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    JOptionPane.showMessageDialog(frame, "软件名:计算器\n版本号:2.0\n制作时间:2017年4月16日\n制作人:muyangren907\n          软件持续更新完善中,敬请期待", "版权信息",
                            JOptionPane.PLAIN_MESSAGE);
                }
            });
    
            JButton[] button = new JButton[10];
            int j = 0, k = 0;
            for (int i = 1; i < 10; i++) {
                button[i] = new JButton(String.valueOf(i));
                button[i].setBackground(Color.LIGHT_GRAY);
                button[i].setBounds(50 + 50 * k, 220 - 50 * j, 50, 50);
                k++;
                if (k == 3) {
                    j++;
                    k = 0;
                }
                panel.add(button[i]);
            }
    
            button[0] = new JButton("0");
            button[0].setBackground(Color.LIGHT_GRAY);
            button[0].setBounds(50, 270, 100, 50);
            panel.add(button[0]);
    
            JButton buttondot = new JButton(".");
            buttondot.setBackground(Color.LIGHT_GRAY);
            buttondot.setBounds(150, 270, 50, 50);
            panel.add(buttondot);
    
            JButton buttonadd = new JButton("+");
            buttonadd.setBackground(Color.LIGHT_GRAY);
            buttonadd.setBounds(200, 220, 50, 50);
            panel.add(buttonadd);
    
            JButton buttonminus = new JButton("-");
            buttonminus.setBackground(Color.LIGHT_GRAY);
            buttonminus.setBounds(200, 170, 50, 50);
            panel.add(buttonminus);
    
            JButton buttonmultiply = new JButton("×");
            buttonmultiply.setBackground(Color.LIGHT_GRAY);
            buttonmultiply.setBounds(200, 120, 50, 50);
            panel.add(buttonmultiply);
    
            JButton buttondivide = new JButton("÷");
            buttondivide.setBackground(Color.LIGHT_GRAY);
            buttondivide.setBounds(200, 70, 50, 50);
            panel.add(buttondivide);
    
            JButton buttonequals = new JButton("=");
            buttonequals.setBackground(Color.LIGHT_GRAY);
            buttonequals.setBounds(200, 270, 50, 50);
            panel.add(buttonequals);
    
            JButton buttonac = new JButton("AC");
            buttonac.setBackground(Color.LIGHT_GRAY);
            buttonac.setBounds(50, 70, 50, 50);
            panel.add(buttonac);
    
            JButton buttonzf = new JButton("+/-");
            buttonzf.setBackground(Color.LIGHT_GRAY);
            buttonzf.setBounds(100, 70, 50, 50);
            panel.add(buttonzf);
    
            JButton buttonbfh = new JButton("%");
            buttonbfh.setBackground(Color.LIGHT_GRAY);
            buttonbfh.setBounds(150, 70, 50, 50);
            panel.add(buttonbfh);
    
            JLabel labelans = new JLabel("0");
            labelans.setHorizontalAlignment(SwingConstants.RIGHT);
            labelans.setBounds(50, 20, 200, 50);
            panel.add(labelans);
    
            Ans ans = new Ans();//创建答案对象
    
            //以下为按钮动作监听
    
            button[0].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        if(ans.getNum1().charAt(0)=='0'&&ans.getNum1().indexOf(".")==-1){                       
                        }
                        else{
                            ans.setNum1(ans.getNum1()+"0");
                        }
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"0");
                        labelans.setText(ans.getNum2());
                    }
                }
            });
    
            button[1].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"1");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"1");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[2].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"2");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"2");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[3].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"3");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"3");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[4].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"4");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"4");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[5].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"5");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"5");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[6].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"6");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"6");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[7].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"7");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"7");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[8].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"8");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"8");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            button[9].addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()!=0){
                        ans.setNum1("");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                    }
                    if(ans.getOperation()==0){
                        ans.setNum1(ans.getNum1()+"9");
                        labelans.setText(ans.getNum1());
                    }else{
                        ans.setNum2(ans.getNum2()+"9");
                        labelans.setText(ans.getNum2());
                    }
    
                }
            });
    
            //"."按钮
            buttondot.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if(ans.getEquals()==0){
                        if (ans.getOperation() == 0) {
                            if (ans.getNum1().indexOf(".") == -1)
                                ans.setNum1(ans.getNum1() + ".");
                            labelans.setText(ans.getNum1());
                        } else {
                            if (ans.getNum2().indexOf(".") == -1)
                                ans.setNum2(ans.getNum2() + ".");
                            labelans.setText(ans.getNum2());
                        }   
                    }else{
                        ans.setNum1("0.");
                        ans.setNum2("");
                        ans.setOperation(0);
                        ans.setEquals(0);
                        labelans.setText(ans.getNum1());
                    }
    
                }
            });
    
        //"+-*/"
        buttonadd.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                ans.setOperation(1);
                labelans.setText("+");
            }
        });
        buttonminus.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                ans.setOperation(2);
                labelans.setText("-");
            }
        });
        buttonmultiply.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                ans.setOperation(3);
                labelans.setText("×");
            }
        }); 
        buttondivide.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                ans.setOperation(4);
                labelans.setText("÷");
            }
        });
    
        //"="的动作监听
        buttonequals.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e) {
                    ans.setEquals(1);
                    if (ans.getNum1().equals(""))
                        ans.setNum1("0");
                    if (ans.getNum2().equals(""))
                        ans.setNum2("0");
    
                    BigDecimal b1 = new BigDecimal(ans.getNum1()).stripTrailingZeros(); // 去除末尾多余的0
                    BigDecimal b2 = new BigDecimal(ans.getNum2()).stripTrailingZeros();
                    ans.setNum1(b1.toPlainString());
                    ans.setNum2(b2.toPlainString()); // 防止科学记数法输出
    
                    DecimalFormat df = new DecimalFormat();
                    String style = "0.00000000000E00000";
                    df.applyPattern(style);
    
                    if (ans.getOperation() == 1) {
                        if (b1.add(b2).toPlainString().length() <= 27)
                            ans.setNum1(b1.add(b2).toPlainString());
                        else
                            ans.setNum1(df.format(b1.add(b2)));              //科学计数法
                    } else if (ans.getOperation() == 2) {
                        if (b1.subtract(b2).toPlainString().length() <= 27)
                            ans.setNum1(b1.subtract(b2).toPlainString());
                        else
                            ans.setNum1(df.format(b1.subtract(b2)));
                    } else if (ans.getOperation() == 3) {
                        if (b1.multiply(b2).toPlainString().length() <= 27)
                            ans.setNum1(b1.multiply(b2).toPlainString());
                        else
                            ans.setNum1(df.format(b1.multiply(b2)));
                    } else if (ans.getOperation() == 4) {
                        if(b1.divide(b2, 16, RoundingMode.HALF_UP).toPlainString().length() <= 27)
                        ans.setNum1(b1.divide(b2, 16, RoundingMode.HALF_UP).toPlainString());
                        else
                            ans.setNum1(df.format(b1.divide(b2, 16, RoundingMode.HALF_UP)));
                    }
    
                    labelans.setText(ans.getNum1().replace("E", "×10^"));
    
                }
        });
    
        buttonac.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                ans.setNum1("");
                ans.setNum2("");
                ans.equals(0);
                ans.setOperation(0);
                labelans.setText("0");
            }
        });
    
        buttonbfh.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    BigDecimal b1 = new BigDecimal(ans.getNum1()).stripTrailingZeros(); // 去除末尾多余的0
                    BigDecimal b2 = new BigDecimal("100").stripTrailingZeros();
                    ans.setNum1(b1.toPlainString()); // 防止科学记数法输出
    
                    DecimalFormat df = new DecimalFormat();
                    String style = "0.0000E00";
                    df.applyPattern(style);
                    if (b1.divide(b2, 16, RoundingMode.HALF_UP).toPlainString().length() <= 27)
                        ans.setNum1(b1.divide(b2, 16, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString());
                    else
                        ans.setNum1(df.format(b1.divide(b2, 16, RoundingMode.HALF_UP).stripTrailingZeros()));
                    labelans.setText(ans.getNum1().replace("E", "×10^"));
                }
        });
    
        buttonzf.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if(ans.getOperation()==0){
                    if(ans.getNum1().indexOf("-")==-1)
                        ans.setNum1("-"+ans.getNum1());
                    labelans.setText(ans.getNum1().replace("E", "×10^"));
                }else{
                    if(ans.getNum2().indexOf("-")==-1)
                        ans.setNum2("-"+ans.getNum2());
                    labelans.setText(ans.getNum2().replace("E", "×10^"));
                }
    
    
            }
        });
            //end
        }
    
    }
    

    104行改为

    frame.setType(Type.UTILITY);

    貌似比较好看

    源码及打包生成的jar及exe文件均已上传至网盘(2.0为本计算器)
    链接: https://pan.baidu.com/s/1skQnqhf
    密码: 牛B
    仅供交流,引用请注明作者

    展开全文
  • (4)从第一个文件中取第一个操作数,从第二个文件中取第二个操作数,将其按照第三步中选择的运算做加减乘除后存入第三个文件中。 (5)从第三个文件中读取出运算结果。 其他要求: (1)要求处理double型或float...
  • package com.cn.java;import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.InputStream;import java.util.Properties;.../*** @version 计算器V1.1* @author 860...

    package com.cn.java;

    import java.io.BufferedInputStream;

    import java.io.FileInputStream;

    import java.io.InputStream;

    import java.util.Properties;

    import java.util.Scanner;

    /**

    * @version 计算器V1.1

    * @author 860616034

    *

    */

    public class Calculator {

    // 运算符

    public static String operator2;

    // 第一个计算数字

    public static String oneNumber;

    // 第二个计算数字

    public static String twoNumber;

    // 计算数的长度

    public static String setlength;

    // string转double 第一个数

    private static double one;

    // string转double 第二个数

    private static double two;

    // 计算器的位数

    private static int number;

    public static void main(String[] args) {

    // 定义string变量

    String operator = "";

    boolean bresult = true;

    // 创建Scanner的对象 System.in是标准输入

    Scanner input = new Scanner(System.in);

    // double one = 0;

    double result = 0;

    Calculator ca = new Calculator();

    // 输入要计算的位数

    // ca.getInput(input);

    ca.getInput1();

    // ca.getInput2();

    // 用于程序循环执行

    while (true) {

    // 用户输入第一个数

    ca.getOneNumber(input);

    // 提示用户请输入运算符

    ca.getOperator(operator, input);

    // 提示用户输入要计算的第二个数

    ca.getTwoNumber(input);

    // switch循环实现运算

    switch (operator2) {

    case "+":

    result = one + two;

    break;

    case "-":

    result = one - two;

    break;

    case "*":

    result = one * two;

    break;

    case "/":

    result = one / two;

    // 除数特殊,被除数不能为0,提示用户

    if (two == 0) {

    System.out.println("被除数不能为0,结果错误!");

    // 为false不输出结果

    bresult = false;

    }

    break;

    default:

    break;

    }

    // 为true输出计算结果

    if (bresult) {

    System.out.println("结果是:" + oneNumber + " " + operator2 + " " + twoNumber + " = " + result);

    }

    }

    }

    // 判断字符串长度的方法

    public static boolean getLength(String oneNumber) {

    if (oneNumber.length() > number) {

    System.out.println("输入错误,不能超过" + number + "位");

    return false;

    }

    return true;

    }

    // 输入运算的进行判断的方法

    public void getOperator(String operator, Scanner input) {

    System.out.println("请输入运算符:");

    operator = input.nextLine();

    // 对运算符进行判断是否有该运算符

    // String[] op = { "+", "-", "*", "/" };

    // SetstrSet = new HashSet(Arrays.asList(op));

    if (operator.equals("+") || operator.equals("-") || operator.equals("*") || operator.equals("/")) {

    // if (strSet.contains(operator)) {

    operator2 = operator;

    } else {

    System.out.println("运算符输入错误,请重新输入");

    getOperator(operator, input);

    }

    }

    // 输入第二个数进行判断的方法

    public void getTwoNumber(Scanner input) {

    // public void getTwoNumber(String twoNumber, Scanner input) {

    System.out.println("请输入第二个数字:");

    twoNumber = input.nextLine();

    // 判断输入的字符是否超过16个

    boolean isTwoNumber = getLength(twoNumber);

    if (!isTwoNumber) {

    getTwoNumber(input);

    } else if (twoNumber.equals("exit")) {

    System.out.println("退出程序,欢迎下次使用");

    return;

    } else {

    try {

    Calculator.two = Double.parseDouble(twoNumber);

    } catch (Exception e) {

    System.out.println("请输入有效数字");

    getTwoNumber(input);

    }

    }

    }

    public void getOneNumber(Scanner input) {

    System.out.println("请输入第一个数字:");

    oneNumber = input.nextLine();

    // 判断输入的字符是否超过16个

    boolean isLength = getLength(oneNumber);

    if (!isLength) {

    getOneNumber(input);

    } else if (oneNumber.equals("exit")) {

    System.out.println("退出程序,欢迎下次使用");

    System.exit(0);

    } else {

    try {

    Calculator.one = Double.parseDouble(oneNumber);

    } catch (Exception e) {

    System.out.println("请输入有效数字");

    getOneNumber(input);

    }

    }

    }

    // 控制台输入

    public void getInput(Scanner input) {

    System.out.println("请输入计算器计算的位数:");

    Calculator.setlength = input.nextLine();

    try {

    Calculator.number = Integer.parseInt(setlength);

    } catch (Exception e) {

    System.out.println("请输入正确的有效数字");

    getInput(input);

    }

    }

    public void getInput1() {

    try {

    Properties prop = new Properties();

    // System.out.println(Test.class.getResource ("").getFile ());

    InputStream is = new BufferedInputStream(new FileInputStream("bin/com/cn/java/a.xml"));

    // 加载Properties文件信息属性列表

    prop.load(is);

    String str = prop.getProperty("length");

    //System.out.println(prop.getProperty("length"));

    // 关闭流释放测内存

    is.close();

    number = Integer.parseInt(str);

    } catch (Exception e) {

    System.out.println("请输入有效位数数字");

    return;

    }

    }

    }

    展开全文
  • Java计算器实现加减乘除功能

    万次阅读 2017-03-03 17:44:29
    package com.cn.java;import java.io.BufferedInputStream; import java.io.FileInputStream; import java.io.InputStream; import java.util.Properties; import java.util.Scanner;... * @version 计算器V1.1 * @au
  • Java计算器(结对)

    2015-05-17 11:34:00
    我们要做的是一个多功能计算器Java程序编辑器是:图形界面、线程、流与文件等技术的综合应用。图形界面的实现:考虑简单、实用、高效等特点,就选择了Swing来完成实现,在选择组件上,文本编辑区就选用了...
  • 计算器输入计算式输出结果

    千次阅读 2017-12-04 20:27:40
    这个比较简单,只能实现两个数的加减乘除运算,后面那个虽然实现了输入式子输出结果,但是比较麻烦。import java.util.Scanner;public class Calculator { public static void main(String[] args) { Scanner sc =...
  • JAVA制作简单的计算器

    万次阅读 多人点赞 2018-05-18 15:30:48
    关键词:java计算器,简单计算器,java程序设计,设置监听器。前期需要:IDE ,javafx包思路:分为两个方面,第一是计算器的界面怎么做,需要什么元素、控件。第二是对运算的实现。1、首先来分析一下计算器的基本...
  • 只有加减乘除运算,键盘不能输入,输出结果为浮点型
  • 计算器 数据结构 java

    2013-04-09 21:20:29
    输入:不含变量的数字表达式的中缀形式,可以接受的操作符包括+、-、*、/、%和... ·注:输入、输出形式可采取终端设备输入、输出,也可以采取文件输入、输出,一个文件中可包含多个表达式。  ·知识点:堆栈、队列
  • JAVA 简单的计算器

    2016-12-19 15:44:47
    带GUI的简单计算器 可以将计算结果保存到文件 Main.java public class Main { public static void main(String[] args) { Calculator calculator=new Calculator(); } } Calculator.java import java.awt....
  • import java.awt.*; import java.io.*; import java.io.File; import java.io.FileNotFoundException; import java.awt.datatransfer.*; import java.awt.datatransfer.Clipboard; import java.awt.datatransfer....
  • java实现简单计算器 断断续续的几天时间里,尝试着用java实现了一个简单的计算器。上一次的修复版增加了...5个java文件在一个lianxi包中。Caculator.java是主类来创建两个界面一个Programmer.java和一个std.java...
  • Java实现简单计算器

    千次阅读 多人点赞 2020-02-14 10:54:14
    实训要求:(1)要使用 java 的 GUI 设计出计算器界面。(2)通过界面按钮,可以实现整数或浮点数的四则运算,并能将结果显示在界面中。(3)计算可以有小数点,和正负整数的计算。(4)要有清零功能。 二 类设计 ...
  • 小项目-Java开发简单的计算器

    万次阅读 多人点赞 2017-01-16 20:14:28
    本次实验制作一个可以进行简单的四则运算的计算器,会使用 Java swing 进行开发。 1.1 知识点 Java Swing 界面编程计算器逻辑运算实现 1.2 实验环境介绍 本实验环境采用带桌面的 Ubuntu Linux 环
  • package ... import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOEx...
  • Java输入输出流--文件

    2016-12-12 19:12:37
    /* * To change this template, choose Tools | Templates * and open the template in the editor. */ ...import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File;
  • Java —— 计算器(前端+后台) 要求: 可以计算整型也可以计算浮点型 可以计算带括号的四则运算 当结果为整数时不带小数点 算出结果后若还有运算操作则结果就是第一个输入 可退格和清空 参考界面如下: 整型运算...
  • java编写的计算器

    2015-06-30 09:27:27
    // 日志输出到全局的 即rootLogger 指定的文件中 //long start=System.currentTimeMillis(); public static void main(String[] args)  {/* System.out.println("Hello World"); String name = ...
  • 这是在校期间用JAVA 开发的一个语音计算器,在学习JAVA的时候想着做一个作品出来就把语音和文件输入输出和数据库全用了,就做出了这个程序!功能还算比较强大的吧,自动解释算数表达式和函数表达式。
  • 这是我挺久以前课程设计java写的计算器,只能实现基本的功能,我现在分享出来希望能帮助别人。写得其实挺一般的,见谅见谅。有课程设计任务的学弟学妹也是写计算器的可以看看参考参考。源代码里我写有挺多解析的,...
  • JAVA图形界面:加法计算器

    千次阅读 多人点赞 2020-10-19 20:21:25
    JAVA用于开发图形界面应用的 SWING 组件包功能强大,使用方便。接下来我们就使用其写一个简单的图形界面小程序:加法计算器。 第一步: 首先得构思,我们要做什么。加法计算器的话,做出来之后大概是这个样子的。 ...
  • 基于JAVA GUI图形用户界面的计算器

    千次阅读 2019-12-08 21:55:37
    利用java gui实现一个简单的计算器, 设计思路 设计这个计算器主要是参考Windows操作系统中自带的计算器,由于编者水平和时间的限制,不能将计算器设计科学型及其他更复杂的类型,在设计过程中还参考了一些其他的...
  • Java编写计算器--学习笔记,附源码

    千次阅读 2020-04-21 16:22:39
    目录实验题目及内容软件设计简易流程图实验流程图实验程序与结果实验结果分析和问题讨论 实验题目及内容 注:嵌套布局需要灵活使用中间容器JPanel 软件设计简易流程图 实验流程图 实验程序与结果 ...
  • 近半个月的时间学习了Java的一些基础语法。为了巩固近段的学习以及增强记忆,手写一个简单的GUI计算器小程序。搜索了一下网上的一些计算器小程序,大部分缺少括号运算、小数点运算、有些仅仅实现了一位数字运算。...
  • 该项目是一个通过Java实现的计算器小程序,该计算器具有实现加减乘除、取余等功能。 将介绍如何通过Java来实现该项目的全部过程。 在该项目中将介绍新的技术JavaFX,JavaFX拥有比swing更加友好的外观。 使用...
  • 本文例程出自《Java核心技术》,主编:马志强、张然等。...1.Java简易计算器实现 1.1.效果 1.2.代码 package charpter06.edu.com.login.JMenuTest; import java.awt.BorderLayout; import java.awt.Color; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,226
精华内容 4,090
关键字:

java计算器输出结果到文件

java 订阅