Java基础-03.总结运算符、键盘录入、if语句

  1. 云栖社区>
  2. 博客>
  3. 正文

Java基础-03.总结运算符、键盘录入、if语句

奋斗蒙 2016-11-24 10:25:00 浏览1259
展开阅读全文

你需要的是什么,直接评论留言。

获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦)

还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读

学习交流请加Java帮帮交流QQ群553841695

分享是一种美德,分享更快乐!

1:运算符(掌握)
(1)算术运算符
A:+,-,*,/,%,++,--
B:+的用法
a:加法
b:正号
c:字符串连接符
C:/和%的区别
数据做除法操作的时候,/取得是商,%取得是余数
5/3=1
5%3=2
-5%3=-2;
-5%-3=-2;
/*
运算符:
就是对常量和变量进行操作的符号。

分类:算术运算符,赋值运算符,比较运算符,逻辑运算符,位运算符,三目运算符


算术运算符:
+,-,*,/,%,++,--

注意事项:
A:整数相除只能得到整数。如果想得到小数,必须把数据变化为浮点数类型
B:/获取的是除法操作的商,%获取的是除法操作的余数
*/


class OperatorDemo {
public static void main(String[] args) {
//定义变量
int x = 3;  //把3赋值给int类型的变量x
int y = 4;

System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y); //整数相除只能得到整数

//我就想得到小数,该肿么办呢?
//只需要把操作的数据中任意的一个数据变为浮点数
System.out.println(x*1.0/y);

//%的应用
System.out.println(x%y); //得到的是余数
}
}

D:++和--的用法
a:他们的作用是自增或者自减
b:使用
**单独使用
放在操作数据的前面和后面效果一样。
a++或者++a效果一样。


”开发多用++a“


**参与操作使用
放在操作数的前面:先自增或者自减,再参与操作
int a = 10;
int b = ++a;
放在操作数的后面:先参与操作,再自增或者自减
int a = 10;
int b = a++;
/*
++,--运算符的使用:
单独使用:
放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
参与运算使用:
放在操作数的前面,先自增或者自减,然后再参与运算。
放在操作数的后面,先参与运算,再自增或者自减。

作用:就是对变量进行自增1或者自减1。
*/
class OperatorDemo2 {
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);
System.out.println("x:"+x+",y:"+y);

//意外的类型,常量是不可以这样做的
//System.out.println(10++);

System.out.println("-------------------");
//参与运算使用
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
}
}


/*
++,--的练习题

第一题:
int a = 10;
int b = 10;
int c = 10;


a = b++;
c = --a;
b = ++a;
a = c--;
请分别计算出a,b,c的值

第二题:
int x = 4;
int y = (x++)+(++x)+(x*10);
请分别计算出x,y的值
*/
class OperatorTest {
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 10;


a = b++; //a=10,b=11,c=10
c = --a; //a=9,b=11,c=9
b = ++a; //a=10,b=10,c=9
a = c--; //a=9,b=10,c=8

System.out.println("a:"+a);
System.out.println("b:"+b);
System.out.println("c:"+c);
System.out.println("--------------");

int x = 4;
int y = (x++)+(++x)+(x*10);
//4+6+60
//x=5,6

System.out.println("x:"+x);
System.out.println("y:"+y);
}
}
/*   扩展:
 +的用法:
A:加法
B:正号
C:字符串连接符
*/
class OperatorDemo3 {
public static void main(String[] args) {
//加法
System.out.println(3+4);

//正号
System.out.println(+4);

System.out.println('a');
System.out.println('a'+1); //这里是加法

//字符串连接符
System.out.println("hello"+'a'+1);
System.out.println('a'+1+"hello");
}
}


(2)赋值运算符
A:=,+=,-=,*=,/=,%=等
B:=叫做赋值运算符,也是最基本的赋值运算符
int x = 10; 把10赋值给int类型的变量x。
C:扩展的赋值运算符的特点
隐含了自动强制转换。
+=:把左边的数和右面的数进行相加,然后在赋值给左边的变量。
左边必须是一个变量。

