本文详细介绍了Java编程中的关键概念，包括运算符（算数、关系、逻辑、赋值和三目），类型提升，控制台录入方法，以及IF分支结构（单分支、双分支、多分支和嵌套）、switch分支和局部变量，以及while循环的运用。
目录
一、运算符
概述：参与运算的特殊符号 例如：+ - * / > = != 等
分类：算数运算符，关系运算符，逻辑运算符，赋值运算符，三目运算符
1.算数运算符
算数运算符：+ - * / % ++ --
//算数运算符：+ - * / % ++ --(单目)
double a = 1+2.5;
System.out.println(a); //3.5 两个数相加，最终结果为操作数最高的类型
int b = 5/2; //2 两个整数相除，最终结果取整
System.out.println(b); //2
int c = 5%2;
System.out.println(c); //1 模/取余运算符
int i = 3;
//i++:后置自增，先打印结果，变量的值后+1
//++i:前置自增，变量的值先+1,再打印结果
//i--:后置自减，先打印结果，变量的值后-1
//--i:前置自减，变量的值先-1,再打印结果
System.out.println(i++); //3 i=4
System.out.println(++i); //i=5 5
System.out.println(i--); //5 i=4
System.out.println(--i); //i=3 3 2.赋值运算符
//赋值运算符：= += -= *= /= %=
//基本赋值：=
//复合赋值：+= -= *= /= %=
int a = 1; //初始化赋值
a = 3; //基本赋值
System.out.println(a); //3
a += 2; //等价于a=a+2; -->5
System.out.println(a); //53.关系运算符
关系运算符： > >= < <= ==(等于) !=
规则：最终的计算结果为布尔类型，运算式子成立则为true，不成立则为false
//关系运算符：> >= < <= ==(等于) !=
System.out.println(5>3); //true
System.out.println(5>=3); //true
System.out.println(5<3); //false
System.out.println(5<=3); //false
System.out.println(5==3); //false
System.out.println(5!=3); //true
//说明：关系运算符很重要，因为后面的条件判断，循环，都需要关系运算符4.逻辑运算符
逻辑运算符： && || !
//逻辑运算符： && || !
//逻辑运算符和关系运算符类似，最终结果为true或false;区别在于，逻辑运算符的操作数结果为true或false
//&&：操作数两边为true，则结果为true
//||: 操作数两边为false，结果才为false
//!: true取反则为false；false取反则为true
System.out.println((5>3)&&(3<2)); //false
System.out.println(false&&true); //false
System.out.println(false||true); //true
System.out.println(!false); //true
//应用场景：数学的范围判断 10<x<15
int x = 12;
//System.out.println(10<x<15); //true不能参与关系运算
System.out.println((10<x)&&(x<15)); //true
//扩展应用： &逻辑与 |逻辑或
System.out.println((10<x)&(x<15)); //true
//分析特点：
//短路与&&：当第一个操作数为false时，不会执行第二个操作数
//逻辑与&： 当第一个操作数为false时，依然执行第二个操作数
//短路或||：当第一个操作数为true时，不会执行第二个操作数
//逻辑或|： 当第一个操作数为true时，依然执行第二个操作数
//验证特点：
System.out.println("==========完美分隔符============");
boolean a=true;
//测试&& 和 &
//System.out.println(false&&(a=false)); //false
//System.out.println(false&(a=false)); //false
//System.out.println(a); //为true，则没有执行第二个操作数；为false，则执行到了第二个操作数
//测试|| 和 |
//System.out.println(true||(a=false)); //true
System.out.println(true|(a=false)); //true
System.out.println(a); //为true，则没有执行第二个操作数；为false，则执行到了第二个操作数
//结论：后续常用短路&&和||，因为执行效率更高5.三目运算符
三目运算符： (关系表达式)?操作数1：操作数2
规则：关系表达式成立，则结果为操作数1；不成立则结果为操作数2
表达式：由运算符和操作数组成的式子 例如：1+2 算数表达式 5>3 关系表达式
应用场景：往往用于求最大值和最小值
//三目运算符：
String a = (5>3)?"结果为5":"结果为3";
System.out.println(a);
//应用场景：求最大值和最小值
int b = 5;
int c = 8;
int max = (b>c)?b:c; //最大值
int min = (b<c)?b:c; //最小值
System.out.println("最大值："+max);
System.out.println("最小值："+min);二、类型提升与控制台录入
1.类型提升
//类型提升：
//在进行算数运算时：
//1.运算结果为操作数中最高的类型
//2.操作数中，都是byte或short类型，最终结果为int类型
byte a = 1;
int b = a+2; //a+2--自动提升为int类型
System.out.println(b);
//字符串拼接+： 字符串类型与任意类型相加最终结果为String
String c = "aaa"+a;
System.out.println(c); //aaa12.控制台录入
步骤：
1.导包 导入包名下的类名
2.实例化控制台对象 Scanner对象
3.通过控制台对象调方法来获取控制台的值
import java.util.Scanner; //1.导包 导入控制台的类
public class Control{
public static void main(String[] args){
//2.实例化对象
Scanner sc = new Scanner(System.in); //new 对象
System.out.print("请输入一个数:");
//3.调用方法获取到控制台录入的值
//int a = sc.nextInt(); //nextInt:获取整数值 阻塞方法 常用
//String a = sc.next(); //next: 获取字符串的值 常用
//注意：如果是nextInt，则只能接收整数，如果内容不匹配，则会出现输入不匹配异常InputMismatchException
//扩展了解：
//double a = sc.nextDouble(); //nextDouble:接收小数 不常用
char a = sc.next().charAt(0); //获取输入字符串中的第一个字符 不常用
System.out.println("打印:"+a);
}
}三、IF分支结构
生活中的执行结构：
顺序结构：起床、刷牙、坐车、上学...
选择结构：上学选择交通工具--坐公交，做地铁，打车...
循环结构：重复性的每天敲代码...
程序中的执行结构：
顺序结构：从main方法出发，从头往下依次执行...
选择结构：IF，switch
循环结构：while，dowhile，for
1.IF单分支
import java.util.Scanner; //1.导包 导入控制台的类
public class If1{
public static void main(String[] args){
/*
语法结构：
if(关系表达式){
语句；
}
执行流程：关系表达式成立，则执行括号中的语句；不成立则不执行
案例：如果同学考试及格，则请全班吃饭
*/
Scanner sc = new Scanner(System.in); //实例化对象
System.out.print("请输入考试成绩:");
int score = sc.nextInt();
if(score>=60){
System.out.println("考试及格，请全班吃饭");
}
}
}
2.IF双分支
//if双分支结构：if，else
//语法结构:
/*
if(关系表达式){
语句1;
}else{
语句2;
}
执行流程：如果关系表达式成立，则执行语句1；否则，执行语句2
*/
//案例：如果不良人考试及格，则请全班吃饭；否则，全班安慰他
System.out.print("请输入考试成绩:");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score>=60){
System.out.println("考试及格，请全班吃饭");
}else{
System.out.println("很遗憾，不及格；以后就习惯了！");
}3.IF多分支
//if多分支结构 多选一
/*
if(关系表达式1){
语句1；
}else if(关系表达式2){
语句2；
}...
else if(关系表达式n){
语句n；
}else{
最后的语句；
}
执行流程：如果关系表达式1成立则执行语句1；否则，如果关系表达式n成立则执行n；否则，执行最后的
*/
//案例：根据钱包厚度决定请吃饭豪华度
/*
1万以上---海鲜大餐
1千以上---大排档
1百以上---麻辣烫
10元以上--快餐
否则------不吃
*/
System.out.print("请输入你的钱包金额:");
Scanner sc = new Scanner(System.in);
int money = sc.nextInt();
/*
if(money>=10000){
System.out.println("吃海鲜大餐");
}else if(money>=1000&&money<10000){
System.out.println("吃大排档");
}else if(money>=100&&money<1000){
System.out.println("吃麻辣烫");
}else if(money>=10&&money<100){
System.out.println("吃快餐");
}else{ //上面的条件都不成立，则执行else里的代码
System.out.println("没钱吃饭，先饿一顿！");
}*/
//优化：
if(money>=10000){
System.out.println("吃海鲜大餐");
}else if(money>=1000){ //隐含了money<10000
System.out.println("吃大排档");
}else if(money>=100){ //隐含了money<1000
System.out.println("吃麻辣烫");
}else if(money>=10){ //隐含了money<100
System.out.println("吃快餐");
}else{ //上面的条件都不成立，则执行else里的代码
System.out.println("没钱吃饭，先饿一顿！");
}
//特点整理：
//if往往用于判断个范围； if判断要么从小到大，要么从大到小
//if多分支往往后面需要加else更完整4.IF嵌套
//if嵌套：if语句中，又包含了if结构
//案例：输入学生的成绩，打印出对应的等级
/*
90-100 A
80~89 B
70~79 C
60~69 D
60以下 E
*/
System.out.print("请输入百分制成绩:");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score>=0&&score<=100){
if(score>=90){
System.out.println("A");
}else if(score>=80){
System.out.println("B");
}else if(score>=70){
System.out.println("C");
}else if(score>=60){
System.out.println("D");
}else{
System.out.println("E");
}
}else{
System.out.println("输入有误~请重新输入！");
}
//if嵌套特点：先执行外层的if，再执行内层四、switch分支
switch分支与if分支结构类似，都是用于选择结构；只是switch主要用于等值判断的匹配，而if主要用于判断一个范围
1.switch应用
//switch分支结构：
/*
swtich(变量){
case 值1：
语句1；
break； //跳出switch
case 值2：
语句2；
break;
...
case 值n:
语句n;
break;
default: //前面都不匹配，则执行default 类似if多分支的最后一个else
退出语句提示;
break；
}
执行流程：变量匹配case值，匹配上了，则执行里面的语句并退出；如果case都不匹配，则执行最后的default
*/
//案例：请打印一周的伙食：
System.out.print("请输入一周的伙食(1~5):");
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
switch(week){
case 1:
System.out.println("鲍鱼");
break; //如果没有break，则匹配上后，则会依次往下执行，直到遇到break
case 2:
System.out.println("猪脚饭");
break;
case 3:
System.out.println("泡面");
break;
case 4:
case 5: //特殊场景
System.out.println("馒头");
break;
default:
System.out.println("输入有误~");
break;
}2.switch匹配字符串
在JDK1.7之后，switch匹配的变量可以是byte,short,int,char,String等
//switch变量匹配字符串案例： //请输入四大美女的名字，打印对应的名号 System.out.print("请输入四大美女姓名："); Scanner sc = new Scanner(System.in); String name = sc.next(); switch(name){ case "王昭君": System.out.println("落雁"); break; case "貂蝉": System.out.println("闭月"); break; case "杨玉环": System.out.println("羞花"); break; case "西施": System.out.println("沉鱼"); break; default: System.out.println("你的输入有误~"); break; }小结：if和switch都是选择结构，但他们的应用场景不同：
往往if会更常用，if倾向于用在判断范围；switch倾向于用在等值匹配
五、局部变量
局部变量：在main方法中定义的变量，都是局部变量； 可以出现中方法的参数中，也可以出现在方法体中
特点：局部变量必须先赋值再使用，不赋值则会报错
作用域：就是有效范围，从定义处到方法体结束
变量重名问题：在重叠作用域下，不能用重名变量；否则冲突了
//int a; //定义局部变量，必须先赋值再使用
{ //{}表示代码块区域 局部变量的作用域则在代码块里面
int a = 3;
System.out.println(a);
}
int a = 5; //定义了重名变量，会冲突
System.out.println(a);六、循环
生活中的循环：重复的做某件事，做完后结束
程序中的循环：重复的执行某段代码，必须有退出的条件
1.while循环
//循环结构： while循环
/*
初始化语句；
while(条件判断){
语句体;
增量语句；
}
执行流程：
1.初始化语句---只执行一次
2.条件判断，如果成立则执行语句体；如果不成立，则执行跳出循环
3.条件判断成立，执行循环语句体
4.执行增量语句，再进入条件判断中(为条件判断服务，会改变条件判断的变量值)
*/
//案例：打印100遍“我爱java”;
int i = 1; //初始化语句
while(i<=100){ //条件判断；成立则执行循环体，不成立则跳出循环
System.out.println("我爱java..."+i); //循环语句体
i++; //增量语句，再回到条件判断
}
System.out.println(i); //最后i的值为101七、总结
1.运算符
各种运算符应用
算数（重点），赋值，关系(重点)，逻辑(重点)，三目等运算符
2.类型提升与控制台录入
类型提升：算数运算的提升与字符串拼接的提升
3.IF分支语句（重点）
单分支，双分支，多分支，if嵌套
4.switch分支
switch的基本应用及匹配String变量的应用
5.局部变量（重点）
理解概述，特点，作用域，重名冲突问题
6.循环（重点）
循环概述，while循环结构
扫一扫
552
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
