java--第四章：java语言基础3

亦凉 2023-06-07 10:57 34阅读 0赞

### 1 数据类型中补充的几个小问题 ###

一、在定义Long或者Float变量时，要加L或者F。

整数默认是int类型，浮点数默认是double。

byte，short在定义的时候，他们接收的其实是一个int类型的值，这个是自己做了一个数据监测的，如果不在他们的范围内，就报错。

二、byte值的问题

byte b1 = 127;       
    byte b2 = (byte)128;   //-128
    byte b3 = (byte)129;   //-127
    byte b4 = (byte)130;   //-126

byte的范围：-128~127

128:10000000

-128:10000000(这里的1既是符号位，也是数值位)

三、数据类型之间默认转换

byte,short,char----int----long----float----double

long:8个字节

float:4个字节

A：他们底层的存储结构不同

B：float表示的数据范围比long的范围要大

long:2^63-1

float:3.4\*10^38 > 2\*10^38 >2\*8^38 =2\*2^3^38 =2\*2^114 > 2^63-1

四、java语言中的字符char可以存储一个中文汉字吗？为什么呢？

可以，因为java语言中的字符占用两个字节，java语言采用的是unicode编码。

### 2 运算符 ###

**运算：**对常量和变量进行操作的过程称为运算。

**运算符：**对常量和变量进行操作的符号称为运算符。

**操作数：**参与运算的数据称为操作数。

**运算符的分类：**

A：算数运算符

B：赋值运算符

C：比较运算符

D：逻辑运算符

E：位运算符（了解）

F：三目运算符

### 3 算数运算符： ###

<table>  运算符  
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>正好</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>负号</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>加</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取余</td> 
  </tr> 
  <tr> 
   <td>++</td> 
   <td>自增（前）</td> 
  </tr> 
  <tr> 
   <td>--</td> 
   <td>自减（前）</td> 
  </tr> 
  <tr> 
   <td>++</td> 
   <td>自增（后）</td> 
  </tr> 
  <tr> 
   <td>--</td> 
   <td>自减（后）</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>字符串相加</td> 
  </tr> 
 </tbody> 
</table>

class Operator{
    	public static void main(String[] args){
    		//定义变量
    		int x = 3;//把3赋值给int类型的变量3
    		int y = 4;
    		
    		System.out.println(x+y);//7
    		System.out.println(x-y);//-1
    		System.out.println(x*y);//12
    		System.out.println(x/y);//0 
    		
    		//整数相除只能得到整数,就想得到小数，怎么办？
    		//只需要把操作的数据中任意一个数据变为浮点数
    		System.out.println(x*1.0/y);//0.75
    		
    		//%的应用:取余
    		System.out.println(x%y);//3
    	}
    }

**++和--的使用：**

/*
        ++,--运算符的作用：
           就是对变量进行自增或者自减1
    	   
    	++,--运算符的使用：
    	   一、单独使用：放在操作数的前面和后面效果一样。（这种比较常见）
    	   二、参与运算使用：
    	       放在操作数的前面，先自增或者自减，然后再参与运算。
    		   放在操作数的后面，先参与运算，再自增或者自减。
    */ 
    class Operator2{
    	public static void main(String[] args){
    		//定义两变量
    		int x = 3;
    		int y = 4;
    		
    		//字符串拼接
    		//System.out.println("x:"+x);
    		//System.out.println("y:"+y);
    		//System.out.println("x:"+x+",y:"+y);
    		
    		//单独使用
    		//x++;
    		//y--;
    		++x;
    		--y;
    		//System.out.println("x:"+x+",y:"+y);
    		
    		
    		//参与运算使用
    		int a = 3;
    		int b = 4;
    		
    		//int c = a++;
    		//int d = b--;
    		
    		int c = ++a;
    		int d = --b;
    		
    		System.out.println("a:"+a);//4,4
    		System.out.println("b:"+b);//3,3
    		System.out.println("c:"+c);//3,4
    		System.out.println("d:"+d);//4,3
    		
    		
    	}
    }

**运算符的优先级：**

