运算符
1.数学运算符
-
加 + 减 - 乘 * 除 / 取余%
int a = 10;
int b = 5;
int c = a + b;//声明int类型 变量c 接收a+b结果
// System.out.println(c);//15
// System.out.println(a + b);//15
// System.out.println(a - b);//5
// System.out.println(a * b);//50
// System.out.println(a / b);//2
System.out.println(5 % 2);//1
//一个数被2整除(余数为0) 则为偶数
System.out.println(2 % 2);//0
System.out.println(8 % 2);//0
//取余操作时， 若左边的数据 小于右边的数据 ，其余数是左边自身的数据
System.out.println(1 % 3);//1
System.out.println(2 % 3);//2
System.out.println(3 % 3);//0-
.自增自减运算符
自增(++)：在变量自身基础上增加1
自减(--)：在变量自身基础上减少1
1.单独运算时，自增自减符号在前在后都一样。
2.参与运算时，就是写了赋值号(=) 也算运算，自增自减符号在前在后不一样。
加加在前，先做自增，后参与其它运算。
加加在后，先参与其它运算，再做自增。
减减在前，先做自减，后参与其它运算。
减减在后，先参与其它运算，再做自减。
/**
* 运算符相关演示类
* 1.数学运算符相关演示
* 2.自增自减运算符演示
*/
public class OperationDemo {
public static void main(String[] args) {
// int a = 10;
// int b = 5;
// int c = a + b;//声明int类型 变量c 接收a+b结果
System.out.println(c);//15
System.out.println(a + b);//15
System.out.println(a - b);//5
System.out.println(a * b);//50
System.out.println(a / b);//2
//
// System.out.println(5 % 2);//1
// //一个数被2整除(余数为0) 则为偶数
// System.out.println(2 % 2);//0
// System.out.println(8 % 2);//0
//
// //取余操作时， 若左边的数据 小于右边的数据 ，其余数是左边自身的数据
// System.out.println(1 % 3);//1
// System.out.println(2 % 3);//2
// System.out.println(3 % 3);//0
//-----自增自减运算符
// int a = 15;
// ++a;//等价于 a = a+1;
// System.out.println(a);//16
// --a;//等价于 a = a -1;
// System.out.println(a);//15s
//-------第二种情况 ，参与运算时----------------
// int b = 5;
// int c = 4;
// int d = b++;
// int e = --c;
// System.out.println(b);//6
// System.out.println(c);//3
// System.out.println(d);//5
// System.out.println(e);//3
// int b = 5;
// int c = 4;
// int d = --b;
// int e = c--;
// System.out.println(b);//4
// System.out.println(c);//3
// System.out.println(d);//4
// System.out.println(e);//4
int a = 5;
int b = 3;
//运算的规则：抛开减减符号不说，单独就看四则运算 与 赋值运算 ，优先做四则运算。
//套入自增自减规则然后
// int c = --a - b;
// System.out.println(a);
// System.out.println(b);
// System.out.println(c);
int result = a++ - ++b;
System.out.println(a);
System.out.println(b);
System.out.println(result);
}
}3.关系运算符
大于(>) 小于(<) 大于等于(>=) 小于等于(<=) 等于(==) 不等于(!=)
关系运算符的判断结果是boolean类型，要么成立(true) 要么不成立（false）
int a =50; int b = 40;
boolean result = a > b; boolean 类型
a的数据大于b的数据？ --------------------------- true
int c = 50; int d =50;
boolean result1 = c >= d;
c的数据大于等于d的数据吗？---------------------- true
int e = 100; int f =99;
e <= ++f; -------------------------------- true4.逻辑运算符
java逻辑运算符分为三种(与或非)，它们返回的结构是boolean类型(true/ false)
1.逻辑与(&&) :与是并且的意思
2.逻辑或(||) ：或是或者的意思
3.逻辑非(!) ：非是结果取反的意思
逻辑与(并且) 现象:在逻辑与(并且)的关系中,两个或多个条件中,有一个条件不成立,结果一定不成立.
一假俱假 -----见 false 即 false
能毕业吗？
条件一：课程学完了吗？ true false false true
并且
条件二：考试及格了吗？ false true false true
结果： false false false true
--------------------------------------------------------------------------------
逻辑或(或者) 现象:在逻辑或(或者)的关系中,两个或多个条件中,有一个条件成立,结果一定成立.
一真俱真 -----见 true 即 true
能结账吗?
条件一:微信有钱吗? false true true false
或者
条件二:带现金了吗? true false true false
结果: true true true false
--------------------------------------------------------------------------------
逻辑非(取反)
true: !true 非真即假
结果: false
false:!false 非假即真
结果: true
int a = 5;
// int b = 10;
// int c = 5;
// boolean result = a > b && b > c;// false && true ----->在并且的关系中,见false即false
// System.out.println(result);//false
// System.out.println(a > b || c < b);//false || true --->在或者的关系着,见true即true
// System.out.println(!(a==c) && b > c);// false && true-->在并且的关系中,见false即false
//判断年份是否是闰年:
/**
* 闰年的判定条件:
* 条件一: 年份能被4整除 并且 年份不能被100整除
* 或者
* 条件二: 年份能被400整除
* */
// Scanner s = new Scanner(System.in);//创建一个扫描器
// System.out.println("请输入一个要判断的年份");
// int year = s.nextInt(); //接收控制台中输入的int 的数据 存到year这个变量里面
// System.out.println(year);
// boolean r1 = year % 4 == 0 && year % 100 != 0;
// boolean r2 = year % 400 ==0;
// boolean isRun = r1 || r2;//条件一的boolean结果或者条件二的boolean结果 见true 即 true
// System.out.println("当前年份是闰年的结果:"+isRun);
// //第二种写法:
// boolean r3= (year % 4 == 0 && year % 100 != 0) || year % 400 ==0;短路逻辑
短路与 和 短路或
短路与:
相亲成功的两个条件
1.相亲对象是女生 true
并且
2.要勤俭持家 true
结果: 相亲成功(true)
短路与的现象:如果在与的关系中,第一个条件(前面的条件)不成立,程序则立刻返回不成立的结果,代码不会继续看条件二.
-----------------------------------------------------------------------------------------
短路或:
相亲成功的两个条件(满足其一即可)
1.长得好看
或者
2.勤俭持家
短路或的现象:如果在或的关系中,第一个条件(前面的条件)成立,程序立刻返回成立的结果,代码不会继续看条件二.
//短路逻辑:
// int a = 10;
// int b = 20;
// System.out.println(a > b && ++a < b);// false
// System.out.println(a);//10
//
// System.out.println(++a < b || ++b >a);//true
// System.out.println(b);//20
//
// System.out.println(a >=11 && ++b >20 );//true
// System.out.println(a);//11
// System.out.println(b);//215.赋值运算符
赋值号: = 赋值的顺序,将赋值号右边的内容 给左边变量的过程.
扩展赋值: += -= /= *= %= 在变量的自身基础上，进行运算然后将结果再赋值给自身。
//扩展赋值的使用
int a = 10;
a += 20;// 30 // 等价于：a = a + 20;//在a的自身基础上加20
a -= 20;// 10
a *= 20;// 200
a /= 20;// 10
a %= 20;// 10
System.out.println(a);
//面试题：
byte b = 10;
// byte r = b +10;//编译错误：小类型+大类型 其结果会转换为大类型结果。
b += 10;//使用扩展赋值 系统会包含转化的代码 等价于 (byte)(b+10)6.字符串拼接运算符
字符是char类型 要用单引号来存储1个字符！
字符串是String类型,要用双引号来存储，存储一串字符！
1.使用+号时，如果两边的内容都是数值的话，则会进行运算操作！
2.使用+号时，如果有一方是字符串类型，则会进行链接(拼接)操作，则整体会变成一个字符串。
char a = 'D';
String b = "ABC";
//字符串链接运算测试：
String name = "乐磊";
int age = 18;
System.out.println("大家好,我叫"+name+",我的年龄是"+age);
System.out.println(10+10+""+30);//"2030"
System.out.println(""+10+10+30);//"101030"
System.out.println(10+10+30+"");//"50"7.三元(三目)运算符
语法： boolean ？ 值1 ：值2；
判断逻辑是否成立 ？ 若成立则返回值1 : 若不成立则返回值2；
int number1 = 10;
int number2 = 20;
// 判断的逻辑 ? 成立返回值1 ： 不成立 返回值2
int max = number1 > number2 ? number1: number2;
System.out.println(max);
//接收结果要看值1和值2的类型来决定声明什么变量进行接收
String result = number1 > number2 ? "num1大于num2" : "num2大于num1";
System.out.println(result);
流程控制包含3种结构，任何的复杂的业务逻辑都可以通过这3种结构来实现：
1.顺序结构：代码逐语句执行，每句必走。
2.分支结构：有条件的执行某个语句，并非每句都走。
3.循环结构：有条件的重复执行某个语句，并非每句都走。
分支结构:
1.单路分支
例如:
购物满500 打 8折 --------------购物满500 ---true ---- 打8折 单路分支
购物满500 打8折 不满打9折 ------购物满500 --true ----打8折
--false ----打9折
双路分支
package day05;
/**
* if--如果的意思 单路分支的使用演示类:
*/
public class IFDemo {
public static void main(String[] args) {
/** 语法结构:
* if(boolean){
* //满足if条件才会执行的代码块
* }
* ----------
* if(购物满500){
* 打8折的事情
* }
* ----------
* 执行顺序:
* 判断if小括号的boolean值
* 若为true 则执行 if小括号后面的花括号的内容
* 若为false 程序跳过if的代码块 继续往后执行.
* */
//购物满500 打 8折
double price = 300;//金额
if(price >= 500){
price *= 0.8; // price = price * 0.8;
System.out.println("打完8折后,应付:"+price);
}
System.out.println("已付款:"+price);
int number = 11;
if(number % 2 == 0){
System.out.println("number是偶数");
}
System.out.println("代码继续往后执行...");
}
}
2.双路分支
/**
* 双路分支 结构的使用演示类
*/
public class IFElseDemo {
public static void main(String[] args) {
/** 代码结构:
* if(boolean){
* //满足条件所执行的代码块 1
* } else { -----else 代表否则的意思
* //不满足条件所执行的代码块 2
* }
* -------------------------
* 执行过程:
* 判断if小括号中的条件
* 若为true ,则执行代码块1
* 若为false,则执行代码块2
* */
// 购物满500 打8折 不满打9折
double price = 666.66;
if (price >= 500) {
price *= 0.8;
System.out.println("打8折后应付:" + Math.round(price));
} else {
price *= 0.9;
System.out.println("打9折后应付:" + Math.round(price));
}
System.out.println("已付款:" + Math.round(price));
//Math.round(); Java提供的四舍五入的功能,将需要四舍五入的内容放到小括号即可
}
}3.多路分支
import java.util.Scanner;
/**
* 多路分支的使用演示类:
*/
public class IFElseIFDemo {
public static void main(String[] args) {
/** 多路分支的语法结构:
* if(条件1){
* //条件1满足执行的代码块
* } else if(条件2){
* //条件2满足执行的代码块
* } else if(条件3){
* //条件3满足执行的代码块
* }
* ........
* 执行过程:
* 先判断if小括号条件1 若成立则执行条件1的代码块 ,代码跳过其他条件继续往后执行
* 若不成立 再判断条件2 若成立则执行条件2的代码块,代码跳过其他条件继续往后执行
* 若不成立 再判断条件3 若成立则执行条件3的代码块,代码跳过其他条件继续往后执行
* */
//当 我们对一个数据有多种判定条件时,可以用多路分支.
/** 根据 成绩(score) 判断学生的成绩等级
* A. score >= 90 ---优秀
* B. score >= 80 && score <90 ----良好
* C. score >= 70 && score <80 ----一般
* D. score >= 60 && score <70 ----及格
* E. score < 60 -----------------不及格
* */
int score = 50;//分数 变为控制台输入获取的方式: Scanner ..
if (score >= 90) { //如果分数大于等于90的话
System.out.println("优秀!");
} else if (score >= 80) {//否则如果分数大于等于80的话
System.out.println("良好!");
} else if (score >= 70) {//否则如果分数大于等于70的话
System.out.println("一般!");
} else if (score >= 60) {//否则如果分数大于等于60的话
System.out.println("及格!");
} else {//否则分数一定小于60
System.out.println("不及格!");
}
/** 练习题: age
* 通过控制获取数据的方式 获取用户输入的年龄,对年龄进行判定等级:
* A. age>=0 && age<5 打印 幼年
* B. age>=5 && age<12 打印 少年
* C. age>=12 && age<18 打印 青年
* D. age>=18 && age<35 打印 成年
* E. age>=18 && age<50 打印 中年
* F. age>=50 && age<65 打印 中老年
* G. age>=65 && age<130 打印 老年
* 若上述条件都不成立 则打印年龄不合法
* */
Scanner s = new Scanner(System.in);//创建一个扫描器
int age = s.nextInt();//接受用户输入的数据
if(age>=0 && age<5){
System.out.println("幼年");
}else if(age >= 5 && age<12){
System.out.println("少年");
}else if(age>=12 && age<18){
System.out.println("青年");
}else if(age>=18 && age<35){
System.out.println("成年");
}else if(age>=18 && age<50){
System.out.println("中年");
}else if(age>=50 && age<65){
System.out.println("中老年");
}else if(age>=65 && age<130) {
System.out.println("老年");
} else {
System.out.println("年龄不合法!");
}
}
}
多路分支的第二种形式: switch ...case
适用性:只能对整数类型(不包含long类型)进行判定 , 现在也支持对String进行判定
优点:效率高 结构清晰.
缺点: 不能匹配逻辑或关系运算符的写法!只能匹配单值且case 后面只能写直接量
import java.util.Scanner;
/**
* switch 分支语法演示类:
*/
public class SwitchCaseDemo {
public static void main(String[] args) {
/** 语法结构:
* int a = 1;
* switch(a){
* case 1:
* 匹配成功执行的代码区域
* break;//代表退出当前switch整个代码块
* case 2:
* 匹配成功执行的代码区域
* break;
* case 10:
* 匹配成功执行的代码区域
* break;
* }
* */
Scanner s = new Scanner(System.in);
System.out.println("请根据业务提示:1.存款 2.取款 3.转账");
int command = s.nextInt();//接受用户输入的执行
switch (command){
case 1:
System.out.println("正在办理存款业务");
break;//退出的switch结构 若不写break,则还会继续执行后面的语句(则不看case)
case 2:
System.out.println("正在办理取款业务");
break;
case 3:
System.out.println("正在办理办理转账业务");
break;
default:
System.out.println("指令不合法!");
}
System.out.println("代码逐语句往后执行....");
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
