java乘于用什么？java加减乘除是什么类

大家好，java乘于用什么相信很多的网友都不是很明白，包括java加减乘除是什么类也是一样，不过没有关系，接下来就来为大家分享关于java乘于用什么和java加减乘除是什么类的一些知识点，大家可以关注收藏，免得下次来找不到哦，下面我们开始吧！

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语言表达乘方

public static double pow(double a,

double b)返回第一个参数的第二个参数次幂的值。特殊情况是：

如果第二个参数是正零或负零，那么结果是 1.0。

如果第二个参数是 1.0，那么结果与第一个参数相同。

如果第二个参数是 NaN，那么结果是 NaN。

如果第一个参数是 NaN，第二个参数是非零，那么结果是 NaN。

如果

第一个参数的绝对值大于 1，并且第二个参数是正无穷大，或者

第一个参数的绝对值小于 1，并且第二个参数是负无穷大，

那么结果是正无穷大。

如果

第一个参数的绝对值大于 1，并且第二个参数是负无穷大，或者

第一个参数的绝对值小于 1，并且第二个参数是正无穷大，

那么结果是正零。

如果第一个参数的绝对值等于1，并且第二个参数是无穷大，那么结果是 NaN。

如果

第一个参数是正零，并且第二个参数大于零，或者

第一个参数是正无穷大，并且第二个参数小于零，

那么结果是正零。

如果

第一个参数是正零，并且第二个参数小于零，或者

第一个参数是正无穷大，并且第二个参数大于零，

那么结果是正无穷大。

如果

如果第一个参数是负零，并且第二个参数大于零但不是有限的奇数整数，或者

第一个参数是负无穷大，并且第二个参数小于零但不是有限的奇数整数，

那么结果是正零。

如果

第一个参数是负零，并且第二个参数是正的有限奇数整数，或者

第一个参数是负无穷大，并且第二个参数是负的有限奇数整数，

那么结果是负零。

如果

如果第一个参数是负零，并且第二个参数小于零但不是有限的奇数整数，或者

第一个参数是负无穷大，并且第二个参数大于零但不是有限的奇数整数，

那么结果是正无穷大。

如果

第一个参数是负零，并且第二个参数是负的有限奇数整数，或者

第一个参数是负无穷大，并且第二个参数是正的有限奇数整数，

那么结果是负无穷大。

如果第一个参数是小于零的有限值，

并且第二个参数是有限的偶数整数，那么结果等于第一个参数的绝对值的第二个参数次幂的结果。

如果第二个参数是有限的奇数整数，那么结果等于第一个参数绝对值的第二个参数次幂的结果的负数。

如果第二个参数是有限的非整数值，那么结果是 NaN。

如果两个参数都是整数，并且结果可以表示为 double值，那么该结果恰好等于第一个参数的第二个参数次幂的算术结果。

（在前面的描述中，当且仅当浮点数为有限值并且是方法 ceil的定点数，或者是方法 floor的定点数时，才可以认为浮点值是整数。当且仅当将方法应用到该值的结果等于该值时，该值才是带有一个参数的某个方法的定点值。）

计算结果必须在准确结果的 1 ulp范围内。结果必须具有半单调性。

java中的位运算子及其用法。

java中的位运算子及其用法。

位逻辑运算子有“与”（AND）、“或”（OR）、“异或（XOR）”、“非（NOT）”，分别用“&”、“|”、“^”、“~”表示。

下面的例子说明了位逻辑运算子：

Demonstrate the biise logical operators.

class BitLogic{

public static void main(String args[]){

String binary[]={

"0000","0001","0010","0011","0100","0101","0110","0111",

"1000","1001","1010","1011","1100","1101","1110","1111"

};

int a= 3; 0+ 2+ 1 or 0011 in binary

int b= 6; 4+ 2+ 0 or 0110 in binary

int c= a| b;

int d= a& b;

int e= a ^ b;

int f=(~a& b)|(a&~b);

int g=~a& 0x0f;

System.out.println(" a="+ binary[a]);

System.out.println(" b="+ binary[b]);

System.out.println(" a|b="+ binary[c]);

System.out.println(" a&b="+ binary[d]);

System.out.println(" a^b="+ binary[e]);

System.out.println("~a&b|a&~b="+ binary[f]);

System.out.println("~a="+ binary[g]);

}

}

