当前位置：首页 » 编程语言 » java计算器的界面

java计算器的界面

发布时间: 2021-03-18 07:44:17

Ⅰ 用java编写计算器界面

分析
边界布局和
表格布局嵌套使用
详细代码和注释
附件下载

Ⅱ java编写计算器界面

以前我自己的实验作业

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class Jsq extends JFrame
{
JMenu menu1=new JMenu("编辑（E）");
JMenu menu2=new JMenu("查看（V）");
JMenu menu3=new JMenu("帮助（H）");
JMenuBar bar=new JMenuBar();

JTextField text=new JTextField("0.",20);

JRadioButton c1=new JRadioButton("十六进制",false);
JRadioButton c2=new JRadioButton("十进制",true);
JRadioButton c3=new JRadioButton("八进制",false);
JRadioButton c4=new JRadioButton("二进制",false);

JRadioButton d1=new JRadioButton("角度",true);
JRadioButton d2=new JRadioButton("弧度",false);
JRadioButton d3=new JRadioButton("梯度",false);

JCheckBox e1=new JCheckBox("Inv");
JCheckBox e2=new JCheckBox("Hyp");
JTextField lb1=new JTextField(3);
JTextField lb2=new JTextField(3);

JButton a1=new JButton("Backspace");
JButton a2=new JButton(" CE ");
JButton a3=new JButton(" C ");
JButton a4=new JButton("Sta");
JButton a5=new JButton("Ave");
JButton a6=new JButton("Sum");
JButton a7=new JButton("S");
JButton a8=new JButton("Dat");
JButton a9=new JButton("F-E");
JButton a10=new JButton("dms");
JButton a11=new JButton("sin");
JButton a12=new JButton("cos");
JButton a13=new JButton("tan");
JButton a14=new JButton("(");
JButton a15=new JButton("Exp");
JButton a16=new JButton("x^y");
JButton a17=new JButton("x^3");
JButton a18=new JButton("x^2");
JButton a19=new JButton(")");
JButton a20=new JButton("In");
JButton a21=new JButton("log");
JButton a22=new JButton("n!");
JButton a23=new JButton("1/x");
JButton a24=new JButton("MC");
JButton a25=new JButton("MR");
JButton a26=new JButton("MS");
JButton a27=new JButton("M+");
JButton a28=new JButton("pi");
JButton a29=new JButton("7");
JButton a30=new JButton("4");
JButton a31=new JButton("1");
JButton a32=new JButton("0");
JButton a33=new JButton("A");
JButton a34=new JButton("8");
JButton a35=new JButton("5");
JButton a36=new JButton("2");
JButton a37=new JButton("+/-");
JButton a38=new JButton("B");
JButton a39=new JButton("9");
JButton a40=new JButton("6");
JButton a41=new JButton("3");
JButton a42=new JButton(".");
JButton a43=new JButton("C");
JButton a44=new JButton("/");
JButton a45=new JButton("*");
JButton a46=new JButton("-");
JButton a47=new JButton("+");
JButton a48=new JButton("D");
JButton a49=new JButton("Mod");
JButton a50=new JButton("Or");
JButton a51=new JButton("Lsh");
JButton a52=new JButton("=");
JButton a53=new JButton("E");
JButton a54=new JButton("And");
JButton a55=new JButton("Xor");
JButton a56=new JButton("Not");
JButton a57=new JButton("Int");
JButton a58=new JButton("F");

Jsq()
{
super("计算器");
setSize(900,360);
setVisible(true);
Container con=getContentPane();

JPanel panel1=new JPanel();//菜单栏和文本
panel1.setLayout(new GridLayout(2,1));
bar.add(menu1);
bar.add(menu2);
bar.add(menu3);
panel1.add(bar);
panel1.add(text);

JPanel panel2=new JPanel();//单选框
panel2.setLayout(new GridLayout(1,2));
ButtonGroup cbg1=new ButtonGroup();
cbg1.add(c1);
cbg1.add(c2);
cbg1.add(c3);
cbg1.add(c4);
JPanel jp1=new JPanel();
jp1.setLayout(new FlowLayout());
jp1.add(c1);jp1.add(c2);jp1.add(c3);jp1.add(c4);
ButtonGroup cbg2=new ButtonGroup();
cbg2.add(d1);
cbg2.add(d2);
cbg2.add(d3);
JPanel jp2=new JPanel();
jp2.setLayout(new FlowLayout());
jp2.add(d1);
jp2.add(d2);
jp2.add(d3);
panel2.add(jp1);
panel2.add(jp2);

JPanel panel3=new JPanel();//复选框
panel3.setLayout(new FlowLayout(FlowLayout.CENTER,20,5));
panel3.add(e1);
panel3.add(e2);
panel3.add(lb1);lb1.setEditable(false);
panel3.add(lb2);lb2.setEditable(false);

JPanel panel4=new JPanel();//三个按钮
panel4.setLayout(new FlowLayout(FlowLayout.CENTER,3,5));
panel4.add(a1);
panel4.add(a2);
panel4.add(a3);

JPanel panel5=new JPanel();//第一列按钮
panel5.setLayout(new GridLayout(5,1,3,3));
panel5.add(a4);
panel5.add(a5);
panel5.add(a6);
panel5.add(a7);
panel5.add(a8);

JPanel panel6=new JPanel();//第二三四列按钮
panel6.setLayout(new GridLayout(5,3,3,3));
panel6.add(a9);
panel6.add(a14);
panel6.add(a19);
panel6.add(a10);
panel6.add(a15);
panel6.add(a20);
panel6.add(a11);
panel6.add(a16);
panel6.add(a21);
panel6.add(a12);
panel6.add(a17);
panel6.add(a22);
panel6.add(a13);
panel6.add(a18);
panel6.add(a23);

JPanel panel7=new JPanel();//第五列按钮
panel7.setLayout(new GridLayout(5,1,3,3));
panel7.add(a24);
panel7.add(a25);
panel7.add(a26);
panel7.add(a27);
panel7.add(a28);

JPanel panel8=new JPanel();//第六七八九十十一列按钮
panel8.setLayout(new GridLayout(5,6,3,3));
panel8.add(a29);panel8.add(a34);panel8.add(a39);panel8.add(a44);panel8.add(a49);panel8.add(a54);
panel8.add(a30);panel8.add(a35);panel8.add(a40);panel8.add(a45);panel8.add(a50);panel8.add(a55);
panel8.add(a31);panel8.add(a36);panel8.add(a41);panel8.add(a46);panel8.add(a51);panel8.add(a56);
panel8.add(a32);panel8.add(a37);panel8.add(a42);panel8.add(a47);panel8.add(a52);panel8.add(a57);
panel8.add(a33);panel8.add(a38);panel8.add(a43);panel8.add(a48);panel8.add(a53);panel8.add(a58);

JPanel panel9=new JPanel();//前五列按钮添加入同一个面板
panel9.setLayout(new FlowLayout(FlowLayout.CENTER,20,0));
panel9.add(panel5);
panel9.add(panel6);
panel9.add(panel7);

JPanel panel12=new JPanel();//复选框与三个按钮添加入同一面板
panel12.setLayout(new GridLayout(1,2,200,5));
panel12.add(panel3);
panel12.add(panel4);

JPanel panel10=new JPanel();//十一列按钮添加入同一面板
panel10.setLayout(new FlowLayout(FlowLayout.CENTER,50,3));
panel10.add(panel9);
panel10.add(panel8);

JPanel panel11=new JPanel();//单选框与菜单文本添加入同一面板
panel11.setLayout(new GridLayout(3,1));
panel11.add(panel1);
panel11.add(panel2);
panel11.add(panel12);

con.setLayout(new GridLayout(2,1));//三大块面板合一
con.add(panel11);
con.add(panel10);
validate();
addWindowListener(new WindowCloser());
}

public class WindowCloser extends WindowAdapter
{
public void windowClosing(WindowEvent we)
{
System.exit(0);
}
}

}

