本文详细介绍了Java中的基本运算符，包括算术运算符、自增自减运算符、赋值运算符、复合赋值运算符、比较运算符、逻辑运算符、位运算符以及三目运算符，并解释了数据类型转换的概念。此外，还涵盖了Java中的表达式及流程控制语句，如if分支语句、switch语句和各种循环结构。
《java运算符、类型转换与流程控制语句》
1．运算符
1.1 算术运算符
算术运算符：+，-，*，/，%(取余)
1.1.1 加运算（+）
1） 数字相加，与数学类似
2） 字符参与运算，先查出字符在码表中的值，再进行相加
3） 字符串参与运算，+号作为连接符
注：加运算结果超出定义数据类型的范围，就会产生数据类型的提升或转换。
数据类型转换又分为隐式转换和显式转换（后面详讲）两种方式。
1.1.2 减运算（－）
1） 数字相加，与数学类似
2） 字符参与运算，先查出字符在码表中的值，再进行相加
1.1.3 乘运算（*）
1）数字相乘，与数学类似
1.1.4 除运算（/）
1） 整数相除取商，没有小数
2） 除数与被除数只要有一个是小数，结果为小数
3） 除数不能是0，报错。违背除法规则
1.1.5 取余运算（%）
1）%(取模/取余) 结果的正负由 左边的数据的正负决定
public static void main(String[] args) {
// + 数字相加
System.out.println(5+5); //10
//+ 数字与字符相加，先查出字符在码表中的值，再进行相加,
//字符'a'是char类型，占16bit,2byte,5是int占32bit,4byte,这里有数据类型的提升
System.out.println('a'+5);//102
//+ 数字与字符串相加，+号作为连接符
System.out.println("I am is "+5);//I am is 5
//- 减运算
System.out.println(5-4); // 1
//- 与字符做减运算，原理与加运算一样
System.out.println('A'-5); // 60
//* 乘运算
System.out.println(5 * 4); //20
// / 除运算整数相除取商，没有小数
System.out.println(5/5); // 1
System.out.println(5/2); // 2
// 除数与被除数只要有一个是小数，结果为小数
System.out.println(10/3); // 3
System.out.println(10.0/3); // 3
System.out.println(10/3.0); // 3
System.out.println(6.6/2); // 3.3
System.out.println(6/2.0); // 3.0
// /除运算，除数不能是0，违背除法规则
// System.out.println(5/0); 报错
// %(取模/取余)结果的正负由左边的数据的正负决定
System.out.println(10%3); // 1
System.out.println(-10%3);// -1
System.out.println(10.5%-2);// 0.5
System.out.println(-10.5%5);// -0.5
}1.2自增（++）和自减（--）
运算符：++，--
自增与自减运算符是单目（一个数据参与运算）运算符，可以放在操作数之前，也可以放在操作数之后。操作数必须是一个整型或浮点型变量。自增与自减的作用是使用操作数的值增1或减1。
1）放在操作数前面的自增、自减运算符，会先将变量的值加1（减1），然后再使该变量参与表达式的运算。
2）话在操作数后面的自增、自减运算符，会先使变量参与表达式的运算，然后再将该变量的值加1（减1）。
public static void main(String[] args) {
int a = 5;
int b;
double c = 10.5d;
double d;
//运算符在前，先将变量加1（减1），再用变量参与表达式的计算
b = ++ a; //变量+1，变量a=6,表达式为变量自增后的值 b=6
System.out.println(a);//6
System.out.println(b);//6
d= --c;//变量-1，变量c=9.5,表达式为变量自减后的值 b=9.5
System.out.println(c);//9.5
System.out.println(d);//9.5
System.out.println("********************************");
int aa = 5;
int bb;
double cc = 10.5d;
double dd;
//运算符在后，先使用变量参与表达式的计算，再将变量加1（减1）
bb = aa++;//表达式为变量自增前的值bb=5,再将变量+1，变量aa=6,
System.out.println(aa);//6
System.out.println(bb);//5
dd= cc--; //表达式为变量自减前的值 b=10.5,再将变量-1，变量cc=9.5
System.out.println(cc);//9.5
System.out.println(dd);//10.5
}
1.3赋值运算符
赋值运算符以“=”表示，它是一个二目运算符（二个操作数）。功能是将其右方的操作数的值赋给左方的操作数。左方的操作数必须是一个变量，而右边的操作数可以是任何表达式，包括变量（a,b）,常量（12,”123”）,有效的表达式（如：4*5）。
“=”运算符处理结果时，要先获取其右方表达工计算后的值，所以当一个表达式中含有多个“=”运算符时，会从最右方的“=”开始处理。
public static void main(String[] args) {
int a,b;
int c;int d;
a = 15; //右边是常量，直接赋值
b = a +5; //右边是表达式，先计算出表达式的值
d = c =b+10;//一个表达式中含有多个“=”运算符时，从最右方的“=”开始处理
System.out.println(a);//15
System.out.println(b);//20
System.out.println(c);//30
System.out.println(d);//30
}1.4复合赋值运算符
复合赋值运算符 += ,-=, *=, /=, %= 中间不能有空格
例：a += 5;即a = a+5;
a -= 5;即a = a-5; 其他同理。
public static void main(String[] args) {
int a = 3;
a+=5;//大致相当运算a=a+5;
System.out.println(a);
short b = 3;
//此处5是int，b到运算去中要提升为int,b+5的结果是int，而b本身是short,放不进去。显式转换数据类型
b=(short)(b+5);
System.out.println(b);
}1.5比较运算符（关系运算符）
比较运算符：>,<,==,>=,<=,!=
比较运算符的结果都是boolean型，结果为true,否则为false.
注意：比较运算符“＝＝”不要和赋值运算符“＝”混淆。
public static void main(String[] args) { System.out.println(5>3); //true
System.out.println(5<3); //false
System.out.println(5==3); //false，不要和＝混淆
System.out.println(5>=3); //true
System.out.println(5<=3); //false
System.out.println(5!=3); //true }1.6逻辑运算符（布尔运算符）
逻辑运算符：&(单与)，&&(短路与)，|(或)，||(短路或)，!(非)
1. 当&两边是整数时执行的是位运算，而两边是boolean值时执行的才是逻辑运算。结果是一个boolean值。
2. &与&&区别，&逻辑运算时两边都会计算的，而&&则在左边为假时则直接返的是false不再计算右边（又称短路）。
所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。在程序设计时使用&&和||运算符，不建议使用&和|运算符。
3. 计算规则：
&：左右两边同时为true时，表达式结果为true,其余为false;
&&：计算结果和&一样，但如果左边结果为false,就不再计算右边。
|：左右两边同时为false时，表达式结果为false,其余为true;
||：计算结果和|一样，但如果左边结果为true,就不再计算右边。
！：取反，true变false,false变true;
public static void main(String[] args) {
//& 单与
System.out.println(true &true); //true
System.out.println(true &false);//false
System.out.println(false &true);//false
System.out.println(false &false);//false
System.out.println("**********************");
//&& 双与
System.out.println(true &&true); //true
System.out.println(true &&false); //false
System.out.println(false &&true); //false
System.out.println(false &&false);//false
System.out.println("**********************");
//| 单或
System.out.println(true |true);//true
System.out.println(true |false);//true
System.out.println(false |true);//true
System.out.println(false |false);//false
System.out.println("**********************");
//|| 双或
System.out.println(true ||true); //true
System.out.println(true ||false);//true
System.out.println(false ||true);//true
System.out.println(false ||false);//true
System.out.println("**********************");
//! 非
System.out.println(!true);//false
System.out.println(!false);//true
}
1.7 位运算
1.7.1 定义：位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。
操作数不能是字符串也不能是小数。
1.7.2 运算符：位与'&'，位或'|'，位非'~'，位异或'^'，右移'>>'，左移'<<'，0填充的右移'>>>'
1.7.3 位运算的位与'&'，位或'|'，位非'~'，位异或'^'与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而逻辑运算相应操作的操作数和运算结果都是逻辑值boolean型。
1） 位与'&' 同时为1才为1，其余为0
2）位或'|' 同时为0才为0，其余为1。
3）位非'~' 逐位取返，1变0，0变1
4）位异或'^',相同为0，相异为1
任何位与0异或'^',是该位的本身
任何位与1异或'^',是该位的取反
任何位与自己异或'^',结果为0
5）<< 左移位，在低位处(右边)补0
6）>> 右移位，若为正数则高位（左加）补0，若为负数则高位（左边）补1
7）>>> 无符号右移位，无论正负都在高位补0
public static void main(String[] args) { /* * 位与'&'同时为1才为1，其余为0 * 0000 0110 6 * & * 0000 0011 3 * ------------------- * 0000 0010 2 * */ System.out.println( 6 & 3);//2 /* * 位或'|'同时为0才为0，其余为1 * 0000 0110 6 * | * 0000 0011 3 * ------------------- * 0000 0111 7 * */ System.out.println( 6 | 3);//7 /* * 位非'~'逐位取返，1变0，0变1 * 0000 0110 6（补码） * 1111 1001 ~6（补码） * * 1111 1001 ~6（补码） * 1111 1000 ~6（反码） * 1000 0111 -7（原码） * */ System.out.println(~6); // -7 /* * 位异或'^',相同为0，相异为1 * 0000 0110 6 * ^ * 0000 0011 3 * ------------------- * 0000 0101 5 * */ System.out.println( 6 ^ 3);//5 /* * 任何位与0异或'^',是该位的本身 */ System.out.println(0 ^ 0);//0 System.out.println(1 ^ 0);//1 System.out.println(6 ^ 0);//6 /* * 任何位与1异或'^',是该位的取反 */ System.out.println(0 ^ 1);//1 System.out.println(1 ^ 1);//0 System.out.println(6 ^ 1);//7 /* * 任何位与自己异或'^',结果为0 */ System.out.println(0 ^ 0);//0 System.out.println(1 ^ 1);//0 System.out.println(6 ^ 6);//0 /* * << 左移位，在低位处(右边)补0 * 0000 0011 3 * ---- ---- << 1 * 00000 0110 6 * ---- ---- * * 0000 0011 3 * ---- ---- << 2 * 00000 01100 12 * ---- ---- * */ System.out.println(3<<1); //6,3*2*1 System.out.println(3<<2); //12,3*2*2 /* * >> 右移位，若为正数则高位（左加）补0，若为负数则高位（左边）补1 * 0000 0011 3 * ---- ---- >> 1 * 0000 0001 1 1 * ---- ---- * * 0000 0011 3 * ---- ---- >> 2 * 0000 0000 11 0 * ---- ---- * * * 1000 0011 -3(原码) * 1111 1100 -3(反码) * 1111 1101 -3(补码) * ---- ---- >> 1 * 1111 1110 1 补码 * ---- ---- * 1111 1101 反码 * --------- * 1000 0010 -2原码 * * */ System.out.println(3>>1); //1,3/(2*1) System.out.println(3>>2); //0,3/(2*2) System.out.println(-3>>1);//-2 /* * >>> 无符号右移位，无论正负都在高位补0 * 0000 0011 3 * ---- ---- >>> 1 * 00000 0011 1 * ---- ---- */ System.out.println(3>>>1);//1 }
1.7.4 位运算的应用：
根据位运算异或'^'的原理，我们可以来交换两个数的值，不借助第三方变量。
public static void main(String[] args) { //根据位运算异或'^'的原理，我们可以来交换两个数的值，不借助第三方变量 int a= 5; int b= 10; //1.借助第三方变量 int temp; System.out.println("交换前a的值："+a+"，b的值为："+b); ////交换前a的值：5，b的值为：10 temp = a; a = b; b=temp; System.out.println("交换前后的值："+a+"，b的值为："+b); //交换前后的值：10，b的值为：5 // 不借助第三方变量，使用位运算异或'^' int c= 10; int d= 20; System.out.println("交换前c的值："+c+"，d的值为："+d); //交换前c的值：10，d的值为：20 c = c^d; d = c^d; // ===> (c^d)^d ===> c 任何位与自己异或'^',结果为0,任何位与0异或'^',是该位的本身 c = c^d; // ===> (c^d)^((c^d)^d) ===> d System.out.println("交换后c的值："+c+"，d的值为："+d); //交换后c的值：20，d的值为：10 }
1.8三目运算符（三元运算符）
定义：条件运算符是唯一有3个操作数的运算符
格式：<表达式1>?<表达式2>:<表达式3>;
"?"运算符的含义是:先求表达式1的值,如果为真,则执行表达式2，并返回表达式2的结果 ; 如果表达式1的值为假,则执行表达式3，并返回表达式3的结果。
public static void main(String[] args) { System.out.println(true?"表达式二":"表达式三");//表达式二
System.out.println(false?"表达式二":"表达式三");//表达式三
System.out.println(20>10?true:false);//true
System.out.println(20<10?true:false);//false }2. 表达式
2.1 是指用运算符连接起来的，符合java语法的式子。
2.2 Java表达式的分类：
算数表达式：20+10
关系表达式：20>10
逻辑表达式：20>10 && 10>5
赋值表达式：a = 10
2.3 条件表达式
结果是boolean类型的表达式，结果要么是true,要么是false;
3. 数据类型的转换
Java 语言是一种强类型的语言。强类型的语言有以下几个要求：
1） 变量或常量必须有类型:要求声明变量或常量时必须声明类型，而且只能在声明以后才能使用。
2） 赋值时类型必须一致:值的类型必须和变量或常量的类型完全一致。
3）运算时类型必须一致:参与运算的数据类型必须一致才能运算。
但是在实际的使用中，经常需要在不同类型的值之间进行操作，这就需要一种新的语法来适应这种需要，这个语法就是数据类型转换。
在数值处理这部分，计算机和现实的逻辑不太一样，对于现实来说，1和 1.0 没有什么区别，但是对于计算机来说，1 是整数类型，而 1.0 是小数类型，其在内存中的存储方式以及占用的空间都不一样，所以类型转换在计算机内部是必须的。
在Java应用程序中，有时候需要对数据类型进行转换。这个转换包括显示转换与隐式转换。
（1） 隐式转换（自动转换）：编译器自动完成类型转换，不需要在程序中编写代码；
规则：从存储范围小的类型到存储范围大的类型。不会丢失数据精度
具体规则：byte→short(char)→int→long→float→double.
（2） 显示转换（强制转换）：强制编译器进行类型转换，必须在程序中编写代码。
规则：从存储范围大的类型到存储范围小的类型。 该类型转换很可能存在精度的损失。
具体规则：double→float→long→int→short(char)→byte.
格式：（要转换的数据类型）被转换的值 如：(int)3.14
public static void main(String[] args) {
//隐示转换
short s = 250;
int i = 520;
float f;
double d;
f = s;
d = i;
System.out.println(s); //250
System.out.println(i); //520
System.out.println(f); //250.0
System.out.println(d); //520.0
// 显示转换（强制转换）
double pi=3.1415;
int num = (int)pi;
System.out.println(num); //3 存在精度的损失
}4流程控制语句
定义：控制语句即用来实现对程序流程的选择、循环、转向和返回等进行控制。控制语句用于控制程序的流程，以实现程序的各种结构方式。
4.1分支语句-if
4.2分支语句-switch
4.3循环结构-while
4.4循环结构-do-while
4.5 循环结构-for
4.6循环结构-循环嵌套
4.7 循环补充
4.8 break和continue
1. break 命令可以终止循环的运行，然后继续执行循环之后的代码（如果循环之后有代码的话）。在多层循环中，一个break语句只向外跳一层。
2. continue:是结束本次循环，进行下次循环.
3. break和continue不能单独使用，只能在循环中。在switchcase里，只能用break，而不能用continue。
4.break后面可以跟标签名，指定向哪个位置跳（用于多层循环跳出）。
public static void main(String[] args) {
/*
* break 或 continue
*/
for (int i = 0; i < 5; i++) {
if(i == 2){
break; //结束循环
}
System.out.println(i+",");//0,1,
}
for (int i = 0; i < 5; i++) {
if(i == 2){
continue; //结束本次循环，执行下一次循环
}
System.out.println(i+",");//0,1,3,4,
}
}从内层循环直接跳出外层循环的两种方式：
1）通过在外层循环外设置标签，内层循环直接break到标签位置处。
标签格式：标识符”:”(标识符+冒号)
2）使用boolean变量值进行条件控件。
public static void main(String[] args) {
/*
* 从内层循环直接跳出外层循环方式一
*/
ok:
for(int i=0;i<10;i++){
System.out.println("********i=:"+i);
for(int j=0;j<10;j++){
System.out.println("********j=:"+j);
if(j == 3)
break ok;
}
}
System.out.println("****************");
/*
* 从内层循环直接跳出外层循环方式二
* 使用boolean变量值进行条件控件
*/
boolean f = false;
for(int i = 0 ;i<5&&!f;i++){
System.out.println("********i=:"+i);
for(int j = 0 ;j<5;j++){
if(j==3){
f=true;
break;
}
System.out.println("********j=:"+j);
}
}
}
扫一扫
6063
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