在本例中，变数a与b对应位的组合代表了二进位制数所有的 4种组合模式：0-0，0-1，1-0，和1-1。“|”运算子和“&”运算子分别对变数a与b各个对应位的运算得到了变数c和变数d的值。对变数e和f的赋值说明了“^”运算子的功能。字串阵列binary代表了0到15对应的二进位制的值。在本例中，阵列各元素的排列顺序显示了变数对应值的二进位制程式码。阵列之所以这样构造是因为变数的值n对应的二进位制程式码可以被正确的储存在阵列对应元素binary[n]中。例如变数a的值为3，则它的二进位制程式码对应地储存在阵列元素binary[3]中。~a的值与数字0x0f（对应二进位制为0000 1111）进行按位与运算的目的是减小~a的值，保证变数g的结果小于16。因此该程式的执行结果可以用阵列binary对应的元素来表示。该程式的输出如下：

a= 0011

b= 0110

a|b= 0111

a&b= 0010

a^b= 0101

~a&b|a&~b= 0101

~a= 1100

左移运算子

左移运算子<<使指定值的所有位都左移规定的次数。它的通用格式如下所示：

value<< num

这里，num指定要移位值value移动的位数。也就是，左移运算子<<使指定值的所有位都左移num位。每左移一个位，高阶位都被移出（并且丢弃），并用0填充右边。这意味着当左移的运算数是int型别时，每移动1位它的第31位就要被移出并且丢弃；当左移的运算数是long型别时，每移动1位它的第63位就要被移出并且丢弃。

在对byte和short型别的值进行移位运算时，你必须小心。因为你知道Java在对表达式求值时，将自动把这些型别扩大为 int型，而且，表示式的值也是int型。对byte和short型别的值进行移位运算的结果是int型，而且如果左移不超过31位，原来对应各位的值也不会丢弃。但是，如果你对一个负的byte或者short型别的值进行移位运算，它被扩大为int型后，它的符号也被扩充套件。这样，整数值结果的高位就会被1填充。因此，为了得到正确的结果，你就要舍弃得到结果的高位。这样做的最简单办法是将结果转换为byte型。下面的程式说明了这一点：

Left shifting a byte value.

class ByteShift{

public static void main(String args[]){

byte a= 64, b;

int i;

i= a<< 2;

b=(byte)(a<< 2);

System.out.println("Original value of a:"+ a);

System.out.println("i and b:"+ i+""+ b);

}

}

该程式产生的输出下所示：

Original value of a: 64

i and b: 256 0

因变数a在赋值表示式中，故被扩大为int型，64（0100 0000）被左移两次生成值256（10000 0000）被赋给变数i。然而，经过左移后，变数b中惟一的1被移出，低位全部成了0，因此b的值也变成了0。

既然每次左移都可以使原来的运算元翻倍，程式设计师们经常使用这个办法来进行快速的2的乘法。但是你要小心，如果你将1移进高阶位（31或63位），那么该值将变为负值。下面的程式说明了这一点：

Left shifting as a quick way to multiply by 2.

class MultByTwo{

public static void main(String args[]){

int i;

int num= 0xFFFFFFE;

for(i=0; i<4; i++){

num= num<< 1;

System.out.println(num);

}

}

}

该程式的输出如下所示：

536870908

1073741816

2147483632

-32

初值经过仔细选择，以便在左移 4位后，它会产生-32。正如你看到的，当1被移进31位时，数字被解释为负值。

右移运算子

右移运算子>>使指定值的所有位都右移规定的次数。它的通用格式如下所示：

value>> num

这里，num指定要移位值value移动的位数。也就是，右移运算子>>使指定值的所有位都右移num位。

下面的程式片段将值32右移2次，将结果8赋给变数a:

int a= 32;

a= a>> 2; a now contains 8

当值中的某些位被“移出”时，这些位的值将丢弃。例如，下面的程式片段将35右移2次，它的2个低位被移出丢弃，也将结果8赋给变数a:

int a= 35;

a= a>> 2; a still contains 8

用二进位制表示该过程可以更清楚地看到程式的执行过程：

00100011 35

>> 2

00001000 8

将值每右移一次，就相当于将该值除以2并且舍弃了余数。你可以利用这个特点将一个整数进行快速的2的除法。当然，你一定要确保你不会将该数原有的任何一位移出。

右移时，被移走的最高位（最左边的位）由原来最高位的数字补充。例如，如果要移走的值为负数，每一次右移都在左边补1，如果要移走的值为正数，每一次右移都在左边补0，这叫做符号位扩充套件（保留符号位）（sign extension），在进行右移操作时用来保持负数的符号。例如，–8>> 1是–4，用二进位制表示如下：

11111000–8

