目录
运算符
运算符:算术运算符
运算符:赋值运算符
运算符:比较运算符
运算符:逻辑运算符
运算符:三元运算符
运算符的优先级
程序流程控制
概念
顺序结构
if-else结构
switch-case结构
循环结构
循环结构之for循环
循环结构之while循环
循环结构之do-while循环
嵌套循环结构
break、continue
break的使用 终止本次循环
continue的使用 跳过本层循环
运算符
- 算术运算符
- 赋值运算符
- 比较运算符(关系运算符)
- 逻辑运算符
- 位运算符(了解)
- 三元运算符
运算符:算术运算符
术运算符的注意问题
- 如果对负数取模,可以把模数负号忽略不记,如:5%-2=1。 但被模数是负数则不可忽略。此外,取模运算的结果不一定总是整数。
- 对于除号“/”,它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃小数部分。
- +”除字符串相加功能外,还能把非字符串转换成字符串
- 前++ :先自增 后运算 后++ 先运算 后自增 :不会改变本身变量的数据类型,
注意点 取余运算% 结果的符号与被取余的符号相同,整型和整型做运算得到的是int类型
class AirrTest
/*
运算符之一 算数运算符
+ - + - / % 前++ 后++ 前-- 后--
除法运算取商数 取余运算取余数
*/
{public static void main(String[] args) {//除号 /int num1=12;int num2=5;//整型和整型做运算得到的是int类型 2int result=num1 / num2;//0.0是double类型,所以num2+0.0是double类型 2.4double resul2=num1 /(num2+0.0);double result3=num1/ (double)num2;System.out.println(result3);//取余运算% 结果的符号与被取余的符号相同int m1=12;int m2=-5;System.out.println("res1"+ m1%m2);//2int m3=-12;int m4=5;System.out.println("res2"+m3%m4);//-2int m5=-12;int m6=-5;System.out.println("res3"+m5%m6);//-2、//前++ :先自增 后运算//后++ 先运算 后自增int a1=10;int b1=++a1;System.out.println("a1="+a1+",b1="+b1);//11 11int a2=10;int b2=a2++;System.out.println("a2="+a2+",b2="+b2);//11 10//注意点 :不会改变本身变量的数据类型short s1=10;//s1=s1+1;//前-- :先自增 后运算//后-- 先运算 后自增int a3=10;int b3=--a3;System.out.println("a3="+a3+",b3="+b3);//11 11int a4=10;int b4=a4--;System.out.println("a4="+a4+",b4="+b4);//11 10}
}
运算符:赋值运算符
- 符号:= 当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制
- 类型转换原则进行处理。 支持连续赋值。
- 扩展赋值运算符: +=, -=, *=, /=, %=
class setValue
// 赋值 = += *= /= %=
{public static void main(String[] args) {//赋值符号=int j1=10;int j2=20;//连续赋值int i1,i2;i1=i2=10;int i3=10,j3=20;//********int num=10;num+=2;//mum=num+2short s1=10;// s1=s1+2;编译失败s1+=2;// 不会改变 变量本身数据类System.out.println("Hello World!");}
}
运算符:比较运算符
比较运算符的结果都是boolean型,也就是要么是true,要么是false。
比较运算符“==”不能误写成“=” 。
/*
运算符之三 比较运算符
== != > < >= <= instanceof
比较运算符的结果是boolean类型*/class compare
{public static void main(String[] args) { boolean i=true;boolean j=false;System.out.println(i==j);//falseSystem.out.println(j=i);//false}
}
运算符:逻辑运算符
- &—逻辑与
- | —逻辑或
- !—逻辑非
- && —短路与
- || —短路或
- ^ —逻辑异或
逻辑运算符用于连接布尔型表达式,在Java中不可以写成3<x<6,应该写 成x>3 & x<6 。
&”和“&&”的区别:
- 单&时,左边无论真假,右边都进行运算;
- 双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算。
- “|”和“||”的区别同理,||表示:当左边为真,右边不参与运算。
异或( ^ )与或( | )的不同之处是:当左右都为true时,结果为false。 理解:异或,追求的是“异”
/*
运算符之四:逻辑运算符
& && | || ! ^&& 与 & 运算结果是相同的,符号左边是true时 都会执行右边的运算当符号左边是false时,&继续执行右边的运算,&&不在执行右边的运算
|| 与 | 运算结果是相同的,符号左边是false时 都会执行右边的运算当符号左边是true时,|继续执行右边的运算,||不在执行右边的运算逻辑运算符操作的都是Boolean类型
*/
class logic {public static void main(String[] args){//逻辑与boolean b1=false;int num1=10;if(b1&(num1++>0)){System.out.println("真的");}else{System.out.println("假的");}System.out.println("num1:"+num1);//短路与boolean b2=false;int num2=10;if(b2&&(num2++>0)){System.out.println("真的");}else{System.out.println("假的");}System.out.println("num2:"+num2);// 逻辑或boolean b3=true;int num3=10;if(b3|(num3++>0)){System.out.println("真的");}else{System.out.println("假的");}System.out.println("num3:"+num3);//短路或boolean b4=true;int num4=10;if(b4 ||(num4++>0)){System.out.println("真的");}else{System.out.println("假的");}System.out.println("num4:"+num4);}
}
运算符:三元运算符
表达式1和表达式2为同种类型
三元运算符与if-else的联系与区别:
- 1)三元运算符可简化if-else语句
- 2)三元运算符要求必须返回一个结果。
- 3)if后的代码块可有多个语句
class sanYuan
/*
运算符之五:三元运算符
结构条件表达式?(表达式1:表达式2)
根据表达式真或假 决定执行表达式1或表达式2表达式为true,则执行表达式1表达式为false 则执行表达式2表达式1与表达式2的类型要求是一致的三元运算符可以嵌套使用凡是可以使用三元运算符的地方都可以改写为if---else,反之不可以
*/
{public static void main(String[] args) {//获取两个整数的较大值int m=12;int n=12;int max=(m>n)?m:n;String maxstr=m>n?"m大":((m==n)?"m和n相等":"n大");if(m>n){System.out.println(m);}else{System.out.println(n);}System.out.println(maxstr);}}
运算符的优先级
- 运算符有不同的优先级,所谓优先级就是表达式运算中的运算顺序
- 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的
程序流程控制
概念
流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组 合成能完成一定功能的小逻辑模块。 其流程控制方式采用结构化程序设计中规定的三种基本流程结构,即:
- 顺序结构 程序从上到下逐行地执行,中间没有任何判断和跳转。
- 分支结构 根据条件,选择性地执行某段代码 有if…else和switch-case两种分支语句
- 循环结构 根据循环条件,重复性的执行某段代码 有while、do…while、for三种循环语句。
顺序结构
Java中定义成员变量时采用合法的前向引用。如:
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式:
public class Test{
int num2 = num1 + 2;
int num1 = 12;
}
if-else结构
- 条件表达式必须是布尔表达式(关系表达式或逻辑表达式)、布尔变量
- 语句块只有一条执行语句时,一对{}可以省略,但建议保留
- if-else语句结构,根据需要可以嵌套使用
- 当if-else结构是“多选一”时,最后的else是可选的,根据需要可以省略
- 当多个条件是“互斥”关系时,条件判断语句及执行语句间顺序无所谓
- 当多个条件是“包含”关系时,“小上大下 / 子上父下”
/*
分支结构中的if--else
三种结构第一种
if(条件表达式){执行表达式}第二种 二选一
if(条件表达式){执行表达式1
}else{执行表达式2
}
第三种 多选一if(条件表达式){执行表达式1
}else if(条件表达式){执行表达式2
}else{执行表达式3
}*/class ifTest
{public static void main(String[] args) { int n=10;int m=5;if(m>n){System.out.println("m:"+m);}else if(m==n){System.out.println("相等");}else{System.out.println("n:"+n);}System.out.println("Hello World!");}
}
switch-case结构
- switch(表达式)中表达式的值必须是下述几种类型之一:byte,short, char,int,枚举 (jdk 5.0),String (jdk 7.0);
- case子句中的值必须是常量,不能是变量名或不确定的表达式值;
- 同一个switch语句,所有case子句中的常量值互不相同;
- break语句用来在执行完一个case分支后使程序跳出switch语句块;如 果没有break,程序会顺序执行到switch结尾
- default子句是可任选的。同时,位置也是灵活的。当没有匹配的case时, 执行default
/*
分支结构之二:switch-case1.格式
switch(表达式){
case 常量1:执行语句1;//break;case 常量2:执行语句2;//break;...default:执行语句n;//break;}2.说明:
① 根据switch表达式中的值,依次匹配各个case中的常量。一旦匹配成功,则进入相应case结构中,调用其执行语句。当调用完执行语句以后,则仍然继续向下执行其他case结构中的执行语句,直到遇到break关键字或此switch-case结构末尾结束为止。② break,可以使用在switch-case结构中,表示一旦执行到此关键字,就跳出switch-case结构③ switch结构中的表达式,只能是如下的6种数据类型之一:byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)④ case 之后只能声明常量。不能声明范围。⑤ break关键字是可选的。⑥ default:相当于if-else结构中的else. default结构是可选的,而且位置是灵活的。
*/class SwitchCaseTest {public static void main(String[] args) {int number = 5;switch(number){case 0:System.out.println("zero");break;case 1:System.out.println("one");break;case 2:System.out.println("two");break;case 3:System.out.println("three");break;default:System.out.println("other");//break;}String season = "summer";switch (season) {case "spring":System.out.println("春暖花开");break;case "summer":System.out.println("夏日炎炎");break;case "autumn":System.out.println("秋高气爽");break;case "winter":System.out.println("冬雪皑皑");break;default:System.out.println("季节输入有误");break;}//**************如下的两种情况都编译不通过*********************//情况一/*boolean isHandsome = true;switch(isHandsome){case true:System.out.println("我好帅啊~~~");break;case false:System.out.println("我好丑啊~~~");break;default:System.out.println("输入有误~~~");}*///情况二/*int age = 10;switch(age){case age > 18:System.out.println("成年了");break;default:System.out.println("未成年");}*/}
}
- 如果判断的具体数值不多,而且符合byte、short 、char、int、String、枚举等几种类型。虽然两个语句都可以使用,建议使用swtich语句。因为效率稍高。
- 其他情况:对区间判断,对结果为boolean类型判断,使用if,if的使用范围更广。
- 也就是说,使用switch-case的,都可以改写为if-else。反之不成立。
循环结构
循环结构 在某些条件满足的情况下,反复执行特定代码的功能
循环语句分类 for 循环 while 循环 do-while 循环
循环语句的四个组成部分
- 初始化部分(init_statement)
- 循环条件部分(test_exp)
- 循环体部分(body_statement)
- 迭代部分(alter_statement)
循环结构之for循环
语法格式
for (①初始化部分; ②循环条件部分; ④迭代部分){
③循环体部分;
}
执行过程: ①-②-③-④-②-③-④-②-③-④-.....-②
说明:
- ②循环条件部分为boolean类型表达式,当值为false时,退出循环
- ①初始化部分可以声明多个变量,但必须是同一个类型,用逗号分隔
- ④可以有多个变量更新,用逗号分隔
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件二、for循环的结构for(①;②;④){③
}执行过程:① - ② - ③ - ④ - ② - ③ - ④ - ... - ②*/
class ForTest {public static void main(String[] args) {/*System.out.println("Hello World!");System.out.println("Hello World!");System.out.println("Hello World!");System.out.println("Hello World!");System.out.println("Hello World!");*/for(int i = 1;i <= 5;i++){//i:1,2,3,4,5System.out.println("Hello World!");}//i:在for循环内有效。出了for循环就失效了。//System.out.println(i);//练习:int num = 1;for(System.out.print('a');num <= 3;System.out.print('c'),num++){System.out.print('b');}//输出结果:abcbcbcSystem.out.println();//例题:遍历100以内的偶数,输出所有偶数的和,输出偶数的个数int sum = 0;//记录所有偶数的和int count = 0;//记录偶数的个数for(int i = 1;i <= 100;i++){if(i % 2 == 0){System.out.println(i);sum += i;count++;}//System.out.println("总和为:" + sum);}System.out.println("总和为:" + sum);System.out.println("个数为:" + count);}
}
循环结构之while循环
语法格式
①初始化部分
while(②循环条件部分){
③循环体部分;
④迭代部分;
}
执行过程: ①-②-③-④-②-③-④-②-③-④-...-②
说明:
- 注意不要忘记声明④迭代部分。否则,循环将不能结束,变成死循环。
- for循环和while循环可以相互转换
/*
While 循环的使用一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件二、while循环的结构①
while(②){③;④;
}执行过程:① - ② - ③ - ④ - ② - ③ - ④ - ... - ②说明:
1.写while循环千万小心不要丢了迭代条件。一旦丢了,就可能导致死循环!
2.我们写程序,要避免出现死循环。
3.for循环和while循环是可以相互转换的! 区别:for循环和while循环的初始化条件部分的作用范围不同。算法:有限性。*/
class WhileTest{public static void main(String[] args) {//遍历100以内的所有偶数int i = 1;while(i <= 100){if(i % 2 == 0){System.out.println(i);}i++;}//出了while循环以后,仍可以调用。System.out.println(i);//101}
}
循环结构之do-while循环
语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
执行过程: ①-③-④-②-③-④-②-③-④-...②
说明: do-while循环至少执行一次循环体。
/*
do-while循环的使用一、循环结构的4个要素
① 初始化条件
② 循环条件 --->是boolean类型
③ 循环体
④ 迭代条件二、do-while循环结构:①
do{③;④;}while(②);执行过程:① - ③ - ④ - ② - ③ - ④ - ... - ②说明:
1.do-while循环至少会执行一次循环体!
2.开发中,使用for和while更多一些。较少使用do-while*/
class DoWhileTest {public static void main(String[] args) {//遍历100以内的偶数,并计算所有偶数的和及偶数的个数int num = 1;int sum = 0;//记录总和int count = 0;//记录个数do{if(num % 2 == 0){System.out.println(num);sum += num;count++;}num++;}while(num <= 100);System.out.println("总和为:" + sum);System.out.println("个数为:" + count);//*************体会do-while至少执行一次循环体***************int number1 = 10;while(number1 > 10){System.out.println("hello:while");number1--;}int number2 = 10;do{System.out.println("hello:do-while");number2--;}while(number2 > 10);}
}
嵌套循环结构
将一个循环放在另一个循环体内,就形成了嵌套循环。其中, for ,while ,do…while均可以作为外层循环或内层循环。
实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的 循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开 始下一次的循环。
设外层循环次数为m次,内层为n次,则内层循环体实际上需要执行m*n次
/*
嵌套循环的使用
1.嵌套循环:将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环2.
外层循环:循环结构B
内层循环:循环结构A3. 说明
① 内层循环结构遍历一遍,只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次,内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次4. 技巧:外层循环控制行数,内层循环控制列数
*/
class ForForTest {public static void main(String[] args) {//******//System.out.println("******");for(int i = 1;i <= 6;i++){System.out.print('*');}System.out.println("\n");/**************************/for(int j = 1;j <= 4;j++ ){for(int i = 1;i <= 6;i++){System.out.print('*');}System.out.println();}/* i(行号) j(*的个数)* 1 1** 2 2*** 3 3**** 4 4***** 5 5*/for(int i = 1;i <= 5;i++){//控制行数for(int j = 1;j <= i;j++){//控制列数System.out.print("*");}System.out.println();}/* i(行号) j(*的个数) 规律:i + j = 5 换句话说:j = 5 - i;**** 1 4*** 2 3** 3 2* 4 1*/ for(int i = 1;i <= 4;i++){for(int j = 1;j <= 5 - i;j++){System.out.print("*"); }System.out.println();}}
}
break、continue
break的使用 终止本次循环
{ ……break;……}
label1: { ……label2: { ……label3: { ……break label2;……}}}
continue的使用 跳过本层循环
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行,继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时,可以通过标签指明要跳过的是哪一层循环
/*
break和continue关键字的使用使用范围 循环中使用的作用(不同点) 相同点
break: switch-case 循环结构中 结束当前循环 关键字后面不能声明执行语句 continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句*/
class BreakContinueTest {public static void main(String[] args) {for(int i = 1;i <= 10;i++){if(i % 4 == 0){break;//123//continue;//123567910//System.out.println("今晚迪丽热巴要约我!!!");}System.out.print(i);}System.out.println("\n");//******************************label:for(int i = 1;i <= 4;i++){for(int j = 1;j <= 10;j++){if(j % 4 == 0){//break;//默认跳出包裹此关键字最近的一层循环。//continue;//break label;//结束指定标识的一层循环结构continue label;//结束指定标识的一层循环结构当次循环}System.out.print(j);}System.out.println();}}
}
break只能用于switch语句和循环语句中。 continue 只能用于循环语句中。
- 二者功能类似,但continue是终止本次循环,break是终止本层循环。
- break、continue之后不能有其他的语句,因为程序永远不会执行其后的语句。
- 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。