《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);
}
}
}