java加法运算

㈠ 怎么用java编程，实现分数的加减乘除运算

1、打开eclipse，创建一个Java工程，在此工程里新建一个类；

2、在新建的类中，添加4个运算类；

3、在主方法中调用对应的方法即可完成分数的加减乘除运算了。

具体实现代码如下：

public class Demo {

public static void main(String[] args) {

System.out.println(jia(1, 2));

System.out.println(jian(1, 2));

System.out.println(cheng(1, 2));

System.out.println(chu(1, 2));

}

//加法运算

private static float jia(float x,float y) {

return x + y;

}

//减法运算

private static float jian(float x,float y) {

return x - y;

}

//乘法运算

private static float cheng(float x,float y) {

return x * y;

}

//除法运算

private static float chu(float x,float y) {

return x / y;

}

}

㈡ java里的加法运算符问题

首先helloworld类中是定义了全局变量 i=33 ；j=44，以及c1='a' ;c2='b'

然后在主函数里定义了一个对象hw是new 了一个helloworld类的对象，

然后通过“hw.”的形式调用了helloworld中定义的i;j;c1;c2

n相当于 i+j；

因为c是定义为int型的，而c1,c2是char类型的，所以c相当于‘a’与‘b’的ASCII码相加计算……

通过断点清楚的看到其值的计算情况。

呃，大概就是这个样子。

㈢ 在java中，+什么时候是连接符，什么时候是加法

跟字符串做拼接的时候是连接符，数值类型运算的时候是加号。

需要注意string中连续的数字要整合成一个数字，加上括号的时候运算顺序要小心，特别注意括号前有计算数字，比如5+（2+5）。

括号后面有乘除法运算，比如5+（2+5）/2 括号算完了要继续算后面的除法，之后用得到的数字加上前面的加号运算符和‘5’一起运算。

(3)java加法运算扩展阅读

二元加法运算符“+”在两个操作数都是数字或都是字符串时，计算结果是显而易见的。加号“+”的转换规则优先考虑字符串连接，如果其中一个操作数是字符串或者转换为字符串的对象，另外一个操作数会转换为字符串，加号讲践行字符串的连接操作。

如果两个操作数都不是类字符串（string-like)的，那么都讲进行算数加法运算。

“+”操作符的行为表现为：

如果其中一个操作数是对象，则对象会遵循对象到原始值的转换规则转换为原始类值：日期对象通过toString()方法执行转换，其他对象则通过valueOf()方法执行转换（如果valueOf()方法返回一个原始值的话）。

由于多数对象都不具备可用的valueOf()方法，因此它们会通过toString()方法来执行转换。

㈣ java加减乘除是什么类

java中实现加减乘除的类是java.math.BigDecimal类. BigDecimal 类提供以下操作：算术、标度操作、舍入、比较、哈希算法和格式转换。

加法运算：调用BigDecimal类的add方法即可

BigDecimalb1=newBigDecimal("1");
BigDecimalb2=newBigDecimal("2");
BigDecimalresult=b1.add(b2);//加法
System.out.println(result);

减法运算：调用BigDecimal类的subtract方法即可

BigDecimalb1=newBigDecimal(3.2);
BigDecimalb2=newBigDecimal(1.6);
BigDecimalresult=b1.subtract(b2);//减法
System.out.println(result);

乘法运算：调用BigDecimal类的multiply方法即可

BigDecimalb1=newBigDecimal(9);
BigDecimalb2=newBigDecimal(8.2);
BigDecimalresult=b1.multiply(b2);//乘法
System.out.println(result);

除法运算：调用BigDecimal类的divide方法即可。

注意: 除法运算存在除不尽的情况,比如1.0/3=0.333333.. 我们需要指定小数点后面的长度,以及有效的舍入模式(例如四舍五入模式).

BigDecimalb1=newBigDecimal("1");
BigDecimalb2=newBigDecimal("3");
intscale=5;//scale指定小数点后面的位数为5位
doubleresult=b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();//除法
//BigDecimal.ROUND_HALF_UP表示四舍五入
System.out.println(result);

备注：

1：BigDecimal的构造参数有很多，但浮点类型建议转换成字符串类型, 避免精度的丢失.

doubled1=0.001;//浮点类型
Strings1=Double.toString(d1);//转成字符串
BigDecimalb1=newBigDecimal(s1);//使用字符串作为构造参数

