二、运算符及分支结构

在上节课我们讲解了基本数据类型和变量，本节课，我们将讲解运算符及分支结构。
1.运算符
我们将来会通过我们写的代码，做出各种功能强大并且复杂的项目。但是项目再牛，也是由一行一行的代码来组成。那么组成代码的最小单元是什么呢？就是一个个表达式。那么什么是表达式呢？表达式是由操作数和符号组成的式子。
操作数:变量、常量、字面量
变量，就是咱们上节课学习到的，特点是在使用过程中，变量的值可以更改
例如 int a = 10; a就是变量，我们可以在后续将a的值改为其它值；a = 100;
常量，就是值一旦确定，就不可更改
例如 final int a = 10; 此时 a就是常量，它的值只能是10，不能再更改。
字面量，就是按照字面意思理解的数据，例如3，就是字面量。
符号，一般就是指咱们马上要学习的运算符，和数学中的运算符几乎一样。
由这两者构成表达式。
我们常用到的运算符有
1.算术运算符
2.关系运算符
3.逻辑运算符
4.复合运算符
5.位运算符
6.其它运算符
接下来，咱们详细讲解下运算符
1.算术运算符

符号	名称	作用
+	加	进行加法运算
-	减	进行减法运算
*	乘	进行乘法运算
/	除	进行除法运算
%	取模	进行取余数运算

接下来我们通过代码验证下运算符，记得代码还是要写在main方法中，

//等号也是运算符，是赋值运算符，将等号左边的结果，赋值给右边的变量
int a = 10;
int b = 2;
//该表达式就是将a和b的和赋值给变量c，那么c的值就应该是12.
int c = a + b;
/*
  输出c变量的结果，双引号里面的内容原样输出，此处的加号是拼接作用
  没有加双引号的c，会输出c变量的值。所以输出结果就是
   c=12
*/
System.out.println("c = " + c);
/*我们接着尝试其它运算符，由于c变量已将再上面声明过了，所以此处我们直接使用即可。
*/
//此表达式就相当于c = 10 - 2;
c = a - b;
//输出内容为 c = 8
System.out.println("c = " + c);
//乘法
c = a * b;
//输出内容为 c = 20
System.out.println("c = " + c);
//除法
c = a / b;
//输出内容为 c = 5
System.out.println("c = " + c);
//在除法中，如果参与运算的都是整型数，那么除法就是取整
//9和2都是整型数，相除之后，商4余1，此处只取商
c = 9 / 2;
//此时的结果就是 c = 4
System.out.println("c = " + c);
//如果参与运算的有浮点型，那么就是正常除法
//9.0为浮点型，不是整型数
double d = 9.0 / 2;
//此处结果为 d = 4.5
System.out.println("d = " + d);
//取模,实际上就是取余数
//商 5 余 0，取余数，结果为0
c = 10 % 2;
//输出结果为 c = 0
System.out.println("c = " + c);
//商1 余 1.5，所以结果为1.5
d = 4.5 / 3;
//输出结果为 d= 1.5
System.out.println("d = " + d);

2.关系运算符

符号	名称	示例
>	大于号	10 > 5
<	小于号	10 < 5
>=	大于等于号	10 >= 5
<=	小于等于号	10 <= 5
==	等于号	10 == 5
!=	不等于号	10 != 5

关系运算符的结果都是布尔值，因为关系运算符就是表示两个变量或者数字之间的关系，例如 10 > 5 这个表达式成立，所以结果为true;10 < 5 这个表达式不成立，结果为false.
接着咱们通过代码讲解下运算符

int x = 10;
int y = 100;
//小于号  10 < 100,成立
 boolean result = x < y;