<table> 
 <tbody> 
  <tr> 
   <td>优先级</td> 
   <td>描述</td> 
   <td>运算符</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>括号</td> 
   <td>()&nbsp; []</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>正负号</td> 
   <td>+&nbsp; - &nbsp;</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>自增自减，非</td> 
   <td>++&nbsp; --&nbsp; !</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>乘除，取余</td> 
   <td>* &nbsp; / &nbsp; %</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>加减</td> 
   <td>+ &nbsp; -</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>移位运算</td> 
   <td>&lt;&lt; &nbsp; &gt;&gt;&nbsp; &gt;&gt;&gt;</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>大小关系</td> 
   <td>&gt;= &nbsp; &gt; &nbsp; &lt; &nbsp; &lt;=</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>相等关系</td> 
   <td>== &nbsp;&nbsp; !=</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>按位与</td> 
   <td>&amp;</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>按位异或</td> 
   <td>^</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>按位或</td> 
   <td>|</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>逻辑与</td> 
   <td>&amp;&amp;</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>逻辑或</td> 
   <td>||</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>条件运算</td> 
   <td>?</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>赋值运算</td> 
   <td>=&nbsp; +=&nbsp; -=&nbsp; *=&nbsp; /= &nbsp; &amp;=</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>位赋值运算</td> 
   <td>&amp;=&nbsp; |= &nbsp; &lt;&lt;= &nbsp; &gt;&gt;=&nbsp; &gt;&gt;&gt;=</td> 
  </tr> 
 </tbody> 
</table>

**++和--的练习：**

//第一题
    int a = 10;
    int b = 10;
    int c = 10;
    
    a = b++;// a=10,b=11,c=10
    c = --a;// c=9,a=9,b=11
    b = ++a;// b=10,a=10,c=9
    a = c--;// a=9,c=8,b=10
    
    //分别求a,b,c的值 a=9,b=10,c=8
    
    //第二题
    int x = 4;
    int y = (x++)+(++x)+(x*10);
    
    //分别求x,y的值 x=6,y=70

**算数运算符 +的用法：**

/*
       +的用法：
       1 加法
       2 负号
       3 字符串拼接符
    */
    class Operator3{
    	public static void main(String[] args){
    		//加法
    		System.out.println(3+4);
    		
    		//正号
    		System.out.println(+4);
    		
    		//字符串拼接符
    		System.out.println('a'+1);//98
    		System.out.println("hello"+'a'+1);//helloa1
    		System.out.println('a'+1+"hello");//98hello
    	}
    }

### 4 赋值运算符 ###

**基本的赋值运算符：**=

**扩展的赋值运算符：**\+=   -=   \*=   /=   %=

class Operator{
    	public static void main(String[] args){
    		//定义一个变量
    		int x = 10;
    		
    		//其他用法
    		int a,b;
    		a  = b = 10;//这种写法不推荐
    		//System.out.println(a);
    		//System.out.println(b);
    		
    		//定义变量
    		int  y = 10;
    		y += 20;
    		//System.out.println(y);
    		
    		/* 
    		  面试题：
    		        short s=1,s=s+1;short s=1,s+=1;
    				上面两代码有没有问题，如果有，哪里有问题
    				
    				为什么第二个没有问题呢？
    				扩展的赋值运算符其实隐含了一个强制类型转换。
    				
    				s+=1;
    				不是等价于 s = s+1;
    				而是等价于 s = (s的数据类型)(s+1);
    		*/
    		
    		//short s=1;
    		//s=s+1;
    		//System.out.println(s);//有可能会损失精度
    		
    		
    		short s=1;
    		s+=1;
    		System.out.println(s);
    	}
    }

### 5 比较运算符 ###

<table>  比较运算符  
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>等于</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>大于</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于</td> 
  </tr> 
  <tr> 
   <td>instanceof</td> 
   <td>检测是否是类的对象</td> 
  </tr> 
 </tbody> 
</table>

注意：

A：比较运算符的结果都是boolean型，不是true，就是false

B：比较运算符"=="不能误写成"="

class Operator{
    	public static void main(String[] args){
    		int x = 3;
    		int y = 4;
    		int z = 5;
    		
    		System.out.println(x==y);//false
    		System.out.println((x+y)==(x+z));//false
    		System.out.println(x!=y);//true
    		System.out.println(x>y);//false
    		System.out.println(x>=y);//false
    		System.out.println(x<y);//true
    		System.out.println(x<=y);//true
    		
    		int a = 10;
    		int b = 20;
    		
    		//boolean flag = (a == b);
    		//boolean flag = (a = b);//这个是有问题的，不兼容的类型
    	}
    }