2：BigDecimal类, 内存占用比基本类型多,并且为了计算的精度,速度比double慢一点.所以,只有在需要精确计算的情况下,才使用BigDecimal类进行. 普通运算,还是多使用+-*/运算符,位运算符等.

㈤ java的加减乘除运算

使用BigDecimal并且一定要用String来够造。
实现方法如下：

import java.math.BigDecimal;

/**

* 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精

* 确的浮点数运算，包括加减乘除和四舍五入。

*/

public class Arith{

//默认除法运算精度

private static final int DEF_DIV_SCALE = 10;

//这个类不能实例化

private Arith(){

}

/**

* 提供精确的加法运算。

* @param v1 被加数

* @param v2 加数

* @return 两个参数的和

*/

public static double add(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.add(b2).doubleValue();

}

/**

* 提供精确的减法运算。

* @param v1 被减数

* @param v2 减数

* @return 两个参数的差

*/

public static double sub(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.subtract(b2).doubleValue();

}

/**

* 提供精确的乘法运算。

* @param v1 被乘数

* @param v2 乘数

* @return 两个参数的积

*/

public static double mul(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.multiply(b2).doubleValue();

}

/**

* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到

* 小数点以后10位，以后的数字四舍五入。

* @param v1 被除数

* @param v2 除数

* @return 两个参数的商

*/

public static double div(double v1,double v2){

return div(v1,v2,DEF_DIV_SCALE);

}

/**

* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指

* 定精度，以后的数字四舍五入。

* @param v1 被除数

* @param v2 除数

* @param scale 表示表示需要精确到小数点以后几位。

* @return 两个参数的商

*/

public static double div(double v1,double v2,int scale){

if(scale<0){

throw new IllegalArgumentException(

"The scale must be a positive integer or zero");

}

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

}

/**

* 提供精确的小数位四舍五入处理。

* @param v 需要四舍五入的数字

* @param scale 小数点后保留几位

* @return 四舍五入后的结果

*/

public static double round(double v,int scale){

if(scale<0){

throw new IllegalArgumentException(

"The scale must be a positive integer or zero");

}

BigDecimal b = new BigDecimal(Double.toString(v));

BigDecimal one = new BigDecimal("1");

return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

}

};

㈥ Java 加法计算问题

importjava.awt.*;
importjava.awt.event.*;
publicclassTest{
publicstaticvoidmain(String[]arga){
newMyFrame1().LaunchFrame();
}
}
classMyFrame1extendsFrame{
publicTextFieldt1,t2,t3;
publicvoidLaunchFrame(){
t1=newTextField(10);
t2=newTextField(10);
t3=newTextField(15);
Labellb=newLabel("+");
Buttonb=newButton("=");
MyMonitormt=newMyMonitor(this);
b.addActionListener(mt);
setLayout(newFlowLayout());
add(t1);
add(lb);
add(t2);
add(b);
add(t3);
pack();
setVisible(true);
}
}
{
privateMyFrame1mf=newMyFrame1();
publicMyMonitor(MyFrame1mf){
this.mf=mf;
}
publicvoidactionPerformed(ActionEvente){
intm1=Integer.parseInt(mf.t1.getText());
intm2=Integer.parseInt(mf.t2.getText());
intm3=m1+m2;
mf.t3.setText(""+(m3));
}
}

我修改了一下你的代码，看看能不能发现问题。

㈦ 用JAVA编写一个实现加法运算的程序