面试题:
short s = 1;
s = s + 1;

short s = 1;
s += 1;
请问上面的代码哪个有问题?
/*
赋值运算符:
基本的赋值运算符:=
把=右边的数据赋值给左边。

扩展的赋值运算符:+=,-=,*=,/=,%=
+= 把左边和右边做加法,然后赋值给左边。
*/
class OperatorDemo {
public static void main(String[] args) {
//定义一个变量
int x = 10;

//其他用法
int a,b; 
a = b = 10;
System.out.println(a); 
System.out.println(b);
System.out.println("-----------");


//定义一个变量
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);
*/
class OperatorTest {
public static void main(String[] args) {
//short s = 1;
//s = s + 1;
//System.out.println(s);

short s = 1;
s += 1; //好像是 s = s + 1;
System.out.println(s);
}
}


(3)比较运算符
A:==,!=,>,>=,<,<=
B:无论运算符两端简单还是复杂最终结果是boolean类型。
C:千万不要把==写成了=
/*
比较运算符:
==,!=,>,>=,<,<=

特点:
无论你的操作是简单还是复杂,结果是boolean类型。

注意事项:
"=="不能写成"="。
*/
class OperatorDemo {
public static void main(String[] args) {
int x = 3;
int y = 4;
int z = 3;

System.out.println(x == y);
System.out.println(x == z);
System.out.println((x+y) == (x+z));
System.out.println("------------");

System.out.println(x != y);
System.out.println(x > y);
System.out.println(x >= y);
System.out.println(x < y);
System.out.println(x <= y);
System.out.println("------------");

int a = 10;
int b = 20;

//boolean flag = (a == b);
//boolean flag = (a = b); //这个是有问题的,不兼容的类型
//System.out.println(flag);

int c = (a = b); //把b赋值给a,然后把a留下来
System.out.println(c);
}
}


(4)逻辑运算符
A:&,|,^,!,&&,||
B:逻辑运算符用于连接boolean类型的式子
C:结论
&:有false则false
|:有true则true
^:相同则false,不同则true。
情侣关系。
!:非true则false,非false则true

&&:结果和&是一样的,只不过有短路效果。左边是false,右边不执行。
||:结果和|是一样的,只不过有短路效果。左边是true,右边不执行。


/*
逻辑运算符:
&,|,^,!
&&,||

特点:
逻辑运算符一般用于连接boolean类型的表达式或者值。

表达式:就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式:a + b
比较表达式:a == b

结论:
&逻辑与:有false则false。 有0则0
|逻辑或:有true则true。   有1则1
^逻辑异或:相同为false,不同为true。
举例:情侣关系。男男,男女,女男,女女
!逻辑非:非false则true,非true则false。
特点:偶数个不改变本身。
*/
class OperatorDemo {
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 > c)); //true & false = false
System.out.println((a < b) & (a < c)); //true & true = true
System.out.println("---------------");

//|逻辑或
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 > c)); //true | false = true
System.out.println((a < b) | (a < c)); //true | true = true
System.out.println("---------------");

//^逻辑异或
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 > c)); //true ^ false = true
System.out.println((a < b) ^ (a < c)); //true ^ true = false
System.out.println("---------------");

//!逻辑非
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
}
}


/*
&&和&的区别? 同理||和|的区别?
A:最终结果一样。
B:&&具有短路效果。左边是false,右边不执行。

开发中常用的逻辑运算符:
&&,||,!
*/
class OperatorDemo2 {
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 > c)); //true && false = false
System.out.println((a < b) && (a < c)); //true && true = true
System.out.println("----------------");

int x = 3;
int y = 4;

//boolean b1 = ((x++ == 3) & (y++ == 4));
//boolean b1 = ((x++ == 3) && (y++ == 4));
//boolean b1 = ((++x == 3) & (y++ == 4));
boolean b1 = ((++x == 3) && (y++ == 4));
System.out.println("x:"+x);
System.out.println("y:"+y);
System.out.println(b1);
}
}


