Java基本语法
编辑时间：2021/01/25
读完本节：大概花费30分钟，共3070词
1.运算符
-
运算符是一种特殊的符号，可以用于表示数据的运算、赋值和比较等
-
运算符包括：算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、三元运算符
1）算数运算符
运算符 运算 举例 结果 + 正号 +3 3 - 负号 b = 4; -b -4 + 加 5+5 10 - 减 6-4 1 * 乘 3*4 12 / 除 5/5 1 % 取余（取模） 7%5 2 ++i 自增i，先运算后取值 a = 2; b = ++a; a = 3; b = 3; i++ 自增i，先取值后运算 a = 2; b = a++; a = 3; b = 2; –i 自减i，先运算后取值 a = 2; b = --a; a = 1; b = 1; i– 自减i，先取值后运算 a = 2; b = a–; a = 1; b = 2; + 字符串连接 “hell” + “o” “hello” class AriTest{ public static void main(String[] args){ //除号：/ int num1 = 10; int num2 = 5; int result1 = num1 / num2; System.out.println(result1);//2 int result2 = num1 / num2 * num2; System.out.println(result2);//10 } }class AriTest1{ public static void main(String[] args){ //除号：/ int num1 = 12; int num2 = 5; /* 整数类型变量进行除法，可能 会出现浮点数， 若直接采用double类型不能直接得到精确值， 需要进行强制类型转换，或者先加上0.0完成自动类型提升 */ double result3 = num1 / num2;//2.0 double result4 = num1 / num2 + 0.0;//2.0 double result5 = num1 / (num2 + 0.0);//2.4 double result6 = (double)num1 / num2;//2.4 double result7 = (double)(num1 / num2);//2.0 System.out.println(result3); System.out.println(result4); System.out.println(result5); System.out.println(result6); System.out.println(result7); } }class AriTest2{ public static void main(String[] args){ //%：取余运算 //结果的符号与被模数的符号相同 int m1 = 12; int n1 = 5; System.out.println("m1 % n1 = " + m1 % n1);//2 int m2 = -12; int n2 = 5; System.out.println("m2 % n2 = " + m2 % n2);//-2 int m3 = 12; int n3 = -5; System.out.println("m3 % n3 = " + m3 % n3);//2 int m4 = -12; int n4 = -5; System.out.println("m4 % n4 = " + m4 % n4);//-2 } }class AriTest3{ public static void main(String[] args){ //++i：先自增后运算 int a1 = 10; int b1 = ++a1; System.out.println("a1 = " + a1 + ", b1 = " + b1); //i++：先运算后自增 int a2 = 10; int b2 = a2++; System.out.println("a2 = " + a2 + ", b2 = " + b2); int a3 = 10; ++a3;//a3++ b3 = a3;//b3 = 11 //在自增运算过程中不会改变数据类型但是分开处理可能导致数据类型发生改变 short s1 = 10; //s1 = s1 + 1;//编译失败 s1 = (short)(s1 + 1);//正确 s1++;//直接自增1，简单快捷，且不会改变变量本身的数据类型 //超出数据类型的范围 byte bt1 = 127; bt1++; System.out.println("bt1 = " + bt1);//-128 //自减操作注意同自增，类比即可 } }练习1:
class AriTest4{ public static void main(String[] args){ int i1 = 10; int i2 = 20; int i = i1++; System.out.println("i = " + i);//10 System.out.println("i = " + i1);//11 i = ++i1; System.out.println("i = " + i);//12 System.out.println("i = " + i1);//12 i = i2--; System.out.println("i = " + i);//20 System.out.println("i = " + i2);//19 i = --i2; System.out.println("i = " + i);//18 System.out.println("i = " + i2);//18 } }练习2：
//一个百位数，分别输出其个位、十位、百位 class Teardown{ public static void main(String[] args){ int num = 187; //hundreds 百位；tens 十位；digit 个位 int hundreds = num / 100; int tens = num / 10 % 10;// tens = num % 100 / 10 int digit = num % 10; System.out.println("百位为：" + hundreds); System.out.println("十位为：" + tens); System.out.println("个位为：" + digit); } }2）赋值运算符
运算符 运算规则 = 赋值，当等号两边数据类型不一致时，可以使用自动类型提升或强制类型转换原则进行处理 += 加等 -= 减等 *= 乘等 /= 除等 %= 模等 class SetValueTest{ public static void main(String[] args){ //赋值：= int i1 = 10; int j1 = 10; //连续赋值 int i2，j2; i2 = j2 = 10; int i3 = 10, j3 = 10; //加等：+= //减等类同 int num1 = 10; num1 += 2; System.out.println(num1);//12 //模等：%= //乘等、除等类同 int num2 = 12; num2 %= 5; System.out.println(num2);//2 //+=不完全的作用不完全与分开各自运算相同， //可以避免数据类型发生改变，类同自增操作 short s1 =10; //s1 = s1 + 2;//编译失败 s1 = (short)(s1 + 2);//成功 s1 += 2;//成功，简洁的同时不需要强制类型转换 System.out.println(s2); } }练习
//练习一:(1)和(2)有什么区别 short s = 3; s = s + 2;//(1) s += 2;//(2) //(1)编译不通过，2默认为int型变量，(2)的加等操作不会改变数据类型 //练习二：判断输出 int i = 1; i *= 0.1; System.out.println(i); //0 i++; System.out.println(i); //1 //练习三：判断输出 int m = 2; int n = 3; n *= m++; System.out.println("m = " + m); //m = 3 System.out.println("n = " + n); //n = 6 //练习四：判断输出 int n = 10; n += (n++) + (++n); System.out.println(n); //323）比较运算符（关系运算符）
运算符 运算 举例 结果 == 相等于 4==3 false != 不等于 4!=3 true < 小于 4<3 false > 大于 4>3 true <= 小于等于 4<=3 false >= 大于等于 4>=3 true instanceof 检查是否是类的对象 “hello” instanceof String true 比较运算符的结果都是boolean型，要么为true要么为false。
class CompareTest{ public static void main(String[] args){ int i = 10; int j = 20; System.out.println(i == j); //false System.out.println(i = j); //20 boolean b1 = true; boolean b2 = false; System.out.println(b1 == b2); //false System.out.println(b1 = b2); //true } }练习
boolean b1 = false; if(b1 == true){ System.out.println("True"); }else{ System.out.println("False"); } //False4）逻辑运算符
运算符 运算规则 & 逻辑与 && 短路与 | 逻辑或 || 短路或 ! 逻辑非 ^ 逻辑异或 真值表
a b a&b a&&b a|b a||b !a a^b true true true true true true false false true false false false true true false true false true false false true true true true false false false false false false true false class LogicTest{ public static void main(String[] args){ //区分逻辑与和短路与 /* 1. &与&&的运算结果相同 2. 当符号左边是true时，二者都会执行符号右边的运算 3. 当符号左边时false时，&继续执行符号右边的运算而&&不会继续执行符号右边的运算 */ //逻辑与 boolean b1 = true; int num1 = 10; if(b1 & (num1++ > 0)){ System.out.println(1); }else{ System.out.println(2); } System.out.println(num1); /* //结果 1 11 */ //短路与 boolean b2 = true; int num2 = 10; if(b1 & (num2++ > 0)){ System.out.println(1); }else{ System.out.println(2); } System.out.println(num2); /* //结果 1 11 */ b1 = false; if(b1 & (num1++ > 0)){ System.out.println(1); }else{ System.out.println(2); } System.out.println(num1); /* //结果 2 11 */ b2 = false; if(b2 && (num2++ > 0)){ System.out.println(1); }else{ System.out.println(2); } System.out.println(num2); /* //结果 2 10 */ //区分逻辑或和短路或 /* 1. |与||的运算结果相同 2. 当符号左边是false时，二者都会执行符号右边的运算 3. 当符号左边时true时，&继续执行符号右边的运算而&&不会继续执行符号右边的运算 */ } }练习：判断输出结果
//练习一 int x = 1; int y = 1; if(x++ == 2 & ++y ==2){ //false & true x = 7; } System.out.println("x = " + x,", y = " + y); // x = 2, y = 2 //练习二 int x = 1; int y = 1; if(x++ == 2 && ++y ==2){ //false && true x = 7; } System.out.println("x = " + x,", y = " + y); // x = 2, y = 1 //练习三 int x = 1; int y = 1; if(x++ == 1 | ++y ==1){ //true | false x = 7; } System.out.println("x = " + x,", y = " + y); // x = 7, y = 2 //练习四 int x = 1; int y = 1; if(x++ == 1 || ++y ==1){ //true || false x = 7; } System.out.println("x = " + x,", y = " + y); // x = 7, y = 1 //练习五 boolean x = true; boolean y = false; short z = 42; if((z++ == 42) && (y = true)) //ture && true z++; //44 if((x = false) || (++z == 45)) //false || true z++; //46 System.out.println("z = " + z); //z = 46 //练习六 boolean x = true; boolean y = false; short z = 42; if(y == true) //false == true = false if((z++ == 42) && (y = true)) z++; if((x = false) || (++z == 45)) //false || false = true; 43 z++; //44 System.out.println("z = " + z); //z = 445）位运算符
运算符 运算 举例 结果 << 左移，空位补0，被移除的高位丢弃，空缺位补0 3 << 2 = 12 3 * 2 * 2 = 12 >> 右移，被移位的二进制最高位为0，右移后，空缺位补0；最高位为1，空缺位补1 3 >> 1 = 1 3 / 2 = 1 >>> 无符号左移，被移位二进制最高位无论是0或者1，空缺位都用0补，也叫逻辑右移 3 >>> 1 = 1 3 / 2 = 1 & 与运算，二进制位进行与运算，同1为1，否则为0 6 & 3 2 | 或运算，二进制位进行或运算，同0为0，否则为1 6 | 3 7 ^ 异或运算，二进制数从低位到高位进行异或运算，相同为0，不同为1 6 ^ 3 5 ~ 取反运算，正数取反各二进制码按补码各位取反；负数取反，各二进制码按补码各位取反 ~ 6 -7 位运算符是直接对整数的二进制进行的运算，位运算符操作的数据类型都是整型。<<：在一定的范围内，每向左移1位，相当于*2。>>：在一定范围内，每向右移1位相当于/2。
对于高效的计算2 * 8可以采用位运算：2 << 3 = 16 或 8 << 1 = 16
class BitTest{ public static void main(String[] args){ int i = 21; System.out.println("i << 2: " + (i << 2)); //42 System.out.println("i << 3: " + (i << 3)); //84 System.out.println("i << 27: " + (i << 27)); //2,818,572,288 i = -21; System.out.println("i << 2: " + (i << 2)); //-84 System.out.println("i << 3: " + (i << 3)); //-168 System.out.println("i << 27: " + (i << 27)); //-2,818,572,288 int m = 12; int n = 5; System.out.println("m & n: " + (m & n)); //0b1100 & 0b0101 = 0b0100 = 4 System.out.println("m | n: " + (m | n)); //0b1100 | 0b0101 = 0b1101 = 13 System.out.println("m ^ n: " + (m ^ n)); //0b1100 & 0b0101 = 0b1001 = 9 } }练习：交换两个变量的值
class BitTest1{ public static void main(String[] args){ int num1 = 13; int num2 = 5; System.out.println("num1 = " + num1 + ", num2 = " + num2); //方法一：定义临时变量 /* int temp = num1; int num1 = num2; int num2 = temp; */ //方法二：加减法 //1.相加操作可能超出存储范围；2.有局限性，仅适用于数值类型 /* num1 = num1 + num2; num2 = num1 - num2; num2 = num1 - num2; */ //方法三：位运算 //有局限性，仅适用于数值类型 /* num1 = num1 ^ num2; num2 = num1 ^ num2; num1 = num1 ^ num2; */ } }
6）三元运算符（三目运算符）
格式：
(条件表达式) ? 表达式1 : 表达式2；
当条件表达式结果为：
① true，运算后的结果是表达式1；
② false，运算后的结果是表达式2；
表达式1和表达式2为同种类型；表达式的结果为boolean类型；三元运算符可以嵌套使用。
三元运算符与“if-else”的异同：
①三元运算符可以简化为“if-else”语句
②三元运算符要求必须范围一个结果
③“if-else”结构中“if”后可以是代码块
class TernaryTest{ public static void main(String[] args){ //获取两个数的较大值 int m = 12; int n = 5; int max = (m > n) ? m : n; System.out.printl(max); double num = (m > n) ? 2 : 1.0; n = 12; String maxStr = (m > n) ? "m" : ((m == n) ? "m = n" : "n"); System.out.printl(maxStr); } } -
运算符的优先级
1）只有单目运算符、三目运算符、赋值运算符是从右向左运算，其余都是从左到右运算。
2）优先级表（降序）
. () {} ; , R→L ++ – ~ !(data type) L→R *** / %** L→R + - L→R << >> >>> L→R < > <= >= instanceof L→R == != L→R & L→R ^ L→R | L→R && L→R || R→L (条件表达式)?(表达式1):(表达式2) R→L *= = /= %= += -= <<= >>= >>>= &= ^= |=
2.程序流程控制
-
程序流程控制采用结构化程序设计中规定的三种基本流程结构：顺序结构、分支结构、循环结构
-
顺序结构：程序从上到下执行，中间没有任何跳转
-
分支结构：根据条件选择型的执行某段代码，分支结构包括“if-else”，“switch-case”两种分支语句
-
循环结构：根据循环条件，重复执行某段代码，有“while”，“do-while”，“for”三种循环语句，JDK1.5提供了便于遍历集合、数组元素的“foreach”循环
while
do-while
for
-
for循环和while的区别如下：
①循环的结构不同
for循环的表达式为：
for(单次表达式;条件表达式;末尾循环体){
代码块;
}
while循环的表达式为：
while(表达式){
代码块；
}
②执行条件的判断方式不同
for循环执行末尾循环体后将再次进行条件判断，若条件还成立，则继续重复上述循环，当条件不成立时则跳出当下for循环。
while循环当满足条件时进入循环，进入循环后，当条件不满足时，执行完循环体内全部语句后再跳出（而不是立即跳出循环）。
③使用的目的不同
for循环的目的是为了限制循环体的执行次数，使结果更精确。
while循环的目的是为了反复执行语句或代码块。
④语法不同
for循环的语法为：for (变量 = 开始值;变量 <= 结束值;变量 = 变量 + 步进值) {需执行的代码 }。