public class Ex9_3
{
public static void main(String[] args)
{
new Jsq();
}
}

Ⅲ java计算器界面代码

纯原创，已编译运行无错误，运用的是最简单最基本的知识，简单易懂，望点赞
（一）源代码
import java.awt.*;
import java.awt.event.*;

public class JSQ
{
public static void main(String[] args)
{
//创建新的面板
JSQFrame f = new JSQFrame();
}
}

class JSQFrame extends Frame
{
double d1, d2;
int m = -1;
TextField tf;
Panel1 p1;
Panel2 p2;

JSQFrame()
{
//设置标题，位置，大小，文本框大小以及不可修改性
setTitle("计算器");
setLayout(new FlowLayout(FlowLayout.CENTER,8,10));
setSize(200,180);
setResizable(false);

tf = new TextField(20);
tf.setEditable(false);
add(tf);

p1 = new Panel1();
p2 = new Panel2();
add(p1);
add(p2);
//设置可见性
setVisible(true);
addWindowListener(new Wclose());
}

class JSQButton extends Button
{
JSQButton(String s)
{
super(s); //调用父类的方法
}
}

class Panel1 extends Panel
{
JSQButton b0, b1, b2, b3,b4, b5, b6, b7, b8, b9, bQF, bPoint;

Panel1()
{
setLayout(new GridLayout(4,4));

b0 = new JSQButton("0");
b1 = new JSQButton("1");
b2 = new JSQButton("2");
b3 = new JSQButton("3");
b4 = new JSQButton("4");
b5 = new JSQButton("5");
b6 = new JSQButton("6");

b7 = new JSQButton("7");
b8 = new JSQButton("8");
b9 = new JSQButton("9");
bQF = new JSQButton("+/-");
bPoint = new JSQButton(".");
//注册监听器
add(b7); b7.addActionListener(new B7());
add(b8); b8.addActionListener(new B8());
add(b9); b9.addActionListener(new B9());
add(b4); b4.addActionListener(new B4());
add(b5); b5.addActionListener(new B5());
add(b6); b6.addActionListener(new B6());
add(b1); b1.addActionListener(new B1());
add(b2); b2.addActionListener(new B2());
add(b3); b3.addActionListener(new B3());
add(b0); b0.addActionListener(new B0());
add(bPoint); bPoint.addActionListener(new BPoint());
add(bQF); bQF.addActionListener(new BQF()); ;

}
}

class Panel2 extends Panel
{
JSQButton bAdd, bSub, bMul, bDiv, bYx, bEqual, bAC, bBack;

Panel2()
{
setLayout(new GridLayout(4,4));

bAdd = new JSQButton("+");
bSub = new JSQButton("-");
bMul = new JSQButton("*");
bDiv = new JSQButton("/");
bYx = new JSQButton("^");
bEqual = new JSQButton("=");
bAC = new JSQButton("AC");
bBack = new JSQButton("DEL");
//注册监听器
add(bBack); bBack.addActionListener(new BBack());
add(bAC); bAC.addActionListener(new BAC());
add(bAdd); bAdd.addActionListener(new BAdd());
add(bSub); bSub.addActionListener(new BSub());
add(bMul); bMul.addActionListener(new BMul());
add(bDiv); bDiv.addActionListener(new BDiv());
add(bYx); bYx.addActionListener(new BYx());
add(bEqual); bEqual.addActionListener(new BEqual());
//设置按钮颜色
bAC.setForeground(Color.blue);
bBack.setForeground(Color.blue);
bEqual.setForeground(Color.red);

}
}

// 实现加法的监听器
class BAdd implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
try {
d1 = Double.parseDouble(tf.getText());
m = 0;
tf.setText("");
} catch(Exception ee) {}
}
}