//输出结果就是result = true
System.out.println("result = " + result);
//大于号 10 > 100 不成立
result = x > y;
//输出结果就是result = false
System.out.println("result = " + result);
/*
大于等于，意思是说大于或者等于，只要满足其中之一，结果就为true，
如果两者都不满足，结果就为false
*/
result = 5 >= 5;
//输出结果就是result = true,虽然不满足5 > 5,但是满足 5 == 5,所以为true
System.out.println("result = " + result);
//好了，后续的 <=、!=、==自己可以试一试。

我们接着说说关系运算符要注意的点，
例如我们想表示一个变量需要大于5并且小于10，不能像数学中一样写成5 3.逻辑运算符

符号	名称	示例
&&	与	表达式1 && 表达式2
\| \|	或	表达式1 \|\| 表达式2
!	非	!表达式

这里需要注意的就是，逻辑运算符可以连接多个表达式，但是这些表达式的结果必须是布尔值，也可以连接多个值，但是这些值必须是布尔值。逻辑运算的结果也是一个布尔值。
接下来我们通过代码来具体说明用法

/*
  &&,有假即为假.意思是说逻辑与连接的多个表达式，只要有一个表达式的结果
   为假，那么整个表达式的结果就是假;只有当所有表达式的结果为真，最终结果才为真
*/
//10 > 5为真，100 < 7为假，所以整个表达式的结果为假。
boolean result = 10 > 5 && 100 < 7;
//输出结果 result = false
System.out.println("result = " + result);
/*
 &&,也被称之为短路与，意思是说，当逻辑与连接的多个表达式，其中某个表达式为假了，
那么该表达式后面的表达式就不会执行了。
*/
//此处因为10 < 5的结果已经为假，所以该表达式后面的表达式不会再执行。
result = 10 < 5 && 10 > 1 && 100 < 1000;
/*
与之对应的有通路与，&,它和短路与的区别就是，它会执行所有的表达式
*/
//此处即使10 < 5已经为假了，但是后面的表达式还是会执行
result = 10 < 5 & 10 > 1 & 100 < 1000;
/*
不管是通路还是短路,它们最终的结果是一样的。例如上面的表达式，
不管使用&&还是&，它最终的结果都是假
*/
/*
||,逻辑或，有真即为真，意思是连接的多个表达式或者值，只要有一个结果为真，那么整体表达式的结果就是真；
它也可以连接多个表达式，但是每个表达式的结果必须是布尔值,
也可以连接多个值，但是值必须是布尔值
*/
//该表达式中，由于10 > 1为真，所以整个表达式的结果就是真
result = 10 < 5 || 10 > 1 || 100 < 1000;
/*
 ||,也被称之为短路或，意思是说，当逻辑或连接的多个表达式，其中某个表达式为真了，
那么该表达式后面的表达式就不会执行了。
*/
//10 > 1已经为真，所以后面的100 < 1000就不会执行了。
result = 10 < 5 || 10 > 1 || 100 < 1000;
/*
与之对应的有通路或，|,它和短路或的区别就是，它会执行所有的表达式
*/
//此处即使10 > 5已经为真了，但是后面的表达式还是会执行
result = 10 > 5 | 10 > 1 | 100 < 1000;
/*
不管是通路还是短路,它们最终的结果是一样的。例如上面的表达式，
不管使用|还是||，它最终的结果都是真
*/
/*
!,非，就是取反，原来表达式的值为true，那么取反就是false，如果是false,
 取反就是true。所以非作用的表达式的结果必须是布尔值，整个表达式的结果也是一个布尔值
*/
//在运算符中，有括号，先运算括号里面的所以此处会先运行10 > 5 再对结果取反
result = !(10 > 5);
//此处打印结果为false
System.out.println(result);

4.复合运算符

符号	名称	示例
+=	加等	a += 30; 在结果上等同于 a = a + 30;
-=	减等	a -= 30; 在结果上等同于 a = a - 30;
*=	乘等	a = 30; 在结果上等同于 a = a 30;
/=	除等	a /= 30; 在结果上等同于 a = a / 30;
%=	取余等	a %= 30; 在结果上等同于 a = a % 30;