>>1

11111100–4

一个要注意的有趣问题是，由于符号位扩充套件（保留符号位）每次都会在高位补1，因此-1右移的结果总是–1。有时你不希望在右移时保留符号。例如，下面的例子将一个byte型的值转换为用十六进位制表示。注意右移后的值与0x0f进行按位与运算，这样可以舍弃任何的符号位扩充套件，以便得到的值可以作为定义阵列的下标，从而得到对应阵列元素代表的十六进位制字元。

Masking sign extension.

class HexByte{

static public void main(String args[]){

char hex[]={

'0','1','2','3','4','5','6','7',

'8','9','a','b','c','d','e','f''

};

byte b=(byte) 0xf1;

System.out.println("b= 0x"+ hex[(b>> 4)& 0x0f]+ hex[b& 0x0f]);

}

}

该程式的输出如下：

b= 0xf1

无符号右移

正如上面刚刚看到的，每一次右移，>>运算子总是自动地用它的先前最高位的内容补它的最高位。这样做保留了原值的符号。但有时这并不是我们想要的。例如，如果你进行移位操作的运算数不是数字值，你就不希望进行符号位扩充套件（保留符号位）。当你处理画素值或图形时，这种情况是相当普遍的。在这种情况下，不管运算数的初值是什么，你希望移位后总是在高位（最左边）补0。这就是人们所说的无符号移动（unsigned shift）。这时你可以使用Java的无符号右移运算子>>>，它总是在左边补0。下面的程式段说明了无符号右移运算子>>>。在本例中，变数a被赋值为-1，用二进位制表示就是32位全是1。这个值然后被无符号右移24位，当然它忽略了符号位扩充套件，在它的左边总是补0。这样得到的值255被赋给变数a。

int a=-1;

a= a>>> 24;

下面用二进位制形式进一步说明该操作：

11111111 11111111 11111111 11111111 int型- 1的二进位制程式码

>>> 24无符号右移24位

00000000 00000000 00000000 11111111 int型255的二进位制程式码由于无符号右移运算子>>>只是对32位和64位的值有意义，所以它并不像你想象的那样有用。因为你要记住，在表示式中过小的值总是被自动扩大为int型。这意味着符号位扩充套件和移动总是发生在32位而不是8位或16位。这样，对第7位以0开始的byte型的值进行无符号移动是不可能的，因为在实际移动运算时，是对扩大后的32位值进行操作。下面的例子说明了这一点：

Unsigned shifting a byte value.

class ByteUShift{

static public void main(String args[]){

char hex[]={

'0','1','2','3','4','5','6','7',

'8','9','a','b','c','d','e','f'

};

byte b=(byte) 0xf1;

byte c=(byte)(b>> 4);

byte d=(byte)(b>>> 4);

byte e=(byte)((b& 0xff)>> 4);

System.out.println(" b= 0x"

+ hex[(b>> 4)& 0x0f]+ hex[b& 0x0f]);

System.out.println(" b>> 4= 0x"

+ hex[(c>> 4)& 0x0f]+ hex[c& 0x0f]);

System.out.println(" b>>> 4= 0x"

+ hex[(d>> 4)& 0x0f]+ hex[d& 0x0f]);

System.out.println("( b& 0xff)>> 4= 0x"

+ hex[(e>> 4)& 0x0f]+ hex[e& 0x0f]);

}

}

该程式的输出显示了无符号右移运算子>>>对byte型值处理时，实际上不是对byte型值直接操作，而是将其扩大到int型后再处理。在本例中变数b被赋为任意的负byte型值。对变数b右移4位后转换为byte型，将得到的值赋给变数c，因为有符号位扩充套件，所以该值为0xff。对变数b进行无符号右移4位操作后转换为byte型，将得到的值赋给变数d，你可能期望该值是0x0f，但实际上它是0xff，因为在移动之前变数b就被扩充套件为int型，已经有符号扩充套件位。最后一个表示式将变数b的值通过按位与运算将其变为8位，然后右移4位，然后将得到的值赋给变数e，这次得到了预想的结果0x0f。由于对变数d（它的值已经是0xff）进行按位与运算后的符号位的状态已经明了，所以注意，对变数d再没有进行无符号右移运算。

B= 0xf1

b>> 4= 0xff

b>>> 4= 0xff

(b& 0xff)>> 4= 0x0f

位运算子赋值

所有的二进位制位运算子都有一种将赋值与位运算组合在一起的简写形式。例如，下面两个语句都是将变数a右移4位后赋给a：