### 6 逻辑运算符 ###

<table>  逻辑运算符  
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>与（并且）有假即假</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>或（或者）有真即真</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>异或</td> 
  </tr> 
  <tr> 
   <td>!</td> 
   <td>非（不是）非false即true，非true即false，偶数个不改变。</td> 
  </tr> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>双与</td> 
  </tr> 
  <tr> 
   <td>||</td> 
   <td>双或</td> 
  </tr> 
 </tbody> 
</table>

逻辑运算符用于连接布尔型表达式，在java中不可以写成3<x<6,应该写成x>3 & x<6

**表达式：**就是用运算符把变量或者常量连接起来的符合java语法的式子。

**& 和 &&的区别：**

A：单&时，左边无论真假，右边都参与运算

B：双&时，如果左边为真，右边参与运算；如果左边为假，那么右边不参与运算（因为有false即false，所以就不用执行右边的了）

**|和 ||的区别：**同理，双或时，左边为真，右边不参与运算（因为有true即true，所以就不用执行右边的了）

**异或(^)和或(|)的区别：**相同为false，不同为true

class Operator{
    	public static void main(String[] args){
    		int a = 3;
    		int b = 4;
    		int c = 5;
    		
    		//&
    		System.out.println((a > b) & (a > c) );//false & false => false
    		System.out.println((a > b) & (a < c) );//false & true => false
    		System.out.println((a < b) & (a > b) );//true & false => false
    		System.out.println((a < b) & (a < b) );//true & true => true
    		
    		//|
    		System.out.println((a > b) | (a > c) );//false & false => false
    		System.out.println((a > b) | (a < c) );//false & true => true 
    		System.out.println((a < b) | (a > b) );//true & false => true
    		System.out.println((a < b) | (a < b) );//true & true => true
    		
    		//^
    		System.out.println((a > b) ^ (a > c) );//false & false => false
    		System.out.println((a > b) ^ (a < c) );//false & true => true 
    		System.out.println((a < b) ^ (a > b) );//true & false => true
    		System.out.println((a < b) ^ (a < b) );//true & true => false
    		
    		//!
    		System.out.println(!(a > b));//!false => true
    		System.out.println(!(a < b));//!true => false
    		
    		System.out.println(!!(a > b));//!!false => false
    		System.out.println(!!!(a > b));//!!!false => true
    	}
    }

**& 和 &&的区别：**

class Operator2{
    	public static void main(String[] args){
    		int a = 3;
    		int b = 4;
    		int c = 5;
    		
    		//&&
    		System.out.println((a > b) && (a > c) );//false & false => false
    		System.out.println((a > b) && (a < c) );//false & true => false
    		System.out.println((a < b) && (a > b) );//true & false => false
    		System.out.println((a < b) && (a < b) );//true & true => true
    		
    		int x = 3;
    		int y = 4;
    		
    		//boolean b1 = (x++ == 3 & y++ ==4); //4,5,true
    		//boolean b1 = (x++ == 3 && y++ ==4); //4,5,true
    		//boolean b1 = (++x == 3 & y++ ==4); //4,5,false
    		boolean b1 = (++x == 3 && y++ ==4); //4,4,false
    		System.out.println("x:"+x);
    		System.out.println("y:"+y);
    		System.out.println(b1);
    	}
    }

### 7 位运算符（不需要掌握） ###

<table>  位运算符  
 <tbody> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;&gt;</td> 
   <td>无符号右移</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>按位与运算（有0则0）</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>按位或运算（有1则1）</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>按位异或运算（相同则0，不同则1）</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>按位取反（0变1，1变0）</td> 
  </tr> 
 </tbody> 
</table>

位运算是直接对二进制进行运算。

要做位运算，首先要把数据转换为二进制。