/*
复合运算符就相当于在变量本身数值的基础上，进行运算，将得到的结果再赋值给本身
*/
int a = 10;
//等同于 a = a + 10;在a原有值的基础上再增加10，那么结果就是20
a += 10;
//输出结果就是 a = 20;
System.out.println("a = " + a);
//其它的运算符都是同样的道理，可以自己通过代码感受下。
/*
  接下来我们说说 a += 30;和 a = a + 30的区别
*/
int a = 10;
//整数后面带L，代表该数字为long型，长整型
/*当有多个类型的变量或者值参与运算时，整个表达式的结果以表数范围最大的类型为准，
所有 a + 3L的值的类型为long型，比int表数范围大，所以此处我们需要强制转换.
*/
a = (int)(a + 3L);

//如果我们使用了复合运算符进行运算，它会自己转换类型，不用我们强制转换
a += 3L;
//上面就是两者的区别，虽然结果一样，但是一个需要强制转换，一个不需要

5.位运算符

符号	名称	示例
&	位与	2 & 5的结果是0 ；转换为二进制，按位与，有0即为0
\|	位或	2 \| 5的结果是7；转换为二进制，按位或，有1即为1
<<	左移	2 << 1 的结果是4；转换为二进制，向左移动一位，等同于乘以2
>>	右移	2 >> 1 的结果是 1；转换为二进制，向右移动一位，等同于除以2
^	异或	2 ^ 5的结果是7；转换为二进制，按位异或，不同即为1，相同即为0

位运算符是将数字转换为二进制数据，然后按位进行运算。咱们一个一个看。

  /*
    1.&,按位与，将数值转换为二进制数字，每位上的数字进行与运算，
    有0即为0；如果位数不对应，高位用0补齐。
*/
/*
  此处5转换为二进制是101；2转换为二进制是10；
   所以 5 & 2就是  101 与上 10，由于10比101少一位，高位用0补齐；
   就成了 101 与上010，按位与之后，就变成了 000，所以 最终结果为0
*/
 int a =  5 & 2;
//打印结果为a = 0
System.out.println("a = " + a);
/*
 |，按位或和按位与大同小异，二进制之后，有1即为1；
*/
/*
  就是 101 或上 010，每一位上有1即为1，结果就是111，转换为十进制就是4 + 2 + 1 = 7
*/
a = 5 | 2;
//打印结果为a = 7
System.out.println("a = " + a);
/*
m << n，将m转换为二进制数字，然后左移动n位，等同于m 乘以2的n次幂
*/
/*
将5转换为二进制位101，左移动两位变为 10100，转换为10进制为20，
就相当于 5 乘以 2的2次幂 就是5乘以4等于20
*/
a = 5 << 2;
//打印结果为a = 20
System.out.println("a = " + a);
/*
m >> n，将m转换为二进制数字，然后右移动n位，等同于m 除以2的n次幂，然后取整数部分
*/
/*
将5转换为二进制位101，右移动两位变为 001，转换为10进制为1，
就相当于 5 除以 2的2次幂 就是5除以4，取整数部分为1
*/
a = 5 >> 2;
//打印结果为a = 1
System.out.println("a = " + a);
/*
 ^，按位异或，二进制之后，每一位相同即为0，不同即为1；
*/
/*
  5 ^ 2 就是  101 异或 010 ，按位异或之后，变成了 111, 转换为十进制为 7
*/
a = 5 ^ 2;
//打印结果为a = 7
System.out.println("a = " + 7);

其它运算符

符号	名称	示例
++	自增	a++,相当于在a的基础上加1，然后再赋值给a
--	自减	a--,相当于在a的基础上减1，再赋值给a
? :	三目运算符	表达式 ? 值1 : 值2，如果表达式的值为true，那么整个表达式的值为值1，如果表达式的值为false，那么整个表达式的值为值2

