今天的内容
1.算术运算符
2.关系运算符
3.逻辑运算符
4.关于逻辑运算符的短路原则
5.分支
1.运算符
1.1算术运算符
1.加减乘除取余
2.+= -= *= /= %=
3.自增和自减
自增和自减： 可以让一个变量自身增加1或者减去1
语法格式：
变量++; 先执行当前的操作 ，然后自身在增加1
a++;
++变量;先自身加1，然后再执行其他的操作
++a;
变量--; 先执行当前的操作，然后执行自身减1
a--;
--变量; 先自身减1，然后再执行其他的操作
--a;public class Demo1 {
public static void main(String[] args) {
//关于自增和自减的代码
int num1 = 10;
//num1++ ++在变量的后面，先执行当前的操作（输出语句），然后再自身加1
System.out.println(num1++);//10
System.out.println(num1);//11
int num2 = 5;
//++num2 ++在变量的前面，先自身增加1 然后再执行接下来的操作
System.out.println(++num2);//6
System.out.println(num2);//6
int num3 = 4;
System.out.println(num3--);//4
System.out.println(num3);//3
int num4 = 3;
int ret = num4++ * num4;
System.out.println(ret);//12
System.out.println(num4);//4
int num5 = 3;
int ret1 = num5 * num5++;
System.out.println(ret1);//9
int num6 = 2;
int ret2 = ++num6 * num6;
System.out.println(ret2);//9
int num7 = 2;
int ret3 = num7 * ++num7;
System.out.println(ret3);//6
//总结： 真实不会有这么麻烦 就是一个简单的自身增加1或者自身减1效果而已
}
}1.2关系运算符
> (大于) <(小于) >=(大于等于) <= (小于等于) ==(是否等于) !=(是否不等于)
变量1 > 变量2 例如: a > b
常量1 > 常量2 例如: 2 > 3
他们结果是个啥？是布尔类型的数据 true or falsepublic class Demo2 {
public static void main(String[] args) {
//将 3 > 4的结果赋值给 ret1 变量
boolean ret1 = 3 > 4;
System.out.println(ret1);//false
int a = 3;
int b = 4;
System.out.println(a < b);//true
System.out.println(a++ >= b);//false
System.out.println(a >= b);//true
int c = 8;
int d = 7;
System.out.println(--c <= d);//true
System.out.println(c++ == d);//true
System.out.println(1 != 1);//fasle
}
}1.3逻辑运算符
返回的结果i也是布尔类型的数据
与:
&&
语法格式:
表达式1 && 表达式2 && ... 关系运算符的表达式 && 关系运算符的表达式 3 > 4 && 5 < 6
表达式都为true的时候，整体的结果就为true。只要有一个为false，整体就为false
逻辑与： ATM取钱： 卡 和 密码 缺一不可
public class Demo3 {
public static void main(String[] args) {
//逻辑运算符：由关系运算符的表达式和&& 组成的
//ret = true && true 整体就为true
boolean ret = (4 > 1) && (7 < 8);
System.out.println(ret);//true
//ret1 = true && false && true 只有有一个为false 中整体的结果就为false
boolean ret1 = 1 < 3 && 2 > 4 && 7 > 1;
System.out.println(ret1);
int a = 20;
int b = 30;
int c = 10;
int d = 80;
//ret2 = false && false 整体为false
boolean ret2 = (a > b) && (c > d);
System.out.println(ret2);//false
}
}或：
||
语法格式:
关系运算符表达式1 || 关系运算符表达式2 || ...
表达式都为false的时候 整体结果就为false。如果有一个为true，整体就为true。
生活中: 你们家里的门得有锁， 你一把钥匙，你媳妇一把。 你媳妇一把丢了，门就可以开了。
public class Demo4 {
public static void main(String[] args) {
//逻辑或
//ret = false || true
boolean ret = 2 > 3 || 6 > 1;
System.out.println(ret);//true
boolean ret1 = 1 > 3 || 3 > 7 || 8 > 9 || 10 > 8;
System.out.println(ret1);//true
}
}非：
!
语法格式:
!关系运算符
如果关系运算符为true，整体结果就为false。 反之 就为true
生活中： 犟 反着来
public class Demo5 {
public static void main(String[] args) {
boolean ret = !(3 > 4);
System.out.println(ret);//true
//ret1 = true && false
// false || true
boolean ret1 = (3 > 2) && (4 > 5) || (5 > 3);
System.out.println(ret1);//true
//false || false
//从这个地方可以说下 与优先级高于或的优先级
boolean ret2 = !(((8 > 7) || (7 > 9)) && (8 < 4) || (6 > 7) && (6 > 7));
System.out.println(ret2);
}
}1.4逻辑运算符的短路原则
逻辑与的短路原则:
表达式1 && 表达式2 &&...
如果表达式1 为false 的话，整体就为false了， 表达式2 和以后的表达式就不再执行了
为啥？ 逻辑与 只要有一个为false，整体就为false了。表达式1位f已经为false了。已经决定了
整体的结果了。Jav为了执行的效率的问题，所以短路了
逻辑或的短路原则:
表达式1 || 表达式2 || ...
如果出现表达式为true的，整体就为true，从为true的表达式开始后面的表达式就不再执行了
public class Demo6 {
public static void main(String[] args) {
//逻辑与的短路原则： 一旦碰到表达式为false 后面的表达式不再执行
int num1 = 10;
boolean ret = (3 < 1) && (++num1 > 8);
System.out.println(ret);//false
System.out.println(num1);//10
int a = 11;
//false || false || true
boolean ret1 = (3 < 1 ) ||(a++ > 12) || (a++ >=11);
System.out.println(ret1);//true
System.out.println(a);//13
}
}练习:
1.
int a = 5;
int b = (a++) + (--a) + (++a)
16
int b = 5 + 5 + 6;
从左向右：
先是5 + 5 + 6总结：
1.算术运算符
2.关系运算符
3.逻辑运算符2.分支【重要】
先学习语法格式，然后再记执行流程
生活中的分支： 就是一种选择
程序中的分支: 也是一种选择
2.1if 分支
语法格式：
if (布尔表达式) { 语句体 }
执行流程: 如果布尔表达式为true， 就执行大括号里面的语句体。 如果布尔表达式为false，就跳过大括号里面的语句体，接着往下执行
public class Demo7 {
public static void main(String[] args) {
if (false) {
System.out.println("嘻嘻 执行了");
}
System.out.println("呵呵，来啊");
}
}public class Demo8 {
public static void main(String[] args) {
//如果成绩大于80分，输出奖励一次大保健
int score = 50;
if (score > 80) {
System.out.println("奖励一次大保健");
}
System.out.println("嘻嘻 结束了");
}
}练习：
如果用户名和密码都是对的，则输出登陆成功 用if来写
public class Demo9 {
public static void main(String[] args) {
//如果用户名和密码都是对的，则输出登陆成功 用if来写
int user = 111;
int password = 123;
if (user == 111 && password == 123) {
System.out.println("登陆成功");
}
}
}回顾上午的内容
1.算术运算符
自增和自减
变量++: 先执行当前的操作，然后自增1
++变量: 先自身加1然后再执行接下来的操作
变量--: 先执行当前的操作，然后自身减1
--变量: 先自身减1 ，然后再执行其他操作
2.关系运算符
< > >= <= != ==
结果是 布尔类型的数据
3.逻辑运算符
&& || ！
结果也是布尔类型的数据
4.短路原则
与短路原则： 只要有一个false的条件 后面的表达式不再执行了
或短路原则: 只要有一个true的表达式 后面的表达式就不执行了
5.分支
现在关注点: 1.语法格式 2.执行流程
if分支
if (布尔表达式) {
语句体
}
2.2if-else 分支
语法格式:
if (布尔表达式) { 语句体1 } else { 语句体2 }
执行流程： 如果布尔表达式为true 执行语句体1 ，如果布尔表达式为false 执行 语句体2
最重要的看布尔表达式值。 两者只能选择其一。
public class Demo10 {
public static void main(String[] args) {
if (false) {
System.out.println("呵呵");
} else {
System.out.println("嘿嘿");
}
}
}案例： 判断一个年份是否是闰年
package com.qf.a_yunsuan;
public class Demo12 {
public static void main(String[] args) {
//判断一个年份是否是闰年
//分析: 是闰年 不是闰年 if-else
//一个年份 ： 在Java中咋表示
//闰年: 能被4整除的并且不能100整除 或者能被400整除的是闰年
int year = 2001;
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
System.out.println("是闰年");
} else {
System.out.println("不是闰年");
}
}
}2.3if-else if 分支
语法格式：
if (布尔表达式1) { 语句体1 } else if (布尔表达式2) { 语句体2 } else if (布尔表达式n) { 语句体n } else { 语句体n+1 }
执行流程：
如果碰到if语句后面的小括号中的表达式为true的时候，就执行相对应的大括号后面的语句体
其他语句体一概不执行
应用场景： 多种情况
public class Demo13 {
public static void main(String[] args) {
/**
* 学生成绩的等级问题:
* 90~100 打印优秀
* 80~89 打印良好
* 70~79 打印一般
* 60~69 打印及格
* 60分以下 叫家长
* 结果是多个分支 用if-esle if
*/
int score = 31;
if (score <= 100 && score >= 90) {
System.out.println("优秀");
} else if (score >= 80) {//代码能够执行到 这一步
System.out.println("良好");
} else if ( score >= 70) {
System.out.println("一般");
} else if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("叫家长");
}
}
}2.4if嵌套的写法【了解】
一个if语句中再写另外一个if语句
public class Demo14 {
public static void main(String[] args){
//嵌套写法
//年龄满18岁，体重达标 才能献血
int age = 19;
int weight = 80;
// if (age >= 18 && weight >= 50) {
// System.out.println("去献血");
// }
if (age >= 18) {
//age >= 18 如果年龄达标 再判断体重
if (weight >= 50) {
System.out.println("可以去献血");
} else {
System.out.println("年龄达标，但是体重不达标");
}
} else {
//age < 18
System.out.println("未成年不能献血");
}
}
}2.5switch-case 分
也是一种选择，类似与 if-else if 分支
多种选择
语法格式：
swicth (表达式) { case 常量1: 语句体1; break; case 常量2: 语句体2; break; case 常量3: 语句体3; break; ... default: 语句体n; break; }
执行流程： switch后面小括号中的表达式值 去和 case后面的常量进行匹配。如果他们两个一样的话
就执行当前的语句体，其他语句体不执行
public class Demo15 {
public static void main(String[] args) {
//使用switch-case 写
/**
* 按1 给妈妈打电话
* 按2 给爸爸打电话
* 按3 给奶奶打电话
* 按4给爷爷打电话
* 按其他键 个110
*/
int num = 1;
switch (num) {
case 1:
System.out.println("给妈妈打电话");
break;//终止 打断
case 2:
System.out.println("给爸爸打电话");
break;
case 3:
System.out.println("给奶奶打电话");
break;
case 4:
System.out.println("给爷爷打电话");
break;
default:
System.out.println("110");
break;
}
System.out.println("================");
//使用if - else if形式来写
if (num == 1) {
System.out.println("给妈妈打电话");
} else if (num == 2) {
System.out.println("给爸爸打电话");
} else if (num == 3) {
System.out.println("给奶奶打电话");
} else {
System.out.println("110");
}
//总结： if-else if 和switch-case 的功能可以相互转 可以实现相等的功能
//但是表示式不一样
}
}public class Demo16 {
public static void main(String[] args) {
/**
* 学生成绩的等级问题:
* 90~100 打印优秀
* 80~89 打印良好
* 70~79 打印一般
* 60~69 打印及格
* 60分以下 叫家长
* 结果是多个分支 用swicth-case
*/
int score = 69;
switch (score / 10) {
case 10:
System.out.println("优秀");
break;
case 9:
System.out.println("优秀");
break;
case 8:
System.out.println("良好");
break;
case 7:
System.out.println("一般");
break;
case 6:
System.out.println("及格");
break;
default:
System.out.println("叫家长");
break;
}
}
}2.6关于switch-case的面试题
switch(表达式) {
}
表达式可以是什么类型的数据
byte short int char String 枚举
public class Demo17 {
public static void main(String[] args) {
byte a = 12; //可以
//short a = 12;可以
//int a = 12; 可以
//long a = 12; 不可以
//String a = "好久上班还好";可以
//boolean a = true; 不可以
//float f1 = 98.8f; 不可以
//char ch = 'a';可以的
//Cannot switch on a value of type long.
//Only convertible int values, strings or enum variables are permitted
switch (a) {
case 'a':
break;
default:
break;
}
}
}扩展【有点难度，但是以后不用】
现在声明变量是咋声明的？ int a = 20;
a的值是在写变量顺手赋值上去的
还有其他的形式对变量进行赋值，通过控制台进行输入 给变量进行赋值
步骤:
1.import java.util.Scanner;
2.在main主函数中 Scanner sca = new Scanner(System.in);
3.将控制台输入的数据赋值给Java代码中的变量
//1.需要使用Java的封装好的类叫Scanner 扫描器
import java.util.Scanner;
public class Demo18 {
public static void main(String[] args) {
//2.创建一个对象 这个行代码是固定的写法
//sca 变量名字 用就用sca
Scanner sca = new Scanner(System.in);
System.out.println("请输入一个数:");
//3.将控制台输入的一个int类型的数 赋值给变量 a
//控制台输入的一个数，在Java中用一个变量来接收到
int a = sca.nextInt();
System.out.println("Line 17:"+a);
}
}import java.util.Scanner;
public class Demo19 {
public static void main(String[] args) {
Scanner sb = new Scanner(System.in);
//获取控制台输入的int类型的数据
// System.out.println("请输入一个整数:");
// int a = sb.nextInt();
// System.out.println("Line11: " + a);
//获取控制台输入的byte类型的数据
// System.out.println("请输入一个整数:");
// byte b = sb.nextByte();
// System.out.println("Line14:" + b);
//获取控制台输入的float类型的数据
// System.out.println("请输入一个小数:");
// float f1 = sb.nextFloat();
// System.out.println("Line18:" + f1);
//获取控制台输入的布尔类型的数据
// System.out.println("请输入一个布尔类型的数据:");
// boolean b1 = sb.nextBoolean();
// System.out.println("Line23:" + b1);
//获取控制台输入的字符串类型的数据
// System.out.println("请输入一个字符串:");
// String str = sb.next();//获取控制台字符串的方法
// System.out.println("呵呵哒:" +str);
//获取控制台输入的字符类型的数据
System.out.println("请输入一个字符串:");
//sb.next() 取控制台的字符串的： 例如 abcdef
//charAt(0) 取你字符串中 第一个位置的字符 a
//charAt(1)取你字符串中 第二个位置的字符 b
char ch = sb.next().charAt(0);
System.out.println("Line32:" + ch);
//字符的获取 是在字符串的基础之上 获取的
}
}import java.util.Scanner;
public class Demo20 {
public static void main(String[] args) {
//看学生的成绩
//请输入学生的成绩，判断学生的等级
Scanner scann = new Scanner(System.in);
System.out.println("请输入学生的成绩:");
int score = scann.nextInt();
if (score >= 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 80) {
System.out.println("良好");
} else {
System.out.println("叫家长");
}
}
}
681
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