a= a>> 4;

a>>= 4;

同样，下面两个语句都是将表示式a OR b运算后的结果赋给a：

a= a| b;

a|= b;

下面的程式定义了几个int型变数，然后运用位赋值简写的形式将运算后的值赋给相应的变数：

class OpBitEquals{

public static void main(String args[]){

int a= 1;

int b= 2;

int c= 3;

a|= 4;

b>>= 1;

c<<= 1;

a ^= c;

System.out.println("a="+ a);

System.out.println("b="+ b);

System.out.println("c="+ c);

}

}

该程式的输出如下所示：

a= 3

b= 1

c= 6

与

0&&0=0

1&&0=0

0&&1=0

1&&1=1

或

0||0=0

1||0=1

0||1=1

1||1=1

异或是

1^0=1

0^1=1

0^0=0

1^1=0

例子

11001010与

00011011

按位与按位或按位异或

00001010 11011011 11010001

位运算子用来对二进位制位进行操作,位运算符(＞＞,＜＜,＞＞＞,&,|,^,～),位运算符中,除～以外,其余均为二元运算符。操作数只能为整型和字符型数据。

比如‘>>’这个就相当于乘以2.

C++位运算子有以下两类：

1位逻辑运算子：&（位“与”）、^（位“异或”）、|（位“或”）和~（位“取反”）

2移位运算子：<<（左移）和>>(右移).

位“与”、位“或”和位“异或”运算子都是双目运算子，其结合性都是从左向右的，优先顺序高于逻辑运算子，低于比较运算子，且从高到低依次为&、^、|

这个是C++中的基础，你可以看看人家的部落格。

:m.blog.csdn./article/details?id=52196039

运算子那多了去了

算术运算子+-*/%分别是加减乘除求余

在这里要特别注意有个晋升现象.是指低于int的三种类型(byte short char)进行算术运算后会自动提升成int型别列如

byte a=20;

byte b=30;

byte c=a+b;这就错了应该写成byte c=(byte)(a+b);或者 int c=a+b;

比较运算子

即<,>,<=,>=,==,!=分别是小于,大于,小于等于,大于等于,不等于

它的结果是一个Boolean型别

逻辑运算子

或(||)与(&&)非(!) or and not

赋值运算子

最简单的是"="用来为常量或者变数指定值注意不能为运算式赋值

还有其他赋值运算子如下

+=加等把变数加上右侧的值然后再赋值给自身

-=减等把变数减去右侧的值然后再赋值给自身

*=乘等把变数乘以右侧的值然后再赋值给自身

/=除等把变数除以右侧的值然后再赋值给自身

%=取余等把变数和右侧的值取余然后再赋值给自身

还有二进位制运算子

位运算子

移位运算子....

++递增

--递减

条件?值1:值2条件运算子