class BSub implements ActionListener{
public void actionPerformed(ActionEvent e)
{
try {
d1 = Double.parseDouble(tf.getText());
m = 1;
tf.setText("");

} catch(Exception ee) {}
}
}

class BMul implements ActionListener{
public void actionPerformed(ActionEvent e)
{
try {
d1 = Double.parseDouble(tf.getText());
m = 2;
tf.setText("");
} catch(Exception ee) {}
}
}

class BDiv implements ActionListener {
public void actionPerformed(ActionEvent e)
{
try {
d1 = Double.parseDouble(tf.getText());
m = 3;
tf.setText("");
} catch(Exception ee) {}
}
}

class BYx implements ActionListener {
public void actionPerformed(ActionEvent e) {
try {
d1 = Double.parseDouble(tf.getText());
m = 4;
tf.setText("");
} catch(Exception ee) {}
}
}

class BEqual implements ActionListener {
public void actionPerformed(ActionEvent e)
{
try {
double result = 0;
d2 = Double.parseDouble(tf.getText());
switch(m)
{
case 0:result = d1 + d2;break;
case 1:result = d1 - d2;break;
case 2:result = d1 * d2;break;
case 3:result = d1 / d2;break;
case 4:result = Math.pow(d1,d2);break;
default:
}
tf.setText(String.valueOf(result));
} catch(Exception ee) {}
}
}

class BBack implements ActionListener {
public void actionPerformed(ActionEvent e) {
try {
String text = tf.getText();
text = text.substring(0,text.length()-1);
tf.setText(text);
} catch(Exception ee) {}
}
}

class BAC implements ActionListener {
public void actionPerformed(ActionEvent e) {
tf.setText("");
}
}

class BQF implements ActionListener {
public void actionPerformed(ActionEvent e) {
try {
String text = tf.getText();
if (text != "") {
if(text.charAt(0) == '-')

tf.setText(text.substring(1));
else if(text.charAt(0) >= '0' && text.charAt(0) <= '9')
tf.setText("-"+text.substring(0));
else if(text.charAt(0) == '.')
tf.setText("-0"+text.substring(0));
}
} catch(Exception ee) { }

}
}

class BPoint implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
if(text.lastIndexOf(".") == -1)
tf.setText(text+".");
}
}

class B0 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"0");
}
}

class B1 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"1");
}
}

class B2 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"2");
}
}

class B3 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"3");
}
}

class B4 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"4");
}
}

class B5 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"5");
}
}

class B6 implements ActionListener {
public void actionPerformed(ActionEvent e)
{
String text = tf.getText();
tf.setText(text+"6");
}
}

class B7 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"7");
}
}

class B8 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"8");
}
}

class B9 implements ActionListener {
public void actionPerformed(ActionEvent e) {
String text = tf.getText();
tf.setText(text+"9");
}
}

//设置关闭时窗口的动作
class Wclose extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
}

（二）编程思路：1，我们创建了一个框架；2，获取内容窗格、建立面板并将面板放入内容窗格之中；3，将按钮放入面板之中；4，通过注册监听器响应事件。
（三）算法：1.用switch语句比较m的值，设置0 1 2 3 4分别为加减乘除以及幂运算，设置加减乘除进行加减乘除运算，并将result的值赋给tf在文本框中显示；2.通过substring方法，实现退格的功能，并且返还tf的值在文本框中显示；3.按下“加减乘除”按钮前面的tf赋值给d1，按下“等于”按钮前的tf赋值给d2，以此来获取数值进行运算。
（四）程序说明:在我们所编写的程序中引用了两个包：java.awt.*; java.awt.event.*;设计了25个类：JSQ（公共类）、JSQFrame、JSQButton、Panel1、Panel2、BBack、 BAC、 BAdd 、
BSub、 BEqual、BDiv 、BYx、BMul、 BQF 、BPoint、B0、 B1、 B2 、
B3、 B4、 B5 、B6 、B7、 B8、 B9 。
在JSQ中的main ()方法中用类JSQFrame创建了一个frame对象,JSQFrame类继承Frame类；用textField创建了tf对象；创建了Panel类p1,p2;
（1）在该类中设置了框架的标题，尺寸，位置，文本框大小以及不可修改性；
（2）在JSQButton类中调用了父类中的构造方法；
（3）在Panel1、Pane2中设置了按钮，为每个按钮创建了监听器并且注册了监听器。
（4）用Double.parseDouble（）方法将textField类转为double类，并用catch语句来进行异常处理。

Ⅳ Java图形界面简单计算器

示例代码如下，请参考：

packagetest.com.test;

importjava.awt.*;
importjava.awt.event.*;
importjavax.swing.*;