class Operator{
    	public static void main(String[] args){
    		//&,|,^,~
    		//当它们两边是布尔值时，做的是逻辑运算；当两是数据时，做的是位运算
    		
    		int a = 3;
    		int b = 4;
    		
    		System.out.println(3 & 4);//0
    		System.out.println(3 | 4);//7
    		System.out.println(3 ^ 4);//7
    		System.out.println(~3);//-4
    	}
    }
    /*
       分析：因为是位运算，所以我们必须先把数据换算成二进制：
        3的二进制：11
          00000000 00000000 00000000 00000011
        4的二进制：100
          00000000 00000000 00000000 00000100
        &位与运算：有0则0
    	00000000 00000000 00000000 00000011
    	00000000 00000000 00000000 00000100
    	-----------------------------------
    	结果是：0
    	
    	|位或运算：有1则1
    	00000000 00000000 00000000 00000011
    	00000000 00000000 00000000 00000100
    	-----------------------------------
    	结果是：7
    	
    	^位异或运算：相同则0，不同则1
    	00000000 00000000 00000000 00000011
    	00000000 00000000 00000000 00000100
    	-----------------------------------
    	结果是：7
    	
    	~按位取反运算符：0变1,1变0
    	00000000 00000000 00000000 00000011
       ~11111111 11111111 11111111 11111100(补码)
    	补码：11111111 11111111 11111111 11111100
    	反码：11111111 11111111 11111111 11111011
    	原码：10000000 00000000 00000000 00000100
    	结果：-4
    	
       
    */

**^的特点：**

一个数据对另一个数据异或两次，该数不变。

class Operator2{
    	public static void main(String[] args){
    		int a = 10;
    		int b = 20;
    		
    		System.out.println(a ^ b ^ b);//10
    		System.out.println(a ^ b ^ a);//20
    	}
    }

**位运算的面试题1：**

/*
      面试题1：请自己实现两整数变量的交换。
      （默认数据的类型为int）
    */
    class Operator3{
    	public static void main(String[] args){
    		int a = 10;
    		int b = 20;
    		
    		System.out.println("a:"+a+",b:"+b);
    		
    		//方式1：使用第三方变量（开发中用）
    		/*
    		int c = a;
    		a = b;
    		b = c;
    		System.out.println("a:"+a+",b:"+b);
    		*/
    		
    		//方式2：用按位异或实现
    		//左边:a,b,a
    		//右边：a^b
    		/*
    		a = a ^ b;
    		b = a ^ b;//b = a ^ b ^ b = a
    		a = a ^ b;//a = a ^ b ^ a = b
    		System.out.println("a:"+a+",b:"+b);
    		*/
    		
    		//方式3：用变量相加的做法
    		/*
    		a = a + b;
    		b = a - b;//b=a+b-b=a
    		a = a - b;//a=a+b-a=b
    		System.out.println("a:"+a+",b:"+b);
    		*/
    		
    		//方式4：一句话搞定
    		b = (a + b) - (a = b);//b=30-20=10,a=20
    		System.out.println("a:"+a+",b:"+b);
    	}
    }

**左移，右移，无符号右移用法以及面试题2：（视频不好）**

<<:左移，左边最高位丢弃，右边补齐0

>>:右移，最高位是0，左边补齐0；最高位是1，左边补齐1

>>>:无符号右移，最高位无论是0还是1，空缺位都用0补齐

/* 
      面试题：请用最有效率的方法计算2乘以8的结果
      2*2^3
    */
    
    class Operator4{
    	public static void main(String[] args){
    		//<<把<<左边的数据乘以2的移动次幂
    		System.out.println(3 << 2);//3*2^2 = 12;
    		
    		//>>把>>左边的数据除以2的移动次幂
    		System.out.println(24 >> 2);//24/2^2 = 6;
    	}
    }
    /*
      计算出3的二进制：11
      00000000 00000000 00000000 00000011
      (00)000000 00000000 00000000 0000001100
      
      计算出24的二进制：11000
      原码：10000000 00000000 00000000 00011000
      反码：11111111 11111111 11111111 11100111
      补码：11111111 11111111 11111111 11101000
    */

### 8 三目运算符/三元运算符 ###

单目运算符：~3

双目运算符：3 + 4

**三目运算符格式：**

（条件表达式）? 表达式1：表达式2

如果条件为true，运算后的结果是表达式1；

如果条件为false，运算后的结果是表达式2.

class Operator{
    	public static void main(String[] args){
    		int x = 100;
    		int y = 200;
    		
    		int z = (x > y) ? x : y;
    		
    		System.out.println(z);//200
    	}
    }

**练习：**

