1 运算符
1.1 概述
运算符 用于连接 表达式 的 操作数，并对操作数执行运算。
在java语言中，运算符可分为5种类型：
- 算术运算符
- 赋值运算符
- 关系运算符
- 逻辑运算符
- 位运算符
根据操作数的不同，运算符又分为单目运算符、双目运算符和三目运算符。
单目运算符只有一个操作数，双目运算符有两个操作数，三目运算符则有三个操作数。
位运算符涉及到二进制位的运算，在java 程序中运用不是很多。
1.2 运算符速查表
![e53cc7e8558df38df4db643889f71979.png]()
1.3 算数运算符（挑重点）
- %（模）：取余数，整除的余数为 0
//1.测试除法与取余数
System.out.println(25/10);//int/int->int,商是2
System.out.println(25%10);//取余，余数为5
//练习：获取一个两位数的十位与个位
int x = 59;
System.out.println(59/10);//获取十位，包含几个10
System.out.println(59%10);//获取个位，除十位之外还剩多少
//练习：获取一个三位数的百位 十位 与个位
int y = 152;
System.out.println(y / 100);//获取百位，包含几个100
System.out.println(y / 10 % 10);//获取十位，15个十，取余取5
System.out.println(y % 10);//获取个位，除了15个10以外的余数2
- ++\--（自增/自减）：自增/自减 分为两类：
- 前缀式：++a / --a （表示先 +1/-1，再使用）
- 后缀式：a++ / a-- （先使用，再 +1/-1）
int a = 1;
System.out.println(a++); //1,先使用，再自增
System.out.println(a); //2，使用后自增成2
int b = 1;
System.out.println(++b); //2,先自增再使用
System.out.println(b); //2
System.out.println("·····································");
/** 练习：自增自减 （之前的代码会对后面的代码产生影响）
* 注意：只有自增z自减运算符才会改变变量本身的值
* 普通的四则运算只能改变算式本身的值，想要改变要重新将结果赋值给变量
* * */
int c = 0;
/** --c(自减为-1)-c-c--（因为是先自减所以c为-1，然后四则运算-c-c--）
* 因为c--是后缀式的，先使用。最后就变成了-1-(-1)-(1) = 1
* */
System.out.println(--c-c-c--); //-1-(-1)-(1) = 1
/** 为什么是-2 因为只有自增自减才能改变，变量本身。四则运算只能改变式子
* 这个案例只自减了两次所以结果为-2
* */
System.out.println(c); //-2
1.4 比较运算符
- == ：判断表达式两边的操作数是否相等,相等为 ”true“，反之为 ”false“。
- 而单个等号 ”=“ 的意思是把右边的值赋给左边。两者样子相近用法截然不同，切忌不要混淆。
- != ：判断表达式两边的操作数是否不相等,相等为 ”true“，反之为 ”false“
- 注意：比较的结果是boolean类型的，只有 ”true“ 和 ”false“ 两种结果。
1.5 逻辑运算符
-
&/与/和/and 只有两边都为true，式子才为true，反之为false
-
|/或/or 只有两边都为false，表达式才为false，反之为true
-
&&：双与/短路与 ，逻辑与单与相同，只不过增加了“短路”的功能
1.6 三目运算符
1 ? 2 : 3
1是表达式,若1的结果为true,结果取2位置,若1的结果为false,结果取3位置
import java.util.Scanner;
/**
* @Author 宁铂
* @Date 2021/7/3 10:19
* @Version 1.0
*/
public class TestMaxNum {
/** 本类用于练习三木运算符
* 要求：接收用户输入的两个数，输出这两个数的最大值
* */
public static void main(String[] args) {
System.out.println("请输入您要比较的第一个整数：");
int a = new Scanner(System.in).nextInt();
System.out.println("请输入您要比较的第二个整数：");
int b = new Scanner(System.in).nextInt();
/** 三目运算符：1？2：3
* 1号位置是一个表达式，如果一号为true，取2号位置的值，反之，取3号 * */
int max = a>b ? a : b;
System.out.println("最大值是："+max);
/** 练习：如何判断3个数的最小值？ */
System.out.println("请输入您要比较的第一个整数：");
int x = new Scanner(System.in).nextInt();
System.out.println("请输入您要比较的第二个整数：");
int y = new Scanner(System.in).nextInt();
System.out.println("请输入您要比较的第三个整数：");
int z = new Scanner(System.in).nextInt();
int min = x<y ? (x<z?x:z):(y<z?y:z);
System.out.println("最小值是："+min);
}
}
关于运算符的优先级：
当一个表达式包含多个运算符时，就需要考虑运算符的优先级，优先级高的运算符先参与运算，优先级低的运算符后参与运算。在实际的开发中，不需要特别去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号辅助进行优先级管理。
2 分支结构
2.1 概述
顺序结构的程序虽然能解决计算、输出等问题（顺序结构：main方法开始顺序执行）
但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构
2.2 三种分支形式
![2afa41af3c7db4d9a87b90af623ed69c.png]()
import java.util.Scanner;
/**
* @Author 宁铂
* @Date 2021/7/3 18:41
* @Version 1.0
*/
public class TestYear {
/** 练习：平年闰年案例
* 需求：接收用户输入的年份,判断是平年还是闰年
* */
public static void main(String[] args) {
System.out.println("请输入您要查询的年份：");
int year = new Scanner(System.in).nextInt();
/** 判断条件：
* 1.能被4整除但不能被100整除
* 2.能被400整除
* */
String result = "闰年";
/**判断结构 if(判断条件){满足判断条件以后执行的代码}
* if(条件1 || 条件2){是闰年 }
* if((小条件1 && 小条件2) || 条件2){ 是闰年 }
* if((能被4整除 && 不能被100整除) || 能被400整除){ 是闰年 }
* */
if((year%4==0 && year%100!=0 )|| year%400==0){
System.out.println(year+"是"+result);
}else {
System.out.println(year+"是平年");
}
}
}
import java.util.Scanner;
/**
* @Author 宁铂
* @Date 2021/7/3 19:53
* @Version 1.0
*/
public class TestScore {
/** 本类用于判断学员分数的档位
* 需求：
* 90分及以上 优秀
* 80-89 良好
* 70-79 中等
* 60-69 及格
* 60分及以下 不及格
* */
public static void main(String[] args) {
System.out.println("请输入您要查询的成绩：");
int score = new Scanner(System.in).nextInt();
/** 为了提高程序的健壮性，需要对分数进行判断
* 如果合理。就判断，不可理结束程序
* */
if(score < 0 || score > 100){
System.out.println("请输入正确的分数！");
}else {
if(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("不及格，需要补考");
}
}
}
}
3 循环结构
3.1 for概述
循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
它由循环体中的条件，判断继续执行某个功能还是退出循环。
根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。
3.2 for形式
![4ab5028198240e62ce3e2f74230d989f.png]()
/**
* @Author 宁铂
* @Date 2021/7/3 20:27
* @Version 1.0
*/
public class TestFor {
/** 本类用于测试for循环结构
* 需求：打印100次学习的slogon
* */
public static void main(String[] args) {
for(int a = 1;a <= 100;a++){
System.out.println("加油努力，干就完了！");
}
/** 需求：打印数字1-10
* 1 2 3 4 5 6 7 8 9 10
* 从哪开始：1
* 到哪结束：10
* 怎么变化：+1 ++
* */
for (int i = 1;i <= 10;i++){
System.out.println(i);
}
/** 需求：10-1 */
for (int i = 10;i>=1;i--){
System.out.println(i);
}
/** 需求：打印8，88，888，8888 */
for(int i = 8;i<=10000;i=i*10+8){
System.out.print(i+",");
}
}
}
课后作业：
/**
* @Author 宁铂
* @Date 2021/7/3 20:55
* @Version 1.0
*/
public class TestFor2 {
/** 需求：求[1,100]以内元素之和,偶数之和,偶数个数 */
public static void main(String[] args) {
int x = 0;
int y = 0;
int z = 0;
for(int i = 1; i<=100;i++){
x = x+i;
if(i%2==0){
y = y+i;
z++;
}
}
System.out.println("1-100以内的元素之和为："+x);
System.out.println("1-100以内的偶数之和为："+y);
System.out.println("1-100以内的偶数个数为："+z);
}
}