publicclassCal{

TextFieldtf=newTextField(40);//显示文本框
StringBuffers1=newStringBuffer();//记录运算数字，以及保留结果
StringBuffers2=newStringBuffer();//记录运算数字，保留上一个输入的数字或运算结果
staticStringflag=newString();//标记运算符号：+，-，*，/
booleanstart=true;//标记运算开始或结束,保证一次运算之后，第二次进行运算时能同时清空显示界面，即s1为空

publicvoidinit(){
//主界面
JFramef=newJFrame("计算器");
JPanelp1=newJPanel();
p1.add(tf);
f.add(p1,BorderLayout.NORTH);
JPanelp2=newJPanel();
p2.setLayout(newGridLayout(1,3));
//动作监听器
ActionListenerlisten=newActionListener(){

publicvoidactionPerformed(ActionEventarg0){

//输入数字0~9
if(arg0.getActionCommand()=="0"){

if(!s1.toString().equals(newString())){
if(!start){
//s1清零，保证可以重新输入数字
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("0").toString());
}
}
if(arg0.getActionCommand()=="1"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("1").toString());
}
if(arg0.getActionCommand()=="2"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("2").toString());
}
if(arg0.getActionCommand()=="3"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("3").toString());
}
if(arg0.getActionCommand()=="4"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("4").toString());
}
if(arg0.getActionCommand()=="5"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("5").toString());
}
if(arg0.getActionCommand()=="6"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("6").toString());
}
if(arg0.getActionCommand()=="7"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("7").toString());
}
if(arg0.getActionCommand()=="8"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("8").toString());
}
if(arg0.getActionCommand()=="9"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
tf.setText(s1.append("9").toString());
}
//输入小数点
if(arg0.getActionCommand()=="."){
if(!start){
s1.delete(0,s1.length());
}
start=true;
if(s1.toString().equals(newString()))
tf.setText(s1.append("0.").toString());
elseif(s1.length()==1&&s1.charAt(0)=='-')
tf.setText(s1.append("0.").toString());
else
tf.setText(s1.append(".").toString());
}
//输入负号
if(arg0.getActionCommand()=="+/-"){
if(!start){
s1.delete(0,s1.length());
}
start=true;
if(s1.toString().equals(newString()))
tf.setText(s1.append('-').toString());
}
//退格Backspace
if(arg0.getActionCommand()=="Backspace"){
start=true;
if(s1.length()!=0){
//删除最后输入的一位
s1.deleteCharAt(s1.length()-1);
tf.setText(s1.toString());
}
}
//归零CE
if(arg0.getActionCommand()=="CE"){
//清空所有，start标记设为true
start=true;
s1.delete(0,s1.length());
s2.delete(0,s2.length());
tf.setText(s1.toString());
}
//清除C
if(arg0.getActionCommand()=="C"){
//清空当前输入，即s1清零
start=true;
s1.delete(0,s1.length());
tf.setText(s1.toString());
}
//加号
if(arg0.getActionCommand()=="+"){
start=true;
flag="+";
//s2接收s1的值
s2.append(String.valueOf(s1.toString()));
//s1清零，重新接收下一个数据
s1.delete(0,s1.length());
tf.setText(s1.toString());
}
//减号
if(arg0.getActionCommand()=="-"){
start=true;
flag="-";
s2.append(String.valueOf(s1.toString()));
s1.delete(0,s1.length());
tf.setText(s1.toString());
}
//乘号
if(arg0.getActionCommand()=="*"){
start=true;
flag="*";
s2.append(String.valueOf(s1.toString()));
s1.delete(0,s1.length());
tf.setText(s1.toString());
}
//除号
if(arg0.getActionCommand()=="/"){
start=true;
flag="/";
s2.append(String.valueOf(s1.toString()));
s1.delete(0,s1.length());
tf.setText(s1.toString());
}
//开根号
if(arg0.getActionCommand()=="sqrt"){
start=false;
doubles=Double.parseDouble(s1.toString());
s1.delete(0,s1.length());
tf.setText(s1.append(String.valueOf(Math.sqrt(s))).toString());
}
//求%
if(arg0.getActionCommand()=="%"){
start=false;
doubles=Double.parseDouble(s1.toString());
s1.delete(0,s1.length());
tf.setText(s1.append(String.valueOf(s/100)).toString());
}
//求1/x
if(arg0.getActionCommand()=="1/x"&&!s1.toString().equals(newString())&&Double.parseDouble(s1.toString())!=0){
start=false;
doubles=Double.parseDouble(s1.toString());
s1.delete(0,s1.length());
tf.setText(s1.append(String.valueOf(1/s)).toString());
}
//求结果
if(arg0.getActionCommand()=="="&&s1.length()!=0&&s2.length()!=0){
//start标记为false
start=false;
//分别获取s1和s2的值
doubles4=Double.parseDouble(s1.toString());
doubles3=Double.parseDouble(s2.toString());
//清空s1和s2，便于开始下一次运算
s1.delete(0,s1.length());
s2.delete(0,s2.length());
//四则运算
if(flag=="+"){
tf.setText(s1.append(String.valueOf(s3+s4)).toString());
}
if(flag=="-"){
tf.setText(s1.append(String.valueOf(s3-s4)).toString());
}
if(flag=="*"){
tf.setText(s1.append(String.valueOf(s3*s4)).toString());
}
if(flag=="/"){
tf.setText(s1.append(String.valueOf(s3/s4)).toString());
}
}

}
};
//添加按钮以及监听器
JButtonbks=newJButton("Backspace");
bks.addActionListener(listen);
JButtonce=newJButton("CE");
ce.addActionListener(listen);
JButtonc=newJButton("C");
c.addActionListener(listen);
p2.add(bks);
p2.add(ce);
p2.add(c);
f.add(p2);
JPanelp3=newJPanel();
p3.setLayout(newGridLayout(4,5));
JButtonb1=newJButton("7");
p3.add(b1);
b1.addActionListener(listen);
JButtonb2=newJButton("8");
p3.add(b2);
b2.addActionListener(listen);
JButtonb3=newJButton("9");
p3.add(b3);
b3.addActionListener(listen);
JButtonb4=newJButton("/");
p3.add(b4);
b4.addActionListener(listen);
JButtonb5=newJButton("sqrt");
p3.add(b5);
b5.addActionListener(listen);
JButtonb6=newJButton("4");
p3.add(b6);
b6.addActionListener(listen);
JButtonb7=newJButton("5");
p3.add(b7);
b7.addActionListener(listen);
JButtonb8=newJButton("6");
p3.add(b8);
b8.addActionListener(listen);
JButtonb9=newJButton("*");
p3.add(b9);
b9.addActionListener(listen);
JButtonb10=newJButton("%");
p3.add(b10);
b10.addActionListener(listen);
JButtonb11=newJButton("1");
p3.add(b11);
b11.addActionListener(listen);
JButtonb12=newJButton("2");
p3.add(b12);
b12.addActionListener(listen);
JButtonb13=newJButton("3");
p3.add(b13);
b13.addActionListener(listen);
JButtonb14=newJButton("-");
p3.add(b14);
b14.addActionListener(listen);
JButtonb15=newJButton("1/x");
p3.add(b15);
b15.addActionListener(listen);
JButtonb16=newJButton("0");
p3.add(b16);
b16.addActionListener(listen);
JButtonb17=newJButton("+/-");
p3.add(b17);
b17.addActionListener(listen);
JButtonb18=newJButton(".");
p3.add(b18);
b18.addActionListener(listen);
JButtonb19=newJButton("+");
p3.add(b19);
b19.addActionListener(listen);
JButtonb20=newJButton("=");
p3.add(b20);
b20.addActionListener(listen);
f.add(p3,BorderLayout.SOUTH);
f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
f.pack();
f.setVisible(true);
}

