Java学习笔记——运算符与控制语句
运算符与控制语句
- 一、运算符
- 1.1.1、运算符概述
- 1.1.2、算术运算符
- 1.1.3、关系运算符
- 1.1.4、逻辑运算符
- 1.1.5、赋值运算符
- 1.1.6、关于优先级
- 1.1.7、条件运算符
- 1.1.8、字符串拼接
- 二、控制语句
- 2.2.1、选择语句if
- 2.2.2、选择语句switch
- 2.2.3、循环语句for
- 2.2.4、循环语句while
- 2.2.5、循环语句do.....while
- 2.2.6、转向语句break
- 2.2.7、转向语句continue
- 2.2.8、Scanner类的使用
一、运算符
1.1.1、运算符概述
运算符是指操作数的运算方式。
1.1.2、算术运算符
public class Test02 {
public static void main(String[] args) {
//算术运算符
//加减乘除运算
int a = 10;
int b = 3;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
//3.3333舍弃小数的部分
System.out.println(a / b);
//取模运算 求余数
//10除以3，余1
System.out.println(a % b);
}
}
运行结果
//++ --
//表示：自增1/自减1的运算
int i = 10;
i++;
System.out.println("i= "+i);
int j = 10;
++j;
System.out.println("j= "+j);
/*
++如果是出现在变量的右侧，那么是先执行++所在的表达式，再执行++
表达式int m - k++;
先执行int m = k;(先执行表达式)
再执行K= k +1(后进行自增操作)
++如果是出现现在变量的左侧，name是先执行++，后执行++所在的表达式
表达式 int p = ++o;
先执行o = o+1(先进行自增操作)
再执行int p = o (后执行表达式)
int i = 10;
++i:是i自身的值，自增了1
i+1：i自身的值，不会发生改变
*/
int k = 10;
int m = k++;
System.out.println("k="+ k);//11
System.out.println("m="+ m);//10
int o = 10;
int p = ++o;
System.out.println("o=" + o);//10
System.out.println("p=" + p);//11
}
运行结果
1.1.3、关系运算符
关系运算符主要是完成数据和数据之间的比较，比如：5>3，结果是 true（真），5>10，结果是 false（假）。
public class Test03 {
public static void main(String[] args) {
//关系运算符
int a = 10;
int b = 20;
System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <= b);
System.out.println(a == b);
System.out.println(a != b);
/*
如果==，不是比较数字，而是比较字符串
通过我们现在案例，得到的结论是没有问题的
但是==不是用来比较字符串，将来会出现严重的问题
结论：
虽然我们看到了以下案例使用==比较字符串是好使的
但是也不要这么用
我们将来是使用equals方法对于字符串进行比较
*/
System.out.println("----------------------");
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
}
}
运行结果
1.1.4、逻辑运算符
逻辑运算符主要包括逻辑与（&），逻辑或（|），逻辑异或（^），短路与（&&），短路或（||）。所有逻辑运算符的特点是操作数都是布尔类型，并且最终的运算结果也是布尔类型。
public class Test05 {
public static void main(String[] args) {
/*
&表示与
两侧必须都是true，最终结果才是true
|表示或
两侧，其中有一侧为ture，最终结果就是true
!表示取反
!ture结果为false
!false结果为true
*/
System.out.println((5 > 3) & (5 < 4));
System.out.println((5 > 3) & (5 > 4));
System.out.println((5 > 100) & (5 > 4));
System.out.println(true & true);//true
System.out.println(true & false);//false
System.out.println(true | false);//true
System.out.println(false & false);//false
System.out.println(!true);//false
System.out.println(!false);//true
/*
^表示异或
两侧都是true，最终的结果就是false
两侧都是false，最终的结果就是false
两侧是不一样的取值，最终的结果就是true
使用的比较少，了解
*/
System.out.println("---------------------------");
System.out.println(true ^ false);
System.out.println(false ^ true);
System.out.println(true ^ true);
System.out.println(false ^ false);
/*
逻辑与(&),和 短路与(&&)的区别
逻辑与(&)
&符号两侧表达式都会完整的执行
短路与(&&)
&&符号左侧表达式如果为false，那么最终的结果一定为false
&&符号右侧的部分就没有比较继续执行了
短路或(//)
//符号左侧表达式如果true，那么最终的结果一定为true
//符号右侧的部分就没有必要继续执行了
前提:
m > n && m >n++语句的可读性很差
未来实际项目开发，我们会将上面的语句进行有效的拆解
更重要的是 ++是一种运算，运算参与到了比较当中
所以先运算后比较，还是先比较后运算，读起来很麻烦，需要认为的判断
*/
System.out.println("==========================");
int m = 99;
int n = 100;
System.out.println(m > n & m >n++);
System.out.println(n);//我们看到了101，表示上面的n++执行了
System.out.println("==========================>>>>");
int a = 99;
int b = 100;
System.out.println(a > b && a >b++);
System.out.println(b);//我们看到了100，表示上面的n++没有执行
System.out.println("------------------------->短路");
//短路
int q = 99;
int w = 100;
boolean flag1 = q > w;
w++;
boolean flag2 = q > w;
System.out.println(flag1 & flag2);//false
System.out.println(q > w & q>w++ | 10 >100 && !(q >= n));//false
}
}
运行结果
1.1.5、赋值运算符
赋值运算符目前也是只需要掌握=、+=、-=、=、/=、%=，其它和二进制相关的内容也是到后面遇到的时候再详细学习。赋值类的运算符包括基本赋值运算符（=）和扩展的赋值运算符（+=、-=、=、/=、%=）。
public class Test05 {
public static void main(String[] args) {
//赋值运算符
int i;
i = 10;
System.out.println("i=" + i);
/* int x = 10;
x += 1;//效果 x = x + 1;
x -= 1;//x = x + 1;
x *= 2;
x /= 2;
x %= 3;
System.out.println("x="+ x);*/
//笔试题：小坑
// x += 1;和 x = x + 1;的区别
int x = 10;
x += 1;
x = x + 1;
System.out.println("x=" + x);//12
byte b = 10;
//b = b + 1 ;编译报错，右侧有变量参与byte不再特殊
//需要进行强转
b =(byte)(b+1);
System.out.println(b);//11
byte a = 10;
a += 1;//编译通过
System.out.println(a);//11
/*
从以上案列效果来看
如果我们造作的是int 类型
x += 1;和 x = x + 1;
的效果似是一样的，没有任何区别
但是如果我们操作的是比int小的类型的整数
x += 1;和 x = x + 1;就不一样了
x = x + 1;编译报错，需要强转
x += 1;编译通过
凭什么 x += 1;就不需要强转？
因为使用这种复制运算 +=
如果遇到了需要强转的操作，系统会自动为我们进行转换
对于byte b= 10;
b += 1;
就是相当于 b =(byte)(b+1);系统会帮我们进行强转
*/
}
}
运行结果
1.1.6、关于优先级
1.1.7、条件运算符
条件运算符我们经常称之为三目运算符（三元运算符），它的语法结构是：布尔表达式?表达式1：表达式2。
public class Test06 {
public static void main(String[] args) {
//三目运算符
/*
语法：
布尔表达式？表达式1：表达式2
如果布尔表达式的取值为true，则执行表达式1
如果布尔表达式的取值为false，则执行表达式2
*/
boolean flag1 = true;
int k = flag1 ? 1 : 0;
System.out.println(k);
boolean flag2 = false;
int q = flag2 ? 1 : 0;
System.out.println(q);
int x = 100;
int y = 200;
System.out.println(x==y? "x和y的值相等":"x和y的值不相等");
int x1 = 100;
int y1 = 100;
System.out.println(x1==y1? "x和y的值相等":"x和y的值不相等");
}
}
运行结果
1.1.8、字符串拼接
字符串拼接符的符号就是加号“+”,实际上“+”运算符在java 语言中有两个作用，作用一是对数字进行求和运算，作用二就是字符串连接运算。
public class Test07 {
public static void main(String[] args) {
//字符串拼接运算符 +
int i = 10;
int j = 20;
String s = "abc";
boolean flag = true;
//System.out.println(i+flag+"");//编译报错了
System.out.println(""+i+ flag);
}
}
运行结果
二、控制语句
顺序结构的程序语句只能被执行一次。
如果您想要同样的操作执行多次，就需要使用循环结构。
- Java中有三种主要的循环结构：
- while循环
- do…while循环
- for循环
2.2.1、选择语句if
选择语句又称为分支语句，它通过对给定的条件进行判断，从而决定执行两个或多个分支中的哪一支。因此，在编写选择语句之前，应该首先明确判断条件是什么，并确定当判断结果为“真”或“假”时应分别执行什么样的操作/算法。
我们先看看if语句，if语句的编写方式归纳为以下四种：
如图所示：
public class Test01 {
public static void main(String[] args) {
/*
流程控制
if
*/
/*
案例1：
如果外面下雨了，出门就带一把伞，反之（没下雨），则不带雨伞
如果boolean值为true,则执行if语句体{}中的内容
如果boolean值为false,则不会执行if语句体{}中的内容
if(boolean){
}
如果boolean值为true,则执行if语句体{}中的内容
如果boolean值为false,则执行else语句题{}中的内容
if(boolean){
}else{
}
*/
boolean raining = true;
//如果
if(raining){
System.out.println("外面下雨了，需要带伞");
//否则
}else{
System.out.println("外面没有下雨，不需要要带伞");
}
System.out.println("-------------------------------");
//如果你吃饱了就出门逛街，反之则继续吃东西
boolean eatFull = true;
if(eatFull){
System.out.println("吃饱了，出门逛街");
}else
System.out.println("没吃饱，继续吃饭");
System.out.println("----------------------------------");
/*
案例2：
多重判断
提供一个变量值 int a = 1;
如果变量值a的值为1，则打印这个值为一
如果变量值a的值为2，则打印这个值为二
如果变量值a的值为3，则打印这个值为三
如果变量值a的值不是1,2，3中任何一个数字，则打印：不是想要的数字
*/
/*int a = 3;
if(a == 1){
System.out.println("这个值为1");
}else if(a == 2){
System.out.println("这个值为2");
}else if(a == 3){
System.out.println("这个值为3");
}else{
System.out.println("不是我想要的数字");
}
*/
/*
案例3：
if的嵌套使用
根据以上的案例2，进行后续的判断
如果a的值为1，判断b的值，输入相应的信息
*/
int a = 1;
int b = 1;
if(a == 1){
System.out.println("a的值为1");
if(b ==1){
System.out.println("b的值也是1");
}else{
System.out.println("b的值不是想要的数字");
}
}else if(a == 2){
System.out.println("这个值为2");
}else if(a == 3){
System.out.println("这个值为3");
}else{
System.out.println("不是我想要的数字");
}
System.out.println("--------------------------");
/*
补充：
if语句不加花括号{}，这样的语法也是可以使用的
不加大括号只对下一行产生作用
实际项目开发中对于if语句，要统一的加上{}，可读性强
*/
/*int a1 = 1;
if(a1==1)
System.out.println("a1的值为1");
System.out.println("是我想要的结果");*/
//以上代码等价于
int a1 = 1;
if(a1==1){
System.out.println("a1的值为1");
}
System.out.println("是我想要的结果");
}
}
运行结果
2.2.2、选择语句switch
看下图片switch语句运行原理
switch运行原理文字性描述是这样的，比方说：拿着c和表达式1进行比较，如果相等，则执行语句1，如果不相等，继续拿着c和表达式2进行比较，如果相等，则执行语句2，如果不相等，继续继续…等等（废话文字。。。。）
public class Test02 {
public static void main(String[] args) {
/*
流程控制
switch
需要case语句的后面，加上break;
否则会产生穿透
案例1：判断的值为整数
*/
int a = 2;
switch (a){
case 1:
System.out.println("a的值为1");
break;
case 2:
System.out.println("a的值为2");
break;
case 3:
System.out.println("a的值为3");
break;
default:
System.out.println("失效的数字");
}
/*
案例2：判断的值为字符型
*/
char gender = '男';
switch (gender){
case '男':
System.out.println("男性");
break;
case '女':
System.out.println("女性");
break;
default:
System.out.println("无效的性别");
}
/*
案例3：判断的值为字符串
*/
String gender1 = "1-男";
switch (gender1){
case "1-男":
System.out.println("男性");
break;
case "1-女":
System.out.println("女性");
break;
default:
System.out.println("无效的性别");
}
/*
案例4：switch语句中的case是可以进行合并的
利用的是在没有加break关键词的基础上，case的穿透现象
成绩 100 90 80 70 过关了
成绩60不及格
*/
int score = 80;
switch (score){
case 100:case 90: case 80:
System.out.println("优秀");
break;
case 70:
System.out.println("中等");
break;
case 60:
System.out.println("不及格，继续努力");
break;
default:
System.out.println("你输入无效的成绩");
}
}
}
运行结果
2.2.3、循环语句for
在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，能否继续重复，取决于循环的终止条件。循环结构是在一定条件下反复执行某段程序的流程结构，被反复执行的程序被称为循环体。循环语句是由循环体及循环的终止条件两部分组成的。
语法格式如下图所示：
public class test01 {
public static void main(String[] args) {
//案例1：for循环语法
//输入10行Hello World
//在for循环（）中声明的变量，只能在for循环中
//不能被外部访问到
for(int i = 0; i < 10; i++){
System.out.println("i="+i);
System.out.println("Hello World");
}
//System.out.println("i="+i);
System.out.println("--------------------1");
//想要让for循环中使用的i变量，在for循环的外部也能够访问到
//将i的声明放在for循环的上面
//这种形式虽然可以，但是在实际项目开放中，这样的写法，是不常用的
//for循环体中使用的i变量，一般情况下，需求只能安排i使用在for循环里面，外面几乎不会使用到
//所以我们以后的写法依然是要将i变量的声明写在for（）里面for(int i=0；i<5；i++)
int j = 0;
for( j = 0; j < 10; j++){
System.out.println(j);
System.out.println("Hello World");
}
System.out.println("j="+j);
System.out.println("-------------------2");
//除以以上的做法，我们来看看下面的for循环声明，判断，和改变条件的方式
//这些改变型你换条件的方式可读性差，并且很难预测最终打印出来的信息
for(int k = 10;k > 0;k--){
System.out.println(k);
System.out.println("Hello world");
}
for(int i=10;i>0;i-=2){
System.out.println("h w");
}
for(int i=100;i>0;i/=3){
System.out.println("q w");
}
//补充：关于变量的作用范围
/*
注意观察代码块{}
{}里面声明的变量，外面是访问不到的
外面声明的变量，{}里面是能够访问到的
*/
//{}里面声明的变量，外面是访问不到的
if(true){
int i = 10;
}
//System.out.println(i);外面是访问不到
int i = 10;
if(true){
System.out.println(i);//10
}
System.out.println("----------------------3");
//案例2：for循环的嵌套使用
/*
//外层循环
for(){
//内层循环
for(){
}
}
在内层循环的里面，也可以继续无限的继续嵌套循环
在我们实际项目开发中，对于嵌套的循环，两层是使用最多的
3层for循环，以后的需求非常少，3+层的for循环的需求，如果没有遇到特殊行业的特殊需求，几乎使用不到的
*/
/*
外层循环，循环一次
相当于内层循环完整的执行一次
*/
for(int f=0;f<5;f++){
for(int g=0;g<5;g++){
System.out.println("g="+g);
}
System.out.println("---------------------- f="+f);
}
/*
关于for循环的注意事项：
*/
//（1）for循环中的三个表达式都可以省略不写
//但是分好; 不能省略
//这种情况，会出现无限循环，在IT界管无限循环，也叫做死循环
/* for(;;){
System.out.println(123);
}*/
//(2)当省略表达式1，则会出现编译错误
//解决办法，就是将表达式1，写在for循环的外面
//虽然能解决，但是不要这么写
int y = 0;
for(;y <10; y++){
System.out.println(y);
}
//(3)当省略表达式2
//出现死循环，当省略表达式2的时候，表达式2的位置会默认为我们提供true这个值
/*for(int l=0;;l++){
System.out.println(123);//死循环
}*/
System.out.println("---------------------------4");
//(4)当省略表达式3，同样是死循环
//解决办法：可以将变量的变更直接写在循环体的内部
for(int p=0;p<10;){
System.out.println(123);
p++;
}
}
}
运行结果
运行结果
i=0
Hello World
i=1
Hello World
i=2
Hello World
i=3
Hello World
i=4
Hello World
i=5
Hello World
i=6
Hello World
i=7
Hello World
i=8
Hello World
i=9
Hello World
--------------------1
0
Hello World
1
Hello World
2
Hello World
3
Hello World
4
Hello World
5
Hello World
6
Hello World
7
Hello World
8
Hello World
9
Hello World
j=10
-------------------2
10
Hello world
9
Hello world
8
Hello world
7
Hello world
6
Hello world
5
Hello world
4
Hello world
3
Hello world
2
Hello world
1
Hello world
h w
h w
h w
h w
h w
q w
q w
q w
q w
q w
10
----------------------3
g=0
g=1
g=2
g=3
g=4
---------------------- f=0
g=0
g=1
g=2
g=3
g=4
---------------------- f=1
g=0
g=1
g=2
g=3
g=4
---------------------- f=2
g=0
g=1
g=2
g=3
g=4
---------------------- f=3
g=0
g=1
g=2
g=3
g=4
---------------------- f=4
0
1
2
3
4
5
6
7
8
9
---------------------------4
123
123
123
123
123
123
123
123
123
123
Process finished with exit code 0
2.2.4、循环语句while
循环语句除了for 循环之外还有while 和do…while，接下来我们先来看一下while 循环~，首先学习while 循环的语法结构
如图所示：
执行原理如图：
public class test02 {
public static void main(String[] args) {
/*
while循环
只要()中的boolean的值为true
则会执行循环体中的内容
当()中的loolean的值false
则退出循环体
*/
//需求：打印数字 1,2,3，4,5
int t = 1;
while(t<=5){
System.out.println(t);
t++;
}
//使用while循环，做一个死循环
while(true){
System.out.println(123);
}
}
}
运行结果
2.2.5、循环语句do…while
do…while 循环是while 循环的变形，它们的区别在于do…while 循环可以==保证循环体执行次数至少为1 次，==也就是说 do…while 循环的循环体执行次数是1~N 次，它有点儿先斩后奏的意思，而while 循环的循环体执行次数为0~N 次。
如图所示：
public class test03 {
public static void main(String[] args) {
/*
do....while循环
至少执行一次
先执行do语句块中的信息，再进行while()中的判断
这种循环使用的很少
*/
//需求：打印数字1,2,3,4,5,
int i=1;
do{
System.out.println(i);
i++;
}while (i<=5);
}
}
运行结果
2.2.6、转向语句break
转向语句用于实现循环执行过程中程序流程的跳转，在Java 中转向语句有break 和continue语句。
public class test04 {
public static void main(String[] args) {
/*
break;语句
使用在switch中，是为了防止case的穿透现象
使用在循环体中，是为了终止循环
*/
//案例1：for循环10次，当i的值为5是(如果i的值为5)，终止循环
for(int i=0; i <10; i++){
if(i==5) {
break;
}
System.out.println(i);
}
System.out.println("=========================>1");
//案例2：break使用在嵌套循环中
/*
通过以下测试的结果，可以得到这样的结论
break语句在默认情况下只能终止离它最近的一层循环
不会影响到外层循环完整的执行
*/
for(int q=0;q<10;q++){
for(int w=0;w<10;w++){
if(w==5){
break;
}
System.out.println("w="+w);
}
System.out.println("-----------------q="+q);
}
System.out.println("========================>2");
//如果想要通过break，将外层循环也一并终止
//解决方案：在相应的for关键字的前面加上具体的标识
//break要通过标识来选择退出循环
/* 外层循环，循环一次
相当于内层循环完整的执行一次*/
one:for (int i = 0; i < 10; i++) {
two:for (int j = 0; j < 10; j++) {
if(j==5){
break one;
}
System.out.println("j="+j);//01234
}
System.out.println("---------------- i="+i);// break two循环十次
}
}
}
结果运行
0
1
2
3
4
=========================>1
w=0
w=1
w=2
w=3
w=4
-----------------q=0
w=0
w=1
w=2
w=3
w=4
-----------------q=1
w=0
w=1
w=2
w=3
w=4
-----------------q=2
w=0
w=1
w=2
w=3
w=4
-----------------q=3
w=0
w=1
w=2
w=3
w=4
-----------------q=4
w=0
w=1
w=2
w=3
w=4
-----------------q=5
w=0
w=1
w=2
w=3
w=4
-----------------q=6
w=0
w=1
w=2
w=3
w=4
-----------------q=7
w=0
w=1
w=2
w=3
w=4
-----------------q=8
w=0
w=1
w=2
w=3
w=4
-----------------q=9
========================>2
j=0
j=1
j=2
j=3
j=4
Process finished with exit code 0
2.2.7、转向语句continue
continue 语句也是单个单词自成一条java 语句，例如“continue;”，它和break 语句都是用来控制循环的，break 语句是用来终止循环的执行，而 continue 语句则是用来终止当前本次循环，直接进入下一次循环继续执行。
public class test05 {
public static void main(String[] args) {
/*
continue;语句
终止本次循环，自动跳到下一次循环
*/
//案例：打印整数1~10 ，不打印5
for(int i = 0; i < 10; i++){
if(i==5){
continue;
}
System.out.println(i);
}
}
}
结果运行
2.2.8、Scanner类的使用
Scanner是控制台做运行结果的输出操作。
public class Test01 {
public static void main(String[] args) {
//Scanner类：操作控制台输入的 （以前的System.out是做控制台输出的）
//创建一个控制台输入的对象 s
Scanner s = new Scanner(System.in);
System.out.println("请你输入一个整数");
//System.out.println("=========================>1");
//通过s，调用指定的next方法，来接收指定类型的数据
//将输入的数据，进行接收，赋值给int类型的变量num
int num = s.nextInt();
System.out.println("控制台输入的数据是："+num);
System.out.println("继续输入一个字符串：");
String str = s.next();
System.out.println("你输入的字符串是："+str);
}
}
运行结果
以上内容到这里了，后续。。。