(5)位运算符(了解)
A:^的特殊用法
一个数据针对另一个数据位异或两次,该数不变
a^b^a得到b
B:面试题
a:请实现两个变量的交换
**采用第三方变量
**用位异或运算符
左边a,b,a
右边a^b
b:请用最有效率的方式计算出2乘以8的结果
2<<3  2(2的3次幂)
位运算符:
&,|,^,~
<<,>>,>>>
>>>:得到都是正数

<<:左移 左边最高位丢弃,右边补齐0
>>:右移 最高位是0,左边补齐0;最高为是1,左边补齐1
>>>:无符号右移 无论最高位是0还是1,左边补齐0
/*
位运算符:
&,|,^,~
<<,>>,>>>
>>>:得到都是正数

注意:
要做位运算,首先要把数据转换为二进制。
*/
class OperatorDemo {
public static void main(String[] args) {
//&,|,^,~

int a = 3;
int b = 4;

System.out.println(3 & 4);
System.out.println(3 | 4);
System.out.println(3 ^ 4);
System.out.println(~3);
}
}
/*
分析:因为是位运算,所以我们必须先把数据换算成二进制。

3的二进制:11
00000000 00000000 00000000 00000011
4的二进制:100
00000000 00000000 00000000 00000100

&位与运算:有0则0。
00000000 00000000 00000000 00000011
  &00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000000
结果是:0

|位或运算:有1则1。
00000000 00000000 00000000 00000011
  |00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是:7

^位异或运算:相同则0,不同则1。
00000000 00000000 00000000 00000011
  &00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是: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 OperatorDemo2 {
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
}
}


/*
<<:左移 左边最高位丢弃,右边补齐0
>>:右移 最高位是0,左边补齐0;最高为是1,左边补齐1
>>>:无符号右移 无论最高位是0还是1,左边补齐0

面试题:
请用最有效率的方式写出计算2乘以8的结果?
2 * 8

2 << 3


*/
class OperatorDemo3 {
public static void main(String[] args) {
//<< 把<<左边的数据乘以2的移动次幂
System.out.println(3 << 2); //3*2^2 = 3*4 = 12;

//>> 把>>左边的数据除以2的移动次幂
System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
System.out.println(24 >>> 2);

System.out.println(-24 >> 2); 
System.out.println(-24 >>> 2);
}
}
/*
计算出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

11111111 11111111 11111111 11101000
1111111111 11111111 11111111 111010(00) 补码

补码:1111111111 11111111 11111111 111010
反码:1111111111 11111111 11111111 111001
原码:1000000000 00000000 00000000 000110

结果:-6

>>>的移动:
计算出24的二进制:11000
原码:10000000 00000000 00000000 00011000
反码:11111111 11111111 11111111 11100111
补码:11111111 11111111 11111111 11101000

11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00)

结果:
*/
/*
面试题:
请自己实现两个整数变量的交换
注意:以后讲课的过程中,我没有明确指定数据的类型,默认int类型。
*/
class OperatorTest {
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);
System.out.println("------------");
*/

//方式2:用位异或实现(面试用)
//左边:a,b,a
//右边:a ^ b
/*
a = a ^ b;
b = a ^ b; //a ^ b ^ b = a
a = a ^ b; //a ^ b ^ a = b
System.out.println("a:"+a+",b:"+b);
*/