publicstaticvoidmain(Stringargs[]){
//调用方法，实现计算器
newCal().init();
}

}

Ⅳ JAVA图形用户界面设计一个简易计算器

下午发
五分钟搞定，先给你发个简单的，照例子自己去做你想要的计算器
package aaa;
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

public class YunSuan implements ActionListener,ItemListener
{
public static JFrame jf;
public static Container c;
public static JTextField jtf1,jtf2,jtf3;
public static JButton jb1;
public static Choice c2;

public static String fuhao="";

public YunSuan()
{
jf=new JFrame("加减乘除运算");
c=jf.getContentPane();
c.setLayout(new FlowLayout());
jtf1=new JTextField(10);
jtf2=new JTextField(10);
jtf3=new JTextField(10);
c2=new Choice();
jb1=new JButton("=");

}

public void Jiemian()
{

c.add(jtf1);
c2.addItemListener(this);
c2.add("");
c2.add("+");
c2.add("-");
c2.add("*");
c2.add("/");
c.add(c2);
c.add(jtf2);
jb1.addActionListener(this);
c.add(jb1);
c.add(jtf3);

jf.setLocation(200,100);
jf.setVisible(true);
jf.pack();
}
public static void main(String args[])
{
YunSuan ys=new YunSuan();
ys.Jiemian();
}

public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
double s1=Integer.parseInt(jtf1.getText());
double s2=Integer.parseInt(jtf2.getText());
double result=0;
if(fuhao.equals("+"))
{
result=s1+s2;
String result2=String.valueOf(result);
jtf3.setText(result2);
}
if(fuhao.equals("-"))
{
result=s1-s2;
String result2=String.valueOf(result);
jtf3.setText(result2);
}
if(fuhao.equals("*"))
{
result=s1*s2;
String result2=String.valueOf(result);
jtf3.setText(result2);
}
if(fuhao.equals("/"))
{
result=s1/s2;
String result2=String.valueOf(result);
jtf3.setText(result2);
}
}

public void itemStateChanged(ItemEvent ie)
{
if(ie.getSource()==c2)
{
String str1=c2.getSelectedItem();
fanhui(str1);
}
}
public String fanhui(String str2)
{
return fuhao=str2;
}
}

Ⅵ 用java编写了一个模拟计算器的界面设计，怎么实现运算功能呢