/*
      练习：
      获取两个整数中的最大值
      获取三个整数中的最大值
      比较两整数是否相同
    */
    
    class Operator2{
    	public static void main(String[] args){
    		//获取两个整数中的最大值
    		int x = 100;
    		int y = 200;
    		int max = (x > y) ? x : y;
    		
    		System.out.println(max);//200
    		
    		//获取三个整数中的最大值
    		int a = 10;
    		int b = 20;
    		int c = 30;
    		
    		//分两步，先比较a,b的最大值，再拿a,b的最大值和c进行比较
    		int temp = (a > b) ? a : b;
    		int max1 = (temp > c) ? temp : c;
    		System.out.println(max1);
    		
    		//一步搞定
    		//int max2 = (a > b )? ((a > c)?a:c):((b > c)?b:c);
    		int max2 = a > b? a > c?a:c:b > c?b:c;
    		System.out.println(max2);
    		
    		//比较两整数是否相同
    		int m = 10;
    		int n = 20;
    		
    		boolean flag = (m==n);
    		System.out.println(flag);
    	}
    }

### 9 键盘录入 ###

**键盘录入数据概述：**

我们目前在写程序的时候，数据值都是固定的。但是实际开发中，数据值肯定是变化的。所以，我准备把数据改进为键盘录入，提高程序的灵活性。

**如何实现键盘录入数据呢？**

导包（位置放到class上面）:import java.util.Scanner;

创建对象：Scanner sc=new Scanner(System.in);

接收数据：int x=sc.nextInt();

import java.util.Scanner;//第一步
    
    //这里的类名不能设置为Scanner，会与上面导入的重名
    class ScannerDemo{
    	public static void main(String[] args){
    		//第二步：创建键盘录入对象
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请你输入一个数据：");
    		
    		//第三步：通过对象获取数据
    		int x=sc.nextInt();
    		System.out.println("你输入的数据是："+x);
    	}
    }

**键盘录入的练习1：**

/*
      键盘录入两个数据，并对这两数据求和，输出其结果
      键盘录入两个数据，获取这两个数据中的最大值
      键盘录入三个数据，获取这三个数据中的最大值
      键盘录入两个数据，比较这两数据是否相等
    */
    import java.util.Scanner;
    
    class ScannerTest{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		//键盘录入两个数据，并对这两数据求和，输出其结果
    		System.out.println("请你输入第一个数据：");
    		int x=sc.nextInt();
    		
    		System.out.println("请你输入第二个数据：");
    		int y=sc.nextInt();
    		
    		int sum = x + y;
    		System.out.println("sum:"+sum);
    		
    		//键盘录入两个数据，获取这两个数据中的最大值
    		System.out.println("请你输入第一个数据：");
    		int a=sc.nextInt();
    		
    		System.out.println("请你输入第二个数据：");
    		int b=sc.nextInt();
    		
    		int max = a > b ? a : b;
    		System.out.println("max:"+max);
    		
    	}
    }

### 10 流程控制 ###

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的，也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程，而且，很多时候，我们要通过控制语句的执行顺序来实现我们要完成的功能。

**流程控制语句分类：**

A:顺序结构

B:选择结构

C:循环结构

**顺序结构概述：**

是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行。程序中大多数的代码都是这样执行的。总的来说，就是写在前面的先执行，写在后面的后执行。

lass ShunXu{
    	public static void main(String[] args){
    		System.out.println("程序开始了");
    		
    		System.out.println("我爱java");
    		
    		System.out.println("程序结束了");
    	}
    }

### 11 选择结构 ###

也被称之为分支结构。

选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

java语言提供了两种选择结构语句：if和switch

**if语句格式1：**