//方式3:用变量相加的做法
/*
a = a + b; //a=30
b = a - b; //b=10
a = a - b; //a=20
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);
}
}


(6)三元运算符
A:格式
比较表达式?表达式1:表达式2;
B:执行流程:
首先计算比较表达式的值,看是true还是false。
如果是true,表达式1就是结果。
如果是false,表达式2就是结果。
/*
单目运算符:~3
双目运算符:3 + 4


三目运算符:
格式:比较表达式?表达式1:表达式2;

比较表达式:结果是一个boolean类型。

执行流程:
根据比较表达式的计算返回一个true或者false。
如果是true,就把表达式1作为结果。
如果是false,就把表达式2作为结果。
*/
class OperatorDemo {
public static void main(String[] args) {
int x = 100;
int y = 200;

int z = ((x > y)? x: y);

//int z = ((x < y)? x: y);

//int z = ((x == y)? x: y);

//报错
//int z = ((x = y)? x : y);

System.out.println("z:"+z);
}
}


C:案例:
a:比较两个数据是否相等
b:获取两个数据中的最大值
c:获取三个数据中的最大值


/*
练习:
获取两个整数中的最大值
获取三个整数中的最大值
比较两个整数是否相同
*/
class OperatorTest {
public static void main(String[] args) {
//获取两个整数中的最大值
int x = 100;
int y = 200;

int max = (x > y? x: y);
System.out.println("max:"+max);
System.out.println("--------");

//获取三个整数中的最大值
int a = 10;
int b = 30;
int c = 20;

//分两步:
//A:先比较a,b的最大值
//B:拿a,b的最大值在和c进行比较
int temp = ((a > b)? a: b);
//System.out.println(temp);
int max1 = (temp > c? temp: c);
System.out.println("max1:"+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:"+max2);
System.out.println("--------");

//比较两个整数是否相同
int m = 100;
int n = 200;

//boolean flag = (m == n)? true: false;
boolean flag = (m == n);
System.out.println(flag);
}
}
2:键盘录入(掌握)
(1)实际开发中,数据是变化的,为了提高程序的灵活性,我们加入键盘录入数据。
(2)如何实现呢?目前就记住
A:导包
import java.util.Scanner;
位置:在class的上边
B:创建对象
Scanner sc = new Scanner(System.in);
C:获取数据
int x = sc.nextInt();


/*
为了让程序的数据更符合开发的数据,我们就加入了键盘录入。
让程序更灵活一下。

那么,我们如何实现键盘数据的录入呢?
A:导包
格式:
import java.util.Scanner; 
位置:
在class上面。
B:创建键盘录入对象
格式:
Scanner sc = new Scanner(System.in);
C:通过对象获取数据
格式:
int x = sc.nextInt();
*/
import java.util.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);
}
}


/*
键盘录入练习:键盘录入两个数据,并对这两个数据求和,输出其结果
*/
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);
}
}


(3)把三元运算符的案例加入键盘录入改进。


/*
键盘录入练习:键盘录入两个数据,获取这两个数据中的最大值
*/


import java.util.Scanner;


class ScannerTest2 {
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 = (a > b? a: b);
System.out.println("max:"+max);
}
}


/*
键盘录入练习:
键盘录入三个数据,获取这三个数据中的最大值
键盘录入两个数据,比较这两个数据是否相等
*/
import java.util.Scanner;


class ScannerTest3 {
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();

System.out.println("请输入第三个数据:");
int c = sc.nextInt();

//获取这三个数据中的最大值
int temp = ((a > b)? a: b);
int max = (temp > c? temp : c);
System.out.println("max:"+max);
System.out.println("------------------");

//键盘录入两个数据
System.out.println("请输入第一个数据:");
int x = sc.nextInt();

System.out.println("请输入第二个数据:");
int y = sc.nextInt();

//比较这两个数据是否相等
boolean flag = (x == y);
System.out.println("flag:"+flag);
}
}


3:流程控制语句
(1)顺序结构 从上往下,依次执行
/*
流程控制语句:可以控制程序的执行流程。

分类:
顺序结构
选择结构
循环结构

顺序结构:
从上往下,依次执行。
*/
class ShunXuJieGouDemo {
public static void main(String[] args) {
System.out.println("程序开始了");

System.out.println("我爱Java");

System.out.println("程序结束了");
}
}


(2)选择结构 按照不同的选择,执行不同的代码
(3)循环结构 做一些重复的代码