算数运算子，+-*/(+=，-=，*=，、/*) p.s. 1/0=> NaN无穷大。逻辑运算子，略转义序列符（例举），\b退格, \t制表, \n换行（制图、一般println）, \r回车, \"双引号, \'单引号p.s.取决于os，并不常用。递增/减++,--赋值=比较>=，<=,==位移<<，>>,>>>p.s.图形用到注释，行注释，/**/段注释型别转换， a=(int)b;括号。条件， if()...== a? true: false三目运算。正则表示式，应用类，用到这再说。

LZ是学Java的新手吧。嗯，慢慢学

Java的运算子可分为4类：算术运算子、关系运算符、逻辑运算子和位运算子。

1.算术运算子

Java的算术运算子分为一元运算子和二元运算子。一元运算子只有一个运算元；二元运算子有两个运算元，运算子位于两个运算元之间。算术运算子的运算元必须是数值型别。

(1)一元运算子：

一元运算子有：正（+）、负（－）、加1（++）和减1（－－）4个。

加1、减1运算子只允许用于数值型别的变数，不允许用于表示式中。加1、减1运算子既可放在变数之前（如＋＋i），也可放在变数之后（如i＋＋），两者的差别是：如果放在变数之前（如＋＋i），则变数值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变数之后（如i＋＋），则先进行其他相应的操作，然后再进行变数值加1或减1。

例如：

int i=6，j，k，m，n;

j=+i;取原值，即j=6

k=-i;取负值，即k=-6

m= i++;先m=i,再i=i+1，即m=6，i=7

m=++i;先i=i+1,再m=i，即i=7，m=7

n= j--;先n=j,再j=j-1，即n=6，j=5

n=--j;先j=j-1,再n=j，即j=5，n=5

在书写时还要注意的是：一元运算子与其前后的运算元之间不允许有空格，否则编译时会出错。

(2)二元运算子

二元运算子有：加（+）、减（－）、乘（*）、除（／）、取余（%）。其中+、－、*、／完成加、减、乘、除四则运算，%是求两个运算元相除后的余数。

%求余操作举例：

a% b= a－(a/ b)* b

取余运算子既可用于两个运算元都是整数的情况，也可用于两个运算元都是浮点数（或一个运算元是浮点数）的情况。当两个运算元都是浮点数时，例如7.6% 2.9时，计算结果为：7.6－ 2* 2.9= 1.8。

当两个运算元都是int型别数时，a%b的计算公式为：

a% b= a－（int）(a/ b)* b

当两个运算元都是long型别（或其他整数型别）数时，a%b的计算公式可以类推。

当参加二元运算的两个运算元的资料型别不同时，所得结果的资料型别与精度较高（或位数更长）的那种资料型别一致。

例如：

7/ 3整除，运算结果为2

7.0/ 3除法，运算结果为2.33333,即结果与精度较高的型别一致

7% 3取余，运算结果为1

7.0% 3取余，运算结果为1.0

-7% 3取余，运算结果为-1，即运算结果的符号与左运算元相同

7%-3取余，运算结果为1，即运算结果的符号与左运算元相同

2.关系运算符

关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑型别的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、小于等于（<=）。

例如：

9<= 8运算结果为false

9.9>= 8.8运算结果为true

'A'<'a'运算结果为true，因字元'A'的Unicode编码值小于字元'a'的

要说明的是，对于大于等于（或小于等于）关系运算符来说，只有大于和等于两种关系运算都不成立时其结果值才为false，只要有一种（大于或等于）关系运算成立其结果值即为true。例如，对于9<= 8，9既不小于8也不等于8，所以9<= 8的运算结果为false。对于9>= 9，因9等于9，所以9>= 9的运算结果为true。

3.逻辑运算子

逻辑运算子要求运算元的资料型别为逻辑型，其运算结果也是逻辑型值。逻辑运算子有：逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑异或（^）、逻辑与（&）、逻辑或（|）。

真值表是表示逻辑运算功能的一种直观方法，其具体方法是把逻辑运算的所有可能值用表格形式全部罗列出来。Java语言逻辑运算子的真值表如下：

逻辑运算子的真值表

A B A&&B A||B!A A^B A&B A|B

false false false false true false false false

true false false true false true false true

false true false true true true false true

true true true true false false true true

前两列是参与逻辑运算的两个逻辑变数，共有4种可能，所以表2.5共有4行。后6列分别是6个逻辑运算子在逻辑变数A和逻辑变数B取不同数值时的运算结果值。

要说明的是，两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和|运算是把逻辑表示式全部计算完，而&&和||运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表示式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。对于&&运算来说，只要运算子左端的值为false，则因无论运算子右端的值为true或为false，其最终结果都为false。所以，系统一旦判断出&&运算子左端的值为false，则系统将终止其后的计算过程；对于||运算来说，只要运算子左端的值为true，则因无论运算子右端的值为true或为false，其最终结果都为true。所以，系统一旦判断出||运算子左端的值为true，则系统将终止其后的计算过程。

例如，有如下逻辑表示式：

(i>=1)&&(i<=100)

此时，若i等于0，则系统判断出i>=1的计算结果为false后，系统马上得出该逻辑表示式的最终计算结果为false，因此，系统不继续判断i<=100的值。短路计算功能可以提高程式的执行速度。

作者建议读者：在程式设计时使用&&和||运算子，不使用&和|运算子。

用逻辑与（&&）、逻辑或（||）和逻辑非（!）可以组合出各种可能的逻辑表示式。逻辑表示式主要用在 if、while等语句的条件组合上。

例如：

int i= 1;

while(i>=1)&&(i<=100) i++;回圈过程

上述程式段的回圈过程将i++语句回圈执行100次。

4.位运算子

位运算是以二进位制位为单位进行的运算，其运算元和运算结果都是整型值。

位运算子共有7个，分别是：位与（&）、位或（|）、位非（~）、位异或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。

位运算的位与（&）、位或（|）、位非（~）、位异或（^）与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的运算元和运算结果都是二进位制整数，而逻辑运算相应操作的运算元和运算结果都是逻辑值。

位运算示例

运算子名称示例说明

&位与 x&y把x和y按位求与

|位或 x|y把x和y按位求或

~位非~x把x按位求非

^位异或 x^y把x和y按位求异或

>>右移 x>>y把x的各位右移y位

<<左移 x<<y把x的各位左移y位

>>>右移 x>>>y把x的各位右移y位，左边填0

举例说明：

（1）有如下程式段：

int x= 64; x等于二进位制数的01000000

int y= 70; y等于二进位制数的01000110

int z= x&y z等于二进位制数的01000000

即运算结果为z等于二进位制数01000000。位或、位非、位异或的运算方法类同。

（2）右移是将一个二进位制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器内部采用补码表示法，正数的符号位为0，负数的符号位为1。例如，对于如下程式段：

int x= 70; x等于二进位制数的01000110

int y= 2;

int z= x>>y z等于二进位制数的00010001

即运算结果为z等于二进位制数00010001，即z等于十进位制数17。

对于如下程式段：

int x=-70; x等于二进位制数的11000110

int y= 2;

int z= x>>y z等于二进位制数的11101110

即运算结果为z等于二进位制数11101110，即z等于十进位制数-18。要透彻理解右移和左移操作，读者需要掌握整数机器数的补码表示法。

（3）0填充的右移（>>>）是不论被移动数是正数还是负数，左边移进的部分一律补0。

5.其他运算子

（1）赋值运算子与其他运算子的简捷使用方式

赋值运算子可以与二元算术运算子、逻辑运算子和位运算子组合成简捷运算子，从而可以简化一些常用表示式的书写。

赋值运算子与其他运算子的简捷使用方式

运算子用法等价于说明

+= s+=i s=s+i s，i是数值型

-= s-=i s=s-i s，i是数值型

*= s*=i s=s*i s，i是数值型

/= s/=i s=s/i s，i是数值型

%= s%=i s=s%i s，i是数值型

&= a&=b a=a&b a，b是逻辑型或整型

|= a|=b a=a|b a，b是逻辑型或整型

^= A^=b a=a^b a，b是逻辑型或整型

<<= s<<=i s=s<<i s，i是整型

>>= s>>=i s=s>>i s，i是整型

>>>= s>>>=i s=s>>>i s，i是整型

（2）方括号[]和圆括号（）运算子

方括号[]是阵列运算子，方括号[]中的数值是阵列的下标，整个表示式就代表阵列中该下标所在位置的元素值。

圆括号（）运算子用于改变表示式中运算子的优先顺序。

（3）字串加（+）运算子

当运算元是字串时，加（+）运算子用来合并两个字串；当加（+）运算子的一边是字串，另一边是数值时，机器将自动将数值转换为字串，这种情况在输出语句中很常见。如对于如下程式段：

int max= 100;

System.out.println（"max="+max）;

计算机萤幕的输出结果为：max= 100，即此时是把变数max中的整数值100转换成字串100输出的。

（4）条件运算子（？：）

条件运算子（？：）的语法形式为：

<表示式1>？<表示式2>:<表示式3>

条件运算子的运算方法是：先计算<表示式1>的值，当<表示式1>的值为true时，则将<表示式2>的值作为整个表示式的值；当<表示式1>的值为false时，则将<表示式3>的值作为整个表示式的值。如：

int a=1，b=2，max;

max= a>b？a：b; max等于2

（5）强制型别转换符

强制型别转换符能将一个表示式的型别强制转换为某一指定资料型别，其语法形式为：

(<型别>)<表示式>

（6）物件运算子instanceof

物件运算子instanceof用来测试一个指定物件是否是指定类（或它的子类）的例项，若是则返回true，否则返回false。

（7）点运算子

点运算子“.”的功能有两个：一是引用类中成员，二是指示包的层次等级。

6.运算子的优先顺序

以下按优先顺序从高到低的次序列出Java语言中的所有运算子，表中结合性一列中的“左右”表示其运算次序为从左向右，“右左”表示其运算次序为从右向左。

优先顺序运算子结合性

1. []();,

2++――+=!~+(一元)-(一元)右左

3*/%左右

4+(二元)-(二元)左右

5<<>>>>>左右

6<><=>= instanceof左右

7==!=左右

8&左右

9 ^左右

10|左右

11&&左右

12||左右

13?：右左

14=*=/=%=+=－=<<=>>=>>>=&= ^=|=右左

--感谢原作者。

位运算子并不是逻辑运算子，逻辑运算子包括或、与、非、异或。

文章到此结束，如果本次分享的java乘于用什么和java加减乘除是什么类的问题解决了您的问题，那么我们由衷的感到高兴！