view sourceprint?
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
* 一个计算器，与Windows附件自带计算器的标准版功能、界面相仿。但还不支持键盘操作。
*/
public class Calculator extends JFrame implements ActionListener {
/** 计算器上的键的显示名字 */
private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6",
"*", "%", "1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };
/** 计算器上的功能键的显示名字 */
private final String[] COMMAND = { "Backspace", "CE", "C" };
/** 计算器左边的M的显示名字 */
private final String[] M = { " ", "MC", "MR", "MS", "M+" };
/** 计算器上键的按钮 */
private JButton keys[] = new JButton[KEYS.length];
/** 计算器上的功能键的按钮 */
private JButton commands[] = new JButton[COMMAND.length];
/** 计算器左边的M的按钮 */
private JButton m[] = new JButton[M.length];
/** 计算结果文本框 */
private JTextField resultText = new JTextField("0");

// 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字
private boolean firstDigit = true;
// 计算的中间结果。
private double resultNum = 0.0;
// 当前运算的运算符
private String operator = "=";
// 操作是否合法
private boolean operateValidFlag = true;

/**
* 构造函数
*/
public Calculator() {
super();
// 初始化计算器
init();
// 设置计算器的背景颜色
this.setBackground(Color.LIGHT_GRAY);
this.setTitle("计算器");
// 在屏幕(500, 300)坐标处显示计算器
this.setLocation(500, 300);
// 不许修改计算器的大小
this.setResizable(false);
// 使计算器中各组件大小合适
this.pack();
}

/**
* 初始化计算器
*/
private void init() {
// 文本框中的内容采用右对齐方式
resultText.setHorizontalAlignment(JTextField.RIGHT);
// 不允许修改结果文本框
resultText.setEditable(false);
// 设置文本框背景颜色为白色
resultText.setBackground(Color.WHITE);

// 初始化计算器上键的按钮，将键放在一个画板内
JPanel calckeysPanel = new JPanel();
// 用网格布局器，4行，5列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));
for (int i = 0; i < KEYS.length; i++) {
keys[i] = new JButton(KEYS[i]);
calckeysPanel.add(keys[i]);
keys[i].setForeground(Color.blue);
}
// 运算符键用红色标示，其他键用蓝色表示
keys[3].setForeground(Color.red);
keys[8].setForeground(Color.red);
keys[13].setForeground(Color.red);
keys[18].setForeground(Color.red);
keys[19].setForeground(Color.red);

// 初始化功能键，都用红色标示。将功能键放在一个画板内
JPanel commandsPanel = new JPanel();
// 用网格布局器，1行，3列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));
for (int i = 0; i < COMMAND.length; i++) {
commands[i] = new JButton(COMMAND[i]);
commandsPanel.add(commands[i]);
commands[i].setForeground(Color.red);
}

// 初始化M键，用红色标示，将M键放在一个画板内
JPanel calmsPanel = new JPanel();
// 用网格布局管理器，5行，1列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
calmsPanel.setLayout(new GridLayout(5, 1, 3, 3));
for (int i = 0; i < M.length; i++) {
m[i] = new JButton(M[i]);
calmsPanel.add(m[i]);
m[i].setForeground(Color.red);
}

// 下面进行计算器的整体布局，将calckeys和command画板放在计算器的中部，
// 将文本框放在北部，将calms画板放在计算器的西部。

// 新建一个大的画板，将上面建立的command和calckeys画板放在该画板内
JPanel panel1 = new JPanel();
// 画板采用边界布局管理器，画板里组件之间的水平和垂直方向上间隔都为3象素
panel1.setLayout(new BorderLayout(3, 3));
panel1.add("North", commandsPanel);
panel1.add("Center", calckeysPanel);

// 建立一个画板放文本框
JPanel top = new JPanel();
top.setLayout(new BorderLayout());
top.add("Center", resultText);

// 整体布局
getContentPane().setLayout(new BorderLayout(3, 5));
getContentPane().add("North", top);
getContentPane().add("Center", panel1);
getContentPane().add("West", calmsPanel);
// 为各按钮添加事件侦听器
// 都使用同一个事件侦听器，即本对象。本类的声明中有implements ActionListener
for (int i = 0; i < KEYS.length; i++) {
keys[i].addActionListener(this);
}
for (int i = 0; i < COMMAND.length; i++) {
commands[i].addActionListener(this);
}
for (int i = 0; i < M.length; i++) {
m[i].addActionListener(this);
}
}

/**
* 处理事件
*/
public void actionPerformed(ActionEvent e) {
// 获取事件源的标签
String label = e.getActionCommand();
if (label.equals(COMMAND[0])) {
// 用户按了"Backspace"键
handleBackspace();
} else if (label.equals(COMMAND[1])) {
// 用户按了"CE"键
resultText.setText("0");
} else if (label.equals(COMMAND[2])) {
// 用户按了"C"键
handleC();
} else if ("0123456789.".indexOf(label) >= 0) {
// 用户按了数字键或者小数点键
handleNumber(label);
// handlezero(zero);
} else {
// 用户按了运算符键
handleOperator(label);
}
}

/**
* 处理Backspace键被按下的事件
*/
private void handleBackspace() {
String text = resultText.getText();
int i = text.length();
if (i > 0) {
// 退格，将文本最后一个字符去掉
text = text.substring(0, i - 1);
if (text.length() == 0) {
// 如果文本没有了内容，则初始化计算器的各种值
resultText.setText("0");
firstDigit = true;
operator = "=";
} else {
// 显示新的文本
resultText.setText(text);
}
}
}

/**
* 处理数字键被按下的事件
*
* @param key
*/
private void handleNumber(String key) {
if (firstDigit) {
// 输入的第一个数字
resultText.setText(key);
} else if ((key.equals(".")) && (resultText.getText().indexOf(".") < 0)) {
// 输入的是小数点，并且之前没有小数点，则将小数点附在结果文本框的后面
resultText.setText(resultText.getText() + ".");
} else if (!key.equals(".")) {
// 如果输入的不是小数点，则将数字附在结果文本框的后面
resultText.setText(resultText.getText() + key);
}
// 以后输入的肯定不是第一个数字了
firstDigit = false;
}

/**
* 处理C键被按下的事件
*/
private void handleC() {
// 初始化计算器的各种值
resultText.setText("0");
firstDigit = true;
operator = "=";
}

/**
* 处理运算符键被按下的事件
*
* @param key
*/
private void handleOperator(String key) {
if (operator.equals("/")) {
// 除法运算
// 如果当前结果文本框中的值等于0
if (getNumberFromText() == 0.0) {
// 操作不合法
operateValidFlag = false;
resultText.setText("除数不能为零");
} else {
resultNum /= getNumberFromText();
}
} else if (operator.equals("1/x")) {
// 倒数运算
if (resultNum == 0.0) {
// 操作不合法
operateValidFlag = false;
resultText.setText("零没有倒数");
} else {
resultNum = 1 / resultNum;
}
} else if (operator.equals("+")) {
// 加法运算
resultNum += getNumberFromText();
} else if (operator.equals("-")) {
// 减法运算
resultNum -= getNumberFromText();
} else if (operator.equals("*")) {
// 乘法运算
resultNum *= getNumberFromText();
} else if (operator.equals("sqrt")) {
// 平方根运算
resultNum = Math.sqrt(resultNum);
} else if (operator.equals("%")) {
// 百分号运算，除以100
resultNum = resultNum / 100;
} else if (operator.equals("+/-")) {
// 正数负数运算
resultNum = resultNum * (-1);
} else if (operator.equals("=")) {
// 赋值运算
resultNum = getNumberFromText();
}
if (operateValidFlag) {
// 双精度浮点数的运算
long t1;
double t2;
t1 = (long) resultNum;
t2 = resultNum - t1;
if (t2 == 0) {
resultText.setText(String.valueOf(t1));
} else {
resultText.setText(String.valueOf(resultNum));
}
}
// 运算符等于用户按的按钮
operator = key;
firstDigit = true;
operateValidFlag = true;
}

/**
* 从结果文本框中获取数字
*
* @return
*/
private double getNumberFromText() {
double result = 0;
try {
result = Double.valueOf(resultText.getText()).doubleValue();
} catch (NumberFormatException e) {
}
return result;
}

public static void main(String args[]) {
Calculator calculator1 = new Calculator();
calculator1.setVisible(true);
calculator1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

Ⅶ 求java编程，windows的计算器界面，只要出现计算器界面，不要计算器的计算功能代码

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

/**
* 一个计算器，与Windows附件自带计算器的标准版功能、界面相仿。但还不支持键盘操作。
*/
public class Calculator extends JFrame implements ActionListener {
/** 计算器上的键的显示名字 */
private final String[] KEYS = { "7", "8", "9", "/", "sqrt", "4", "5", "6",
"*", "%", "1", "2", "3", "-", "1/x", "0", "+/-", ".", "+", "=" };
/** 计算器上的功能键的显示名字 */
private final String[] COMMAND = { "Backspace", "CE", "C" };
/** 计算器左边的M的显示名字 */
private final String[] M = { " ", "MC", "MR", "MS", "M+" };
/** 计算器上键的按钮 */
private JButton keys[] = new JButton[KEYS.length];
/** 计算器上的功能键的按钮 */
private JButton commands[] = new JButton[COMMAND.length];
/** 计算器左边的M的按钮 */
private JButton m[] = new JButton[M.length];
/** 计算结果文本框 */
private JTextField resultText = new JTextField("0");

// 标志用户按的是否是整个表达式的第一个数字,或者是运算符后的第一个数字
private boolean firstDigit = true;
// 计算的中间结果。
private double resultNum = 0.0;
// 当前运算的运算符
private String operator = "=";
// 操作是否合法
private boolean operateValidFlag = true;

/**
* 构造函数
*/
public Calculator() {
super();
// 初始化计算器
init();
// 设置计算器的背景颜色
this.setBackground(Color.LIGHT_GRAY);
this.setTitle("计算器");
// 在屏幕(500, 300)坐标处显示计算器
this.setLocation(500, 300);
// 不许修改计算器的大小
this.setResizable(false);
// 使计算器中各组件大小合适
this.pack();
}

/**
* 初始化计算器
*/
private void init() {
// 文本框中的内容采用右对齐方式
resultText.setHorizontalAlignment(JTextField.RIGHT);
// 不允许修改结果文本框
resultText.setEditable(false);
// 设置文本框背景颜色为白色
resultText.setBackground(Color.WHITE);

// 初始化计算器上键的按钮，将键放在一个画板内
JPanel calckeysPanel = new JPanel();
// 用网格布局器，4行，5列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
calckeysPanel.setLayout(new GridLayout(4, 5, 3, 3));
for (int i = 0; i < KEYS.length; i++) {
keys[i] = new JButton(KEYS[i]);
calckeysPanel.add(keys[i]);
keys[i].setForeground(Color.blue);
}
// 运算符键用红色标示，其他键用蓝色表示
keys[3].setForeground(Color.red);
keys[8].setForeground(Color.red);
keys[13].setForeground(Color.red);
keys[18].setForeground(Color.red);
keys[19].setForeground(Color.red);

// 初始化功能键，都用红色标示。将功能键放在一个画板内
JPanel commandsPanel = new JPanel();
// 用网格布局器，1行，3列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
commandsPanel.setLayout(new GridLayout(1, 3, 3, 3));
for (int i = 0; i < COMMAND.length; i++) {
commands[i] = new JButton(COMMAND[i]);
commandsPanel.add(commands[i]);
commands[i].setForeground(Color.red);
}

// 初始化M键，用红色标示，将M键放在一个画板内
JPanel calmsPanel = new JPanel();
// 用网格布局管理器，5行，1列的网格，网格之间的水平方向间隔为3个象素，垂直方向间隔为3个象素
calmsPanel.setLayout(new GridLayout(5, 1, 3, 3));
for (int i = 0; i < M.length; i++) {
m[i] = new JButton(M[i]);
calmsPanel.add(m[i]);
m[i].setForeground(Color.red);
}

// 下面进行计算器的整体布局，将calckeys和command画板放在计算器的中部，
// 将文本框放在北部，将calms画板放在计算器的西部。

// 新建一个大的画板，将上面建立的command和calckeys画板放在该画板内
JPanel panel1 = new JPanel();
// 画板采用边界布局管理器，画板里组件之间的水平和垂直方向上间隔都为3象素
panel1.setLayout(new BorderLayout(3, 3));
panel1.add("North", commandsPanel);
panel1.add("Center", calckeysPanel);

// 建立一个画板放文本框
JPanel top = new JPanel();
top.setLayout(new BorderLayout());
top.add("Center", resultText);

// 整体布局
getContentPane().setLayout(new BorderLayout(3, 5));
getContentPane().add("North", top);
getContentPane().add("Center", panel1);
getContentPane().add("West", calmsPanel);
// 为各按钮添加事件侦听器
// 都使用同一个事件侦听器，即本对象。本类的声明中有implements ActionListener
for (int i = 0; i < KEYS.length; i++) {
keys[i].addActionListener(this);
}
for (int i = 0; i < COMMAND.length; i++) {
commands[i].addActionListener(this);
}
for (int i = 0; i < M.length; i++) {
m[i].addActionListener(this);
}
}

/**
* 处理事件
*/
public void actionPerformed(ActionEvent e) {
// 获取事件源的标签
String label = e.getActionCommand();
if (label.equals(COMMAND[0])) {
// 用户按了"Backspace"键
handleBackspace();
} else if (label.equals(COMMAND[1])) {
// 用户按了"CE"键
resultText.setText("0");
} else if (label.equals(COMMAND[2])) {
// 用户按了"C"键
handleC();
} else if ("0123456789.".indexOf(label) >= 0) {
// 用户按了数字键或者小数点键
handleNumber(label);
// handlezero(zero);
} else {
// 用户按了运算符键
handleOperator(label);
}
}

/**
* 处理Backspace键被按下的事件
*/
private void handleBackspace() {
String text = resultText.getText();
int i = text.length();
if (i > 0) {
// 退格，将文本最后一个字符去掉
text = text.substring(0, i - 1);
if (text.length() == 0) {
// 如果文本没有了内容，则初始化计算器的各种值
resultText.setText("0");
firstDigit = true;
operator = "=";
} else {
// 显示新的文本
resultText.setText(text);
}
}
}

/**
* 处理数字键被按下的事件
*
* @param key
*/
private void handleNumber(String key) {
if (firstDigit) {
// 输入的第一个数字
resultText.setText(key);
} else if ((key.equals(".")) && (resultText.getText().indexOf(".") < 0)) {
// 输入的是小数点，并且之前没有小数点，则将小数点附在结果文本框的后面
resultText.setText(resultText.getText() + ".");
} else if (!key.equals(".")) {
// 如果输入的不是小数点，则将数字附在结果文本框的后面
resultText.setText(resultText.getText() + key);
}
// 以后输入的肯定不是第一个数字了
firstDigit = false;
}

/**
* 处理C键被按下的事件
*/
private void handleC() {
// 初始化计算器的各种值
resultText.setText("0");
firstDigit = true;
operator = "=";
}

/**
* 处理运算符键被按下的事件
*
* @param key
*/
private void handleOperator(String key) {
if (operator.equals("/")) {
// 除法运算
// 如果当前结果文本框中的值等于0
if (getNumberFromText() == 0.0) {
// 操作不合法
operateValidFlag = false;
resultText.setText("除数不能为零");
} else {
resultNum /= getNumberFromText();
}
} else if (operator.equals("1/x")) {
// 倒数运算
if (resultNum == 0.0) {
// 操作不合法
operateValidFlag = false;
resultText.setText("零没有倒数");
} else {
resultNum = 1 / resultNum;
}
} else if (operator.equals("+")) {
// 加法运算
resultNum += getNumberFromText();
} else if (operator.equals("-")) {
// 减法运算
resultNum -= getNumberFromText();
} else if (operator.equals("*")) {
// 乘法运算
resultNum *= getNumberFromText();
} else if (operator.equals("sqrt")) {
// 平方根运算
resultNum = Math.sqrt(resultNum);
} else if (operator.equals("%")) {
// 百分号运算，除以100
resultNum = resultNum / 100;
} else if (operator.equals("+/-")) {
// 正数负数运算
resultNum = resultNum * (-1);
} else if (operator.equals("=")) {
// 赋值运算
resultNum = getNumberFromText();
}
if (operateValidFlag) {
// 双精度浮点数的运算
long t1;
double t2;
t1 = (long) resultNum;
t2 = resultNum - t1;
if (t2 == 0) {
resultText.setText(String.valueOf(t1));
} else {
resultText.setText(String.valueOf(resultNum));
}
}
// 运算符等于用户按的按钮
operator = key;
firstDigit = true;
operateValidFlag = true;
}

/**
* 从结果文本框中获取数字
*
* @return
*/
private double getNumberFromText() {
double result = 0;
try {
result = Double.valueOf(resultText.getText()).doubleValue();
} catch (NumberFormatException e) {
}
return result;
}

public static void main(String args[]) {
Calculator calculator1 = new Calculator();
calculator1.setVisible(true);
calculator1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

阅读全文

java计算器的界面

与java计算器的界面相关的阅读推荐