4:if语句(掌握)
(1)三种格式
A:格式1
if(比较表达式) {
语句体;
}

执行流程:
判断比较表达式的值,看是true还是false
如果是true,就执行语句体
如果是false,就不执行语句体

B:格式2
if(比较表达式) {
语句体1;
}else {
语句体2;
}

执行流程:
判断比较表达式的值,看是true还是false
如果是true,就执行语句体1
如果是false,就执行语句体2

C:格式3
if(比较表达式1) {
语句体1;
}else if(比较表达式2){
语句体2;
}
...
else {
语句体n+1;
}

执行流程:
判断比较表达式1的值,看是true还是false
如果是true,就执行语句体1
如果是false,就继续判断比较表达式2的值,看是true还是false
如果是true,就执行语句体2
如果是false,就继续判断比较表达式3的值,看是true还是false
...
如果都不满足,就执行语句体n+1
/*
选择结构:
if语句
switch语句

if语句:
格式1
格式2
格式3

if语句的格式:
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");
}
}


(2)注意事项
A:比较表达式无论简单还是复杂,结果是boolean类型
B:if语句控制的语句体如果是一条语句,是可以省略大括号的;如果是多条,不能省略。
建议:永远不要省略。
C:一般来说,有左大括号,就没有分号,有分号,就没有左大括号。
D:else后面如果没有if,是不会出现比较表达式的。
E:三种if语句其实都是一个语句,只要有一个执行,其他的就不再执行。


/*
if语句的注意事项:
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");
}
System.out.println("-------------------");

int a = 100;

/*
if(a == 100) {
System.out.println("a的值是100");
}
*/

if(a != 100) {
System.out.println("a的值是100");
System.out.println("over");
}
System.out.println("-------------------");

int b = 100;
if(b != 100);  //这里其实是有语句体的,只不过是空语句体。

//代码块
{
System.out.println("b的值是100");
System.out.println("over");
}
}
}
(3)案例:
A:比较两个数是否相等
B:获取两个数中的最大值
C:获取三个数中的最大值(if语句的嵌套)
D:根据成绩输出对应的等级
E:根据月份,输出对应的季节
F:根据x计算对应y的值并输出
/*   A:
if语句格式2:
if(比较表达式) {
语句体1;
}else {
语句体2;
}
执行流程:
首先计算比较表达式的值,看其返回值是true还是false。
如果是true,就执行语句体1;
如果是false,就执行语句体2;

注意:else后面是没有比较表达式的,只有if后面有。
*/
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");
}
}
}




/*   B:
if语句格式2的练习:
A:获取两个数据中较大的值
B:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
*/
import java.util.Scanner;


class IfTest {
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("----------------");

//判断一个数据是奇数还是偶数
System.out.println("请输入你要判断的数据:");
int x = sc.nextInt();

if(x%2 == 0) {
System.out.println(x+"这个数据是偶数");
}else {
System.out.println(x+"这个数据是奇数");
}
}
}


/*   C:
获取三个数据中的最大值

由此案例主要是为了讲解if语句是可以嵌套使用的。而且是可以任意的嵌套。
*/
class IfTest4 {
public static void main(String[] args) {
int a = 10;
int b = 30;
int c = 20;

//三元实现
//int temp = (a>b)? a: b;
//int max = (temp>c)? temp: c;
//System.out.println("max:"+max);
//System.out.println("--------");

//用if语句实现
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);
}
}


/*   D:
if语句的格式3:
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}

执行流程:
首先计算比较表达式1看其返回值是true还是false,
如果是true,就执行语句体1,if语句结束。
如果是false,接着计算比较表达式2看其返回值是true还是false,

如果是true,就执行语句体2,if语句结束。
如果是false,接着计算比较表达式3看其返回值是true还是false,
...

如果都是false,就执行语句体n+1。
*/
import java.util.Scanner;


class IfDemo5 {
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("不及格");
}
}
}