if(关系表达式)\{

语句体

首先判断关系表达式结果是true还是false，是true就执行语句体，是false就不执行语句体。

class IfDemo{
    	public static void main(String[] args){
    		int x = 10;
    		
    		if(x==10){
    			System.out.println("x等于10");
    		}
    		
    		if(x==20){
    			System.out.println("x等于20");
    		}
    		
    		System.out.println("over");
    	}
    }

** 注意事项：**

A：关系表达式无论是简单还是复杂，结果必须是boolean

B：if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。

C：一般来说，有坐大括号就没有分号，有分号就没有左大括号。

class IfDemo2{
    	public static void main(String[] args){
    		int x=10;
    		if(x==10){
    			System.out.println("x等于10");
    		}
    		
    		if(x>5 || x==10){
    			System.out.println("x大于或等于10");
    		}
    		
    		int a = 100;
    		
    		if(a!=100)
    			System.out.println("a等于100");
    		    System.out.println("over");//这条不执行
    		
    		int b = 100;
    		
    		if(b!=100);//这里其实是有语句体的，只不过是空语句体
    		
    		//下面被称为代码块
    		{
    			System.out.println("b等于100");
    		    System.out.println("over");
    	}	}
    }

**if语句格式2：**

if(关系表达式)\{

语句体1；

\}else\{

语句体2；

首先判断关系表达式结果是true还是false，是true就执行语句体1，是false就执行语句体2。

class IfDemo3{
    	public static void main(String[] args){
    		int a = 10;
    		int b = 20;
    		
    		if(a==b){
    			System.out.println("a等于b");
    		}else{
    			System.out.println("a不等于b");
    		}
    	}
    }

**练习：**

/*
       获取两数据中较大值
       判断一个数据是奇数还是偶数并输出
    */
    import java.util.Scanner;
    
    class IfDemo4{
    	public static void main(String[] args){
    		Scanner sc = new Scanner(System.in);
    		
    		//获取两数据中较大值
    		System.out.println("请输入第一个数据：");
    		int a = sc.nextInt();
    		
    		System.out.println("请输入第二个数据：");
    		int b = sc.nextInt();
    		
    		int max;
    		
    		if(a>b){
    			max = a;
    		}else{
    			max = b;
    		}
    		
    		System.out.println("max:"+max);
    		
    		//判断一个数据是奇数还是偶数并输出
    		System.out.println("请输入你要判断的数据：");
    		int x = sc.nextInt();
    		
    		if(x%2==0){
    			System.out.println(x+"这个数据是偶数");
    		}else{
    			System.out.println(x+"这个数据是奇数");
    		}
    	}
    }

** if语句格式2和三元的相互转换问题：**

由于if语句的第二种格式刚才也完成了三元运算符可以完成的效果，所以我们就认为他们可以完成一样的操作。但是他们就一点区别都没有吗？不是的。

区别：

三元运算符实现的都可以使用if语句实现，反之不成立。

什么时候if语句实现不能用三元实现呢？当if语句控制的操作是一个输出语句的时候就不行。为什么呢？因为三元运算符是一个运算符，运算符操作完应该有一个结果，而不是一个输出。

class IfDemo5{
    	public static void main(String[] args){
    		//获取两数据的最大值
    		int a = 10;
    		int b = 20;
    		
    		int max1;
    		
    		//用if语句实现
    		if(a>b){
    			max1 = a;
    		}else{
    			max1 = b;
    		}
    		System.out.println("max1:"+max1);
    		
    		//用三元实现
    		int max2 = (a>b)?a:b;
    		System.out.println("max2:"+max2);
    		
    		//判断一个数据是奇数还是偶数，并且输出出来
    		int x = 100;
    		
    		//if实现
    		if(x%2==0){
    			System.out.println("x是一个偶数");
    		}else{
    			System.out.println("x是一个奇数");
    		}
    		
    		//三元实现
    		//这种改进是错误的
    		String s = (x%2==0)?System.out.println("x是一个偶数");:System.out.println("x是一个奇数");
    	}
    }

**if语句格式3：**

if(关系表达式)\{

语句体1；

\}else if(关系表达式2)\{

语句体2；

...

else\{

语句体n+1；

import java.util.Scanner;
    
    class IfDemo6{
    	public static void main(String[] args){
    		//键盘录入一个成绩，判断并输出成绩的等级
    		/*
    		   90-100 优秀
    		   80-90  好
    		   70-80  良
    		   60-70  及格
    		   0-60   不及格
    		*/
    		
    		Scanner sc = new Scanner(System.in);
    		
    		System.out.println("请输入你的考试成绩:");
    		int score = sc.nextInt();
    		
    		/*
    		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{
    			System.out.println("不及格");
    		}
    		*/
    		
    		//这样写可以满足基本要求，可能别人在使用的时候不按照你要求的数据给出。
    		//在做一个程序的基本测试的时候，一定要考虑这样的几个问题：
    		//正确数据，错误数据，边界数据
    		//刚才写的程序并没有处理错误数据，所以这个程序不是很好，需要改进
    		
    		/*
    		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>=0 && score <60){
    			System.out.println("不及格");
    		}else{
    			System.out.println("你输入的成绩有误");
    		}
    		*/
    		
    		//另一种改进
    		if(score<0 || score>100){
    			System.out.println("你输入的成绩有误");
    		}else 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{
    			System.out.println("不及格");
    		}
    	}
    }

** **三种if语句分别适合做什么事情呢？

格式1：适合做单个判断

格式2：适合做两个判断

格式3：适合做多个判断

**练习1：**

/*
       需求：键盘录入x的值，计算出y的值并输出
       x>=3 y=2x+1;
       -1<=x<3 y=2x;
       x<-1 y=2x-1;
    */
    import java.util.Scanner;
    class IfDemo7{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入x的值：");
    		int x=sc.nextInt();
    		
    		int y;
    		//用if语句进行判断
    		if(x>=3){
    			y=2*x+1;
    		}else if(x>=-1 && x<3){
    			y=2*x;
    		}else{
    			y=2*x-1;
    		}
    		
    		System.out.println("y:"+y);
    	}
    }

**练习2：**

/*
       键盘录入月份的值，并输出对应的季节
       春3,4,5
       夏6,7,8
       秋9,10,11
       冬12,1,2
    */
    import java.util.Scanner;
    
    class IfDemo8{
    	public static void main(String[] args){
    		Scanner sc = new Scanner(System.in);
    		
    		System.out.println("请你输入一个月份：");
    		int month = sc.nextInt();
    		
    		/*
    		if(month<1 || month >12){
    			System.out.println("你输入的月份有误");
    		}else if(month==1){
    			System.out.println("冬季");
    		}else if(month==2){
    			System.out.println("冬季");
    		}else if(month==3){
    			System.out.println("春季");
    		}else if(month==4){
    			System.out.println("春季");
    		}else if(month==5){
    			System.out.println("春季");
    		}else if(month==6){
    			System.out.println("夏季");
    		}else if(month==7){
    			System.out.println("夏季");
    		}else if(month==8){
    			System.out.println("夏季");
    		}else if(month==9){
    			System.out.println("秋季");
    		}else if(month==10){
    			System.out.println("秋季");
    		}else if(month==11){
    			System.out.println("秋季");
    		}else{
    			System.out.println("冬季");
    		}
    		*/
    		
    		//这个程序确实是符合了需求，但是看起来比较麻烦，那么我们是不是可以改进一下
    		/*
    		if(month<1 || month >12){
    			System.out.println("你输入的月份有误");
    		}else if(month==1 || month==2){
    			System.out.println("冬季");
    		}else if(month==3 || month==4 || month==5){
    			System.out.println("春季");
    		}else if(month==6 || month==7 || month==8){
    			System.out.println("夏季");
    		}else if(month==9 || month==10 || month==11){
    			System.out.println("秋季");
    		}else{
    			System.out.println("冬季");
    		}
    		*/
    		//这个时候，程序代码已经可以了。假如要求你输入一个月份，判断是上半年还是下半年
    		//这个时候，我们的判断条件连就是6个boolean表达式，也比较麻烦，用范围也可以改进
    		if(month<1 || month >12){
    			System.out.println("你输入的月份有误");
    		}else if(month>=3 && month<=5){
    			System.out.println("春季");
    		}else if(month>=6 && month<=8){
    			System.out.println("夏季");
    		}else if(month>=9 && month<=11){
    			System.out.println("秋季");
    		}else{
    			System.out.println("冬季");
    		}
    	}
    }

if语句的使用场景：

A：针对表达式是一个boolean类型的判断

B：针对一个范围的判断

**if语句的嵌套使用练习：**

class IfDemo9{
    	public static void main(String[] args){
    		//获取三个数值中的最大值
    		int a = 10;
    		int b = 20;
    		int c = 30;
    		
    		int max;
    		if(a>b){
    			if(a>c){
    				max=a;
    			}else{
    				max=c;
    			}
    		}else{
    			if(b>c){
    				max=b;
    			}else{
    				max=c;
    			}
    		}
    		
    		System.out.println("max:"+max);
    	}
    }