一、运算符
1、算数运算符
2、自增自减运算符
3、赋值运算符
4、逻辑运算符
5、比较运算符
6、位移运算符
7、三元运算符
(1).算数运算符
1、用于做运算使用的运算符
2、+ - * / %
3、+：（1）表示一个正数
（2）进行加法运算
（3）拼接字符串
4、-: (1)表示一个负数
（2）：做减法运算
5、*：做乘法运算
6、/：（1）做除法运算
注意：如果是两个整数相除，得到的结果还是一个整数。
如果任意一个整数是小数，那么结果就是小数
7、%:取余运算符（取模运算符）
结果：运算的结果是两个整数相除的余数
注意：取余的结果的符号只和%前面的操作数有关
作用：判断一个数是否被整数，判断一个数的奇偶
8.代码如下所示
public class Yun {
//算数运算符
public static void main(String[] args) {
//+
System.out.println(+1);//表示一个正数，打印结果为1
System.out.println(21 + 12);//表示两个数相加，打印结果为33
String str = "world";
System.out.println("hello" + "world");//表示字符串拼接，打印结果为helloworld
System.out.println("hello" + str);//打印结果同上
//-
System.out.println(-1);//表示一个负数打印结果-1
System.out.println(21-12);//表示两个数相减，打印结果9
//*
System.out.println(1*2);//乘，打印结果2
// /
System.out.println(2 / 1);//两个整数相除结果也是整数，打印结果2
System.out.println(2.0 / 1 );//如果任何一个数是小数，则结果也是小数 2.0
// %
System.out.println(5 % -2); // 5 / 2 = 2...1 打印结果为1
System.out.println(-2 % 5);// -2 / 5 =0 ...2 打印结果 -2
int i = 45;
System.out.println(i % 10);//结果为5
System.out.println(i / 10);//结果为4
System.out.println(i / 10.0);//结果为4.5
}
}
(2).自增自减运算符
1、++，--
2、++：自增运算符
3、--：自减运算符
作用：在【变量】的基础上进行+1或者-1的操作
4、注意：
（1）++，——既可以写在 变量的前面，也可以写在变量的后面
（2）当i++和++i作为一条单独的语句存在的时候，++在前在后没有区别都是在变量的基础之上进行+1的操作
（3）当i++和++i做为表达式存在的时候，++在前，先运算（先进行+1）再取值，++再变量的后面，先取出变量的值，再进行+1的操作。
5.如下代码所示
int l = 10;
System.out.println(++l);//这里打印10 + 1 =11
System.out.println(l++);//这里也是11
System.out.println(--l);//这里相当于 12 - 1 = 11
System.out.println(l--);//这里也是11
//这就是作为表达式和单独语句的区别，不懂得话可以懂debug跑一下就明白了
System.out.println(l);//这里再打印就会变为10
(3).赋值运算符
1、用于给变量进行赋值的运算符
2、分类：
基础的赋值运算符 : =
扩展的赋值运算符 ： +=， -+， /+, *=, %=
3、基本的赋值运算符
将赋值运算符右边的值，赋值给左边的变量
4、扩展的赋值运算符
将运算的结果赋值给左边的变量
5.代码如下所示
//赋值运算符
// =
int k = 10;//这里的意思 不是 i等于10 ，而是把10这个值赋予给了i；将赋值运算符右边的值，赋值给左边的变量
// += -= *= /= %=
k += 20;//k = k + 20
System.out.println(k);//30
k %= 9;// k = k % 9;
System.out.println(k);//3
//以此类推
(4).比较运算符
1、用于做比较运算的运算符，比较两个数据大小关系的运算符
2、分类：
>,<,>=,<=:可以比较两个数据的大小关系
==，!=:比较两个数据是否相等的关系
3、运算结果：
布尔类型，只有true和false两种结果。
4.代码如下
// >,<,>=,<=
System.out.println(4 > 3);//true
System.out.println(4 < 3);//false
System.out.println(3 >= 3);//true
System.out.println(4 <= 4);//true
// 注意： 1 < a < 3，是不合法的
int a = 2;
// System.out.println(1 < a < 3);//java不支持 这种写法
System.out.println("0-------------------------");
// ==，!=
System.out.println(3 == 3);//false
System.out.println(4 != 3 );//true
(5).逻辑运算符
1、用于处理逻辑运算的使用的运算符
2、&&（逻辑与） &（按位与）
||（逻辑或） |（按位与）
3、&&：进行对逻辑值进行处理的时候，没有区别
全真为真，否则为假
true && true true
true && fasle false
false && true false
false && false false
4、||、逻辑或，全假为假，否则为真
true || true true
true || fasle true
false || true true
false || false false
注意：
boolean boo1 = (a > 20) && (b++ > 10);
boolean boo1 = (a > 20) & (b++ > 10);
&&，第一个表达式运算结果为false，那么就不会计算第二个表达式了。效率更高
&,按位与，即使第一个表达式运算结果为false，还会计算第二个表达式。
5、!;逻辑非，遇真为假，遇假为真
!true false
!false true
6、代码如下
// 逻辑运算符
// && 逻辑与 全真为真，否则为假
System.out.println(true & true);
System.out.println(true & false);
System.out.println(false & true);
System.out.println(false & false);
System.out.println("------------------------------------");
// || 逻辑或 全假为假，否则为真
System.out.println(true || true);
System.out.println(true || false);
System.out.println(false || true);
System.out.println(false || false);
// ! 逻辑非
System.out.println("----------------------");
System.out.println(!true);
System.out.println(!false);
// &按位与，以二进制计算 两位都是1的时候才会是1
System.out.println("-------");
System.out.println(4 & 2); // 4 = 0100 2 = 0010
//0100
//0010
//----
//0000
//所以运算结果为0
System.out.println(1 & 1);//0001 0001所以为1
System.out.println(2 & 2);//则为2 0010
System.out.println(3 & 3);//则为3 0011
System.out.println(101 & 110);//101 转二进制=0101 110转二进制=0110 最后结果则为100
//0101
//0110
//----
//0100
//0100二进制转换结果为100
(6).位移运算符
1、对于数据在内存中的表示，进行按照位移进行移动，以此达到进行运算的目的。
2、说明：只能操作整数类型的数据，运算结果还是一个整数
3、<<,>> ,>>>
4、<<;左移运算符，每次移动一位，会将原来的数字扩大2倍
5、>>:右移运算符，每移动一位，会将原来的数字缩小为原来的2分之1
6、>>>:无符号的右移：每移动一位，会将原来的数字缩小为原来的2分之1，这个只能针对正数使用。
7、代码如下
//位移运算符
//>> << >>>
System.out.println(-4 >> 2);//向右移动一位 除以2
System.out.println(-4 << 2);//向左移动一位 乘以2
System.out.println(4 >>> 2);//无符号右移，只能正数使用
(7).三元运算符
1、元：可以操作的数据或者表达式
2、三元运算符：同时可以操作三个数据或者三个表达式的运算符
3、运算符： ? : 将三个数据或者三个表达式进行分隔
4、格式：
表达式1（数据） ? 表达式2（数据） : 表达式3（数据）
5、说明
（1）表达式1（数据）运算结果必须是boolean类型，（boolean类型的表达式）
（2）表达式2和表达式3没有任何要求，可以是任意的数据或者表达式
6、运算流程
（1）计算表达式1的结果，结果只有两种，true或者false
（2）如果表达式1为true，就会将表达式2（数据2）作为整个三元表达式的值
（3）如果表达式1为false，就会将表达式3（数据3）作为整个三元表达式的值
7、注意：
（1）三元运算表达式，不能单独作为一条语句存在，除非定义一个变量接收三个运算表达式运算的结果，或者直接打印三元运算表达式的结果
（2）如果表达式2和表达式3,数据类型不一致,不能定义一个具体类型的变量进行接收,但是可以直接打印
//三元运算符
System.out.println(4 < 5 ? "正确" : "错误");// 4小于5吗？ 结果是ture 所以打印结果是第二条表达式为正确
System.out.println(4 > 5 ? "正确" : "错误");// 4大于5吗？ 结果是false 所以打印结果是第三条表达式为错误
//三元运算表达式，不能单独作为一条语句存在，除非定义一个变量接收三个运算表达式运算的结果，或者直接打印三元运算表达式的结果
String s = 4 < 5 ? "正确" : "错误";
System.out.println(s);
//如果表达式2和表达式3,数据类型不一致,不能定义一个具体类型的变量进行接收,但是可以直接打印
// char str = 4 < 5 ? "正确" : '错'; //这是一个错误语句,但是直接打印就没有问题
System.out.println(4 < 5 ? "正确" : '错');
二、键盘录入
1、键盘录入：在程序的运行过程中，可以让用户录入一些数据，存储到变量内存中，在后续的过程中，可以对该数据进行一些操作。
2、步骤：
第一步：导包，在类声明的上面，import java.util.Scanner;
第二步：创建键盘录入对象，Scanner sc = new Scanner(System.in);
第三步：调用Scanner中的nextInt()方法，实现键盘录入一个整数
int i = sc.nextInt();
第四步：就是对键盘录入的数据进行处理或者使用
//导的包，不需要手动，自动就能导包
import java.util.Scanner;
public class Scan {
public static void main(String[] args) {
//键盘录入
//创建键盘录入对象，Scanner sc = new Scanner(System.in);
Scanner scanner =new Scanner(System.in);
//调用Scanner中的nextInt()方法，实现键盘录入一个整数
System.out.println("请输入第一个数字");
int i = scanner.nextInt();
//调用几次nextInt()方法就录入几个整数
System.out.println("请输入第二个数字");
int j = scanner.nextInt();
System.out.println("j = " + j);
//对键盘录入的数据进行处理或者使用
i *= 20;
System.out.println("i =" + i);
//打印语句写哪里都无所谓，最终录入完以后才会进行打印
}
}
小练习
键盘录入一个整数，判断录入数字的奇偶
package Lian;
import java.util.Scanner;
public class Sca {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字");
int i = sc.nextInt();
String str = i % 2 == 0 ? "偶数" : "奇数";
System.out.println(str);
}
}
三、分支语句
1、顺序结构
从上到下，从左到右
2、程序到达某种状态的时候，可能会有多种情况，对于每种情况提前准备好，所以对于这种情况就成为分支结构
特点：代码写的多，程序运行的少
3、实现格式
if语句：if如果的意思，满足了特点条件，才能执行指定的代码，可以实现不同的逻辑
if()
if...else()
if...else if()...else if()...else if()....else
switch语句:根据指定的变量的值，匹配和该变量值相同的case语句，执行对应的代码
if语句第一种格式
public class If {
public static void main(String[] args) {
int i = 18;
if (i >= 18){//能够控制的代码，只限于if语句后的大括号中
System.out.println("成年了"); //如果大于等于18 则打印此语句
// 执行流程
// （1）计算布尔表达式的值，结果只有两种，要么为true要么为false
// （2）如果布尔表达式的值为true的时候，就会执行语句体
// （3）如果布尔表达式的值为false，不会执行语句体
}
}
}
if语句第二种格式
1、格式：
if(布尔表达式){
语句体1；
}else{
语句体2；
}
2、执行流程
（1）计算布尔表达式的值，结果只有true和false
（2）如果布尔表达式的值为true，就执行语句体1，if语句就结束了
（3）如果布尔表达式的值为false，就执行语句体2，if
3、注意：
语句体1和语句体2有没有可能够执行?
没有。
语句体1和语句体2有没有可能够不执行?
没有.至少要执行其中的一条语句。
import java.util.Scanner;
public class If2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的年龄");
int age = sc.nextInt();
if (age >= 18){
System.out.println("成年了，可以进网吧了");
}else{
System.out.println("未成年，回家写作业");
}
}
}
if语句第三种格式
1、格式：
if(条件表达式1){
语句体1；
}else if(条件表达式2){
语句体2；
}else if(条件表达式3){
语句体3；
}else if(条件表达式4){
语句体4；
}else if(条件表达式5){
语句体5；
}....else if(条件表达式n){
语句体n;
}else{
语句体n+1;
}
2、执行流程
（1）计算条件表达式1的值，如果为true，就执行语句体1，结束if。。。else if语句
（2）如果条件表达式1的值为false，计算条件表达式2的值，如果为true，就执行语句体2
（3）如果条件表达式2的值为false，，就计算条件表达式3的值，。。。以此类推
（4）如果条件表达式1-条件表达式n的值都为false，就会执行else中的内容
3、说明（注意）：
（1）最后的else是可以有，也可以没有的，如果有了else，那么对于if。。 else if语句而言，至少会执行一条语句
如果没有else那么if。。。else if语句就有可能一条语句都不执行
（2） 有没有可能同时执行多个语句体呢？
没有可能的，即使多个条件判断表达式都满足，只会执行第一个满足条件的语句体，执行完语句体后，if。。。else if语句就结束了，就不会向下再进行匹配了
import java.util.Scanner;
//if语句第三种格式
//能力值分类查找案例
public class If3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入要查找角色的能力值：");
int i =sc.nextInt();
if (i >= 95){
System.out.println("梅西 C罗 内马尔 阿扎尔 莫德里奇");
}else if (i >=90){
System.out.println("德布劳内 阿圭罗 拉莫斯 范戴克");
}else if (i >= 85){
System.out.println("哈兰德 桑乔 德莱赫特");
}
}
}
// 执行流程
// （1）计算条件表达式1的值，如果为true，就执行语句体1，结束if。。。else if语句
// （2）如果条件表达式1的值为false，计算条件表达式2的值，如果为true，就执行语句体2
// （3）如果条件表达式2的值为false，，就计算条件表达式3的值，。。。以此类推
// （4）如果条件表达式1-条件表达式n的值都为false，就会执行else中的内容
Switch语句
1、switch：切换，开关
2、格式：
swtich(表达式){
case 常量1：
语句体1；
break；
case 常量2：
语句体2；
break；
case 常量3：
语句体3；
break；
case 常量n：
语句体n；
break；
default：
语句体n+1；
}
case：情况
2、执行流程
（1）计算表达式的值，分别和case后的各个常量进行匹配
（2）如果和常量1匹配 ，就执行语句体1；再执行break；switch语句就结束了
（3）如果和常量1不匹配，那么就判断和常量2是否匹配，如果匹配了，就执行语句体2，执行break，结束swtich语句
（4）以此类推，如果常量1-常量n都没有和表达式的运算结果相匹配，那么就会执行default中的内容，遇到右大括号，结束swtich语句
import java.util.Scanner;
public class Swi {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的答案");
String d = scanner.next();//这里只能输入大写，不然会打印default中的内容，可以利用case穿透解决
switch (d){
case "A":
System.out.println("答案正确");
break;//打断，中断，结束switch语句
case "B":
System.out.println("答案错了");
break;
case "C":
System.out.println("答案错了");
break;
case "D":
System.out.println("答案错了");
break;
default://如果d在case中没有相对应的常量相匹配，最终就会执行default中的内容
System.out.println("有病？");
}//这个其实没必要用Scanner语句，我写着玩的
//// 执行流程
// （1）计算表达式的值，分别和case后的各个常量进行匹配
// （2）如果和常量1匹配 ，就执行语句体1；再执行break；switch语句就结束了
// （3）如果和常量1不匹配，那么就判断和常量2是否匹配，如果匹配了，就执行语句体2，执行break，结束swtich语句
// （4）以此类推，如果常量1-常量n都没有和表达式的运算结果相匹配，那么就会执行default中的内容，遇到右大括号，结束swtich语句
}
}
switch语句的注意事项
1、swtich：开关，切换
case：情况
break：中断，打断
default：默认
2、表达式（变量）：
类型是有要求的，一共只有六中
jdk1.5之前：byte short，char ，int
jdk1.5：枚举类型
jdk1.7：String
3、case后面只能跟的是常量，不能跟变量
4、每个case后面，一定要跟上一个break语句，作用：结束swtich语句，如果在case后面，不跟break语句，那么就无法正常的结束swtich语句。会发生case穿透。case穿透的利用：多个情况是相同的逻辑，那么就可以使用case穿透完成代码的简化。
5、default语句可以放在任意的位置，都是最后进行匹配的，如果不是放在最后，一定要注意case穿透问题，加上break
default，可以写也可以不写，如果写了，swtich语句至少要执行一条语句，如果不写swtich语句就有可能一条都不执行
public class Sw2 {
public static void main(String[] args) {
// switch语句的注意事项
// （1）表达式的运算结果或者变量的类型是有要求，必须是byte ，short ，char ，int，String ，枚举
// char c = 'A';
int i = 1;
// long l = 2;不可以
String str = "two";
switch(str) {
// default，可以写也可以不写
default://default语句可以放在任意的位置，都是最后进行匹配的，如果不是放在最后，一定要注意case穿透问题，加上break
System.out.println("没有此选项，你是学生吗");
break;
// case 'A':
// case 1:
case "one":
// case s:case后只能跟的是常量
System.out.println("one");
// break;// 如果不加break会发生case穿透，直接就执行到下个case中的语句，并不做匹配
// case 'B':
// case 2:
case "two":
System.out.println("two");
// break;
// case 'C':
// case 3:
case "three":
System.out.println("three");
break;
// case 'D':
// case 4:
case "four":
System.out.println("four");
break;
}
}
}
swtich语句练习
1、键盘录入一个月份，输出这个月份对应的季节
2、春季 3，4，5 夏季 6，7，8，秋季9，10，11冬季12，1，2
package Lian;
import java.util.Scanner;
public class Sw {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入月份");
int month = sc.nextInt();
switch (month){
case 3: //
case 4:
case 5:
System.out.println("春天");
break;
case 6: //
case 7:
case 8:
System.out.println("夏天");
break;
case 9: //
case 10:
case 11:
System.out.println("秋天");
break;
case 12: //
case 1:
case 2:
System.out.println("冬天");
break;
default:
System.out.println("请问你生活在火星吗？");
}
}
}
四、循环语句
1、日常生活中
日出日落，春夏秋冬
2、循环语句：对于某些需要重复执行的，相同的或者相似的代码，可以使用某种格式完成对这种重复代码的一种简写格式。
3、实现语句
for语句【常用】
while语句【常用】
do...while语句【不常用】
1、格式：
for(初始化语句表达式;循环条件判断表达式;初始化语句改变表达式){
循环体语句；
}
2、说明：
初始化语句表达式：声明一个变量，用于记录循环的次数。 int i = 0；
循环条件判断表达式：控制循环的执行条件，结果也是一个boolean类型 i < 10
初始化语句改变表达式：将初始化语句中的变量进行变化，一般是向着循环不能执行的方面进行变化。 i++；
循环体语句：要重复循环执行的代码。
3、执行流程
//忘记说了，千万别学我，我这些命名规则很有问题！！！！！
public class Fo {
public static void main(String[] args) {
// 老板，让你打印十遍老板娘真漂亮
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// System.out.println("老板娘真漂亮");
// 问题：重复性太高了
// 解决：使用java中提供的循环语句
// 循环语句：对于某些需要重复执行的，相同的或者相似的代码，可以使用某种格式完成对这种重复代码的一种简写格式。
// 使用循环语句完成对重复代码的改造
for (int i = 0; i <= 10; i++) {
// 要循环执行的代码
System.out.println("老板娘真漂亮");
}
}
}
五、日常练习
1、随意定义一个两位数的变量，分别获取这个两位数上的个位数字和十位数字并输出。
例如：
int i = 98;
打印结果：个位数字为：8,十位数字为：9
2、分析如下代码，写结果
int x = 10;
int y = 20;
int z = (x++) + (y++) + (--x+y);
不运算代码，分析出 x y z的值分别是多少？
3、键盘录入一个学生的成绩，int类型的分数，根据录入的分数，输出分数的等级
[90,100] 优秀
[80，90）良好
[60，80）及格
[0，60） 不及格
4、使用循环打印1-5，和5-1
5、使用循环打印1-100之间的偶数
package Lian;
public class L1 {
//1、随意定义一个两位数的变量，分别获取这个两位数上的个位数字和十位数字并输出。
public static void main(String[] args) {
int i = 23;
int l = 32;
System.out.println(i % 10);
System.out.println(l / 10);
}
}
x=10 y=20 31
import java.util.Scanner;
//键盘录入一个学生的成绩，int类型的分数，根据录入的分数，输出分数的等级
//[90,100] 优秀
//[80，90）良好
//[60，80）及格
//[0，60） 不及格
public class If3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入成绩");
int i =sc.nextInt();
if (i >=90 && i <= 100 ){
System.out.println("优秀");
}else if (i >=81){
System.out.println("良好");
}else if (i >= 60){
System.out.println("及格");
}else if (i <= 59){
System.out.println("不及格");
}else {
System.out.println("输入错误");
}
}
}
//4、使用循环打印1-5，和5-1
public class If3 {
public static void main(String[] args) {
for (int i = 1;i <= 5; i++){
System.out.println(i);
}
System.out.println("------------------");
for (int l = 5;l >=1;l--){
System.out.println(l);
}
}
}
浙公网安备 33010602011771号