/*   E:
键盘录入月份的值,输出对应的季节。

3,4,5
6,7,8
9,10,11
12,1,2

分析:
A:键盘录入月份的值,所以我们要使用Scanner。
B:我们应该判断这个月份在那个季节,而这个判断情况较多,所以,用if语句格式3。

if语句的使用场景:
A:针对表达式是一个boolean类型的判断
B:针对一个范围的判断
*/
import java.util.Scanner;


class IfTest3 {
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("冬季");
}
System.out.println("--------------");

//这个程序确实是符合了我们的需求,但是就是看起来比较麻烦
//那么,我们能不能改进一下呢?
//month == 3
//month == 4
//month == 5
//我们发现,上面三个都是春季。
//而他们本身每一个都是一个boolean表达式
//所以,我们就可以考虑使用逻辑运算符给他们连接起来改进
if(month<1 || month>12) {
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("冬季");
}
System.out.println("--------------");

//这个时候,程序代码以及可以了。
//但是呢,假如我要求你输入一个月份,判断是上半年还是下半年。
//这个时候,我们的判断条件连接就是6个boolean表达式
//我们可能还有更多的连接
//这个时候,其实我们还有另外的一种改进方案:
//month == 3
//month == 4
//month == 5
//month>=3 && month<=5
//用范围也是可以改进的。
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("冬季");
}
System.out.println("--------------");
}
}


/*   F:
三种if语句分别适合做什么事情呢?
格式1:适合做单个判断
格式2:适合做两个判断
格式3:适合做多个判断

需求:
键盘录入x的值,计算出y的并输出。

x>=3 y = 2x + 1;
-1<=x<3 y = 2x;
x<=-1 y = 2x – 1;

分析:
A:由于数据要键盘录入,所以必须使用Scanner。
B:由于是三种判断,所以我们选择if语句格式3。
*/
import java.util.Scanner;


class IfTest2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

System.out.println("请输入x的值:");
int x = sc.nextInt();

//定义一个y
int y;

//用if语句格式3进行判断
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);
}
}

(4)三元运算符和if语句第二种格式的关系
所有的三元运算符能够实现的,if语句的第二种格式都能实现。
反之不成立。

如果if语句第二种格式控制的语句体是输出语句,就不可以。
因为三元运算符是一个运算符,必须要有一个结果返回,不能是一个输出语句。
/*
由于if语句的第二种格式刚才也完成了三元运算符可以完成的效果。
所以,我们就认为他们可以完成一样的操作。
但是,他们就一点区别没有吗?肯定不是。

区别:
三元运算符实现的,都可以采用if语句实现。反之不成立。

什么时候if语句实现不能用三元改进呢?
当if语句控制的操作是一个输出语句的时候就不能。
为什么呢?因为三元运算符是一个运算符,运算符操作完毕就应该有一个结果,而不是一个输出。
*/
class IfDemo4 {
public static void main(String[] args) {
//获取两个数据的最大值
int a = 10;
int b = 20;

//用if语句实现
int max1;
if(a > b) {
max1 = a;
}else {
max1 = b;
}
System.out.println("max1:"+max1);

//用三元改进
int max2 = (a > b)? a: b;
System.out.println("max2:"+max2);
System.out.println("----------");

//判断一个数据是奇数还是偶数,并输出是奇数还是偶数
int x = 100;

if(x%2 == 0) {
System.out.println("100是一个偶数");
}else {
System.out.println("100是一个奇数");


//用三元改进
//这种改进是错误的。
//String s = (x%2 == 0)?System.out.println("100是一个偶数");:System.out.println("100是一个奇数");;
}
}

你需要的是什么,直接评论留言。

获取更多资源加微信公众号“Java帮帮” (是公众号,不是微信好友哦)

还有“Java帮帮”今日头条号,技术文章与新闻,每日更新,欢迎阅读

学习交流请加Java帮帮交流QQ群553841695

分享是一种美德,分享更快乐!


网友评论

登录后评论
0/500
评论