public class Plus {
public static void main(String[] args) {
String fristParam = args[0];
String secondParam = args[1];

String result = plus(fristParam, secondParam);

System.out.println(result);
}

private static String plus(String _sFristParam, String _sSecondParam) {
String sResult = null;
if (isVirtual(_sFristParam) || isVirtual(_sSecondParam)) {
sResult = virualPlus(_sFristParam, _sSecondParam);
}
else {
sResult = normalPlus(_sFristParam, _sSecondParam);
}
return sResult;
}

private static String normalPlus(String _sFristParam, String _sSecondParam) {
if (_sFristParam == null || _sSecondParam == null) {
return "对不起输入有错，请重新输入";
}

int nFristParam = Integer.parseInt(_sFristParam);
int nSecondParam = Integer.parseInt(_sSecondParam);
int nResult = nFristParam + nSecondParam;
String sResult = String.valueOf(nResult);

return sResult;
}

private static String virualPlus(String _sFristParam, String _sSecondParam) {
String sFirstActual = getActual(_sFristParam);
String sFirstVirtual = getVirtual(_sFristParam);

String sSecondActual = getActual(_sSecondParam);
String sSecondVirtual = getVirtual(_sSecondParam);

String sResult = null;

int nFirstActual = 0;
int nFirstVirtual = 0;
int nSecondActual = 0;
int nSecondVirtual = 0;

int nVirtual = 0;
int nActual = 0;

if (sFirstActual == null || sFirstVirtual == null || sSecondActual == null ||

sSecondVirtual == null) {
return "对不起输入的虚数有错，请重新输入";
}

nFirstActual = Integer.parseInt(sFirstActual);
nFirstVirtual = Integer.parseInt(sFirstVirtual);
nSecondActual = Integer.parseInt(sSecondActual);
nSecondVirtual = Integer.parseInt(sSecondVirtual);

nVirtual = nFirstVirtual + nSecondVirtual;
nActual = nFirstActual + nSecondActual;

String sVirtual = String.valueOf(nVirtual);
String sActual = String.valueOf(nActual);

sResult = sActual + "+" + sVirtual + "i";
return sResult;
}

private static String getVirtual(String _sParam) {
String[] members = _sParam.split("\\+");
String sResult = (members[1] != null) ? members[1].substring(0, 1) : null;
return sResult;
}

private static String getActual(String _sParam) {
String[] members = _sParam.split("\\+");
String sResult = (members[0] != null) ? members[0] : null;
return sResult;
}

private static boolean isVirtual(String _sParam) {
return (_sParam.indexOf("i") != -1) ? true : false;
}
}

自己改一下吧，基本上没问题

㈧ 用 Java 写一个两个整数相加的程序

代码如下：

public class Test {

public static int add(int a,int b){

return a+b;

}

public static void main(String args[]){

Scanner scanner = new Scanner(System.in);

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

int a = scanner.nextInt();

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

int b = scanner.nextInt();

System.out.println("和为:"+add(a,b));

}

}

(8)java加法运算扩展阅读

运算符

运算符是一些特殊的符号，主要用于数学函数、一些类型的赋值语句和逻辑比较方面。

1、赋值运算符

赋值运算符以符号“=”表示，它是一个二元运算符（对两个操作数作处理），其功能是将右方操作数所含的值赋给左方的操作数。

例如：

1 int a = 100;

2、算术运算符

运算符说明 ：

“+” 加 ；“-” 减 ；“*” 乘 ； “/”除 ； “%” 取余数

3、自增和自减运算符

自增和自减是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整型或浮点型变量。自增、自减运算符的作用是使变量的值增1或减1。放在操作元前面的自增、自减运算符，会先将变量的值加1或减1，然后再使该变量参与表达式的运算。放在操作元后面的自增、自减运算符，会先使变量参与表达式的运算，然后再将该变量的值加1或减1。

例如：

假设a=5

1 b=++a;//先将a的值加1，然后赋值给b，此时a的值为6，b的值为6

2 b=a++;//先将a的值赋值给b，再将a的值变为6，此时a的值为6，b的值为5

4、比较运算符

比较运算符属于二元运算符，用于程序中的变量之间，变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运算的结果为true，否则为false。比较运算符共有6个，通常作为判断的依据用于条件语句中。

运算符说明：

">"比较左方是否大于右方

"<"比较左方是否小于右方

"=="比较左方是否等于右方

"> = "比较左方是否大于等于右方

"<= "比较左方是否小于等于右方

"！= "比较左方是否不等于右方

参考链接：Java（计算机编程语言）_网络

㈨ java 的加法运算,用代码实现。

int a = 1；
int b =1;
int sum = a+b;
System.out.println(sum);

㈩ java里加法运算符里的一些问题，求解

第一张图里，示例代码3-1编写了一个Java类，叫做HelloWord。
如果说java面向对象，那么这个HelloWord就一个对象类型，就好比说HelloWord=玉米，玉米也是一种对象类型。

第二张图里，创建了一个对象hw，其实也就是定义了一个变量hw。你就把hw当作一个变量看就能理解了。那么这个hw是什么类型的呢？是整数类型还是字符串类型？都不是，它是自定义类型（HelloWord这种类型）。

HelloWorld hw=new HelloWorld（）;//这行代码的意思，就是告诉虚拟机做以下事情：
1、帮我在内存里创建一个名称叫做hw的变量；
2、同时给这个变量定义类型为：HelloWord。
3、创建方法为：通过 new HelloWord()这种途径来创建。
提示：名字hw取自helloword的每个单词的首字母。