接下来，咱们通过代码来详细说一下

int a = 10;
//等同于 a = a + 1;
a++;
//所以输出为a = 11
System.out.println("a = " + a);
//重新将的值置为10
a = 10;
//等同于 a = a + 1;
++a;
//所以输出为a = 11
System.out.println("a = " + a);
/*
接下来我们说说 ++在前和在后的区别，
通过上面的代码我们看出来，好像在前在后没有区别，结果都是11，
当我们使用++没有参与其它运算时，它两的效果一样；如果参与其它运算
时，++在前，先自身加1，然后参与其它运算；++在后，先参与其它运算，
然后自身再加1.
*/
int m = 10;
/*
这里有自增运算，又有赋值运算，由于++在后，所以先将m赋值给n，那么n的值就是10，
然后m本身再加1，那么 m的值就是11
等同于
int n = m;
m = m + 1;
*/
int n = m++;
//此处打印 n = 10; m = 11 
System.out.println("n = " + n);
System.out.println("m = " + m);

int x = 10;
/*
 此处既有自增运算，又有赋值运算，由于++在前，所以先为x加1，x的值就为11了 ，
然后再赋值给y，所以y的值为11
等同于
x = x + 1;
int y = x;
*/
int y = ++x;
//此处打印 x = 11; y = 11 
System.out.println("x = " + x);
System.out.println("y = " + y);
/*
  只有当参与其它运算时，才需要区分在前在后，如果不参与其它运算，效果一样。
*/
/*
--，自减运算符和自增运算符类似，只是将加1，变为减1即可；
参与其它运算时，--在前，先自减，再参与其它运算；--在后，先参与其它运算，再自减。
可以根据上面的自增代码，自己试试自减运算符，
*/

//三目运算符
//由于表达式 7 > 5的值为true，所有整个表达式的值为冒号前面的值，为7
int i = 7 > 5 ? 7 : 5;
//打印结果为 i = 7;
System.out.println("i = " + i);
//由于表达式 7 < 5的值为false，所有整个表达式的值为冒号后面的值，为100
i = 7 < 5 ? 10 : 100;
//打印结果为 i = 100
System.out.println("i = " + i);

到这里为止，我们的常用运算符就讲解完毕，接下来我们简单说一下运算符的优先级。当有多种运算符时，优先级高的先运算。
一般情况下，算术运算符的优先级高于关系运算符，关系运算符的优先级高于逻辑运算符，逻辑运算符高于赋值运算符；至于每种运算符内部的优先级，可以自己通过代码尝试下。
当然，我们不用死记硬背这个优先级，我们想让那种运算先运算，就加括号即可；例如 int a = 8 + 4 * 5;我们想让8+4先执行，就可以写成 int a = (8 + 4) * 5;
2.分支结构
再说分支结构之前，在这里所以写题外话，不要将编程看成是多高大上的东西，编程无外乎就是通过技术手段来解决现实生活中的问题。话题扯回来，接着说我们的分支结构。
分支结构是用来解决生活中选择性的问题，例如：一个朋友给你打电话说，明天有没有空，去网吧开黑啊！，你想了想，自己还是单身，就回答说，如果你女朋友也去，那我就不去了! 这就是生活中选择的场景，也就是我们分支结构要解决的问题，当满足某个条件，我就做哪些操作，不满足，我就做哪些操作。
在Java中，分支结果一共有两种，一种是if，一种是switch，接下来我们一个一个详细讲解。

2.1 if
if分支的的形式一共以下几种
需要注意的点有:
1.此处的条件可以是表达式或者值，但是最终的运算结果必须是一个布尔值
2.一个分支结构中，一次最多只能执行一个分支

if(条件){
满足条件要执行的代码
}
if(条件){
满足条件会执行的代码
}else{
不满足条件会执行的代码
}
if(条件1){
满足条件1会执行的代码
}else if(条件2){
满足条件2会执行的代码
}else if(条件3){
满足条件3会执行的代码
}
....
else{
以上条件都不满足会执行的代码
}
接下来我们通过代码来举例子

 /*
  1.从控制台输入成绩，当成绩超过90分(包含90)，输出成绩优秀。
*/
//scanner暂时可以理解为，可以从控制台输入内容的工具，后面讲面向对象再具体讲解，只需要创建一次该工具，后续可以重复使用
Scanner scanner = new Scanner(System.in);
//此处只是在输出之前的提示，可以在此内容的下方输入内容，会看到光标在闪烁
System.out.println("请输入成绩:");
/*
    从控制台输入内容，由于是nextInt(),所以只能输入整型数，
然后将输入的值赋值给score，点击回车，结束输入。
*/
int score = scanner.nextInt();
//当你输入的数值比90分大，那就会输出内容，如果没有比90分大，就不会看到任何内容输出到控制台
if(score >= 90) {
  System.out.println("成绩优秀");
}
//上面的验证完毕，就可以把if部分注释掉，然后接着往下写
/*
  当我们输入的值比90大，就会执行if中的代码，否则，就执行else中的代码；
 这里要么执行if中的代码，要么执行else中的代码，不会两个分支中都执行；

*/
if(score >= 90) {
  System.out.println("成绩优秀");
}else{
  System.out.println("成绩不到90分");
}
//验证完毕之后，将if...else代码注释掉，咱们接着
//分数在90-100之间
if(score >= 90 && score <= 100) {
   System.out.println("成绩优秀");
}else if(score >= 80 && score <= 90){
  System.out.println("成绩良好");
}else if(score >= 70 && score <= 80){
  System.out.println("成绩中等");
}else if(score >= 60 && score <= 70){
  System.out.println("成绩及格");
}else if(score < 60){
  System.out.println("你的进步空间很大");
}
/*
满足上述那个条件就会执行该分支中的代码，
这里有人注意到了，如果我输入90，既满足第一个分支，也满足第二个分支，
那么该执行那个分支？还是说两个都执行？此处还是只会执行一个分支，
自上而下，先满足那个条件，就执行该分支中的代码，
下面的分支不会再执行。例如，上面满足了if分支，就不会再执行后续所有的else if。
*/

2.2 switch
switch的形式为:
此处的条件只能是 byte、short、int、char、String、枚举，不能是其它类型的值
前面四种类型咱们都学过了，String类型，实际上就是咱们每次打印内容时，
双引号内容；叫做字符串，后面面向对象部分会详细讲解。

switch(条件){
case 值1:
条件和值1相等时执行的代码
break;
case 值2:
条件和值2相等时执行的代码
break;
....
default:
以上case都不满足时，执行的代码
}
下面我们通过代码来实现下

 /*
此处的案例是我们输入的数字是多少，就输出星期几，如果超出范围
就输出 输入有误
*/
 Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容");
int week = scanner.nextInt();
switch(week){
    case 1:
      System.out.println("星期一");
  break;
   case 2:
       System.out.println("星期二");
  break;
   case 3:
       System.out.println("星期三");
  break;
   case 4:
       System.out.println("星期四");
  break;
   case 5:
       System.out.println("星期五");
  break;
  case 6:
        System.out.println("星期六");
  break;
  case 7:
       System.out.println("星期日");
  break;
 default:
       System.out.println("输入有误");
}
/*
此处你输入的数字在1-7之间，就会输出对应的星期几，如果不在1-7之间，
  就会输出输入有误
*/
/*
  这里，代码执行期间，只有执行到break才会停止，如果没有break，代码会
一直往下执行；例如，case 1:后面没有break，那么当你输入1，就会输出星期一，
星期二，在星期二后面有break，就会停止。
*/

好了，到这为止，我们的本章就结束了

二、运算符及分支结构

你可能感兴趣的:(二、运算符及分支结构)