目录
2. break ,continue ,return 的区别及作用
一、注释
1. 简介
Java注释是程序中用来给代码添加解释、说明和注解的特殊文本。它们不会被编译器识别为代码的一部分，仅用于
人读取和理解代码。
Java注释有三种不同的形式：单行注释、多行注释和文档注释。
2. 解说
1、单行注释使用双斜杠（//）开始，可以在任何地方使用。
例如：
// 这是一个单行注释
int age = 20; // 初始化变量年龄为202、多行注释使用/开始，以/结束，可以跨越多行，但不能嵌套使用。
例如：
/*
这是一个多行注释
用于给代码块添加解释
*/
int score = 90; // 初始化变量分数为903、文档注释是一种特殊的多行注释，用于自动生成代码文档。它也使用/ 开始，以 / 结束，但是在注释内部可以
使用特定的标签和格式来提供详细的代码文档说明。
例如：
/**
* 这是一个文档注释示例
* 用于说明该类的功能、用途等
*/
public class MyClass {
/**
* 这是一个文档注释
* 用于说明方法的作用、参数、返回值等
* @param name 姓名
* @return 拼接后的字符串
*/
public String sayHello(String name) {
return "Hello, " + name + "!";
}
}需要注意的是，注释不会被编译器解释为可执行的代码，它们仅用于给程序员添加注解和解释。在实际运行时，
注释会被忽略掉。
3. 总结
Java 语言中提供了三种注释方式：单行注释、多行注释和文档注释。它们分别用于解释代码的意图、实现方式或
用途，并可以提高代码的可读性和可维护性。
二、访问修饰符
定义：Java中，可以使用访问修饰符来保护对类、变量、方法和构造方法的访 问。
Java 支持 4 种不同的 访问权限。
分类：
- private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部 类）
- default (即缺省，什么也不写，不使用任何关键字）: 在同一包内可见，不使用 任何修饰符。使用 对象：类、接口、变量、方法。
- protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意： 不能修饰类（外部 类）。
- public : 对所有类可见。使用对象：类、接口、变量、方法
访问修饰符图
三、标识符
Java 中，标识符是用来标识变量、类、方法等程序实体的名称。
标识符必须符合一定的命名规则，并且不能与 Java 的关键字和保留字重复。
Java 中的标识符命名规则如下：
- 标识符由字母、数字、下划线（_）和美元符号（$）组成。
- 标识符不能以数字开头。
- 标识符区分大小写。
- 标识符不允许使用 Java 关键字和保留字。
四、关键字
1. 简介
Java 中的关键字和保留字是有限的，它们有着特殊的含义，在代码中不能作为变量名或其他标识符。
关键字即Java自己保留的一些单词，作为特殊功能的，例如：public、class、byte、short、int、long、
double…
以下是 Java 中的 50 个关键字和保留字列表：
| 关键字 | 保留字 |
| abstract | assert |
| boolean | break |
| byte | case |
| catch | char |
| class | const |
| continue | default |
| do | double |
| else | enum |
| extends | final |
| finally | float |
| for | goto |
| if | implements |
| import | instanceof |
| int | interface |
| long | native |
| new | package |
| private | protected |
| public | return |
| short | static |
| strictfp | super |
| switch | synchronized |
| this | throw |
| throws | transient |
| try | void |
| volatile | while |
2. Java 有没有 goto
goto 是 Java 中的保留字，在目前版本的 Java 中没有使用。
3. final finally finalize
3.1. final 有什么用？
用于修饰类、属性和方法；
- 被final修饰的类不可以被继承
- 被final修饰的方法不可以被重写
- 被final修饰的变量不可以被改变，
- 被final修饰不可变的是变量的引用，而不是引用指向的内容，引 用指向的内容是可以改变的
3.2. final finally finalize区别
- final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、
修 饰变量表示该变量是一个常量不能被重新赋值。 - finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法
finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代 码。 - finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾 回收器来调用，当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾，一 个对象是否可回收的最后判断。
3.3. this & super
3.3.1. this关键字的用法
this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指 针。
this的用法在java中大体可以分为3种：
- 普通的直接引用，this相当于是指向当前对象本身。
- 形参与成员名字重名，用this来区分
- 引用本类的构造函数
3.3.2. super关键字的用法
super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离 自己最近的一个父类。
super也有三种用法：
- 普通的直接引用 与this类似，super相当于是指向当前对象的父类的引用，这样就可以用super.xxx来引用父类的成员。
- 子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区 分
- 引用父类构造函数
super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
3.3.3. this与super的区别
- super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函 数，
基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参） - this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；
如果函数的 形参与类中的成员数据同名，这时需用this来指明成员变量名） - super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其 它构造方法。
- super()和this()均需放在构造方法内第一行。 尽管可以用this调用一个构造器，但却不能调用两个。
- this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，
其它的构造 函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意 义，编译器也不会通过。 - this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
- 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
3.4. static
3.4.1. static存在的主要意义
static的主要意义是在于创建独立于具体对象的域变量或者方法。
以致于即使没有创建对象，也能使用属 性和调用方法！
static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。
static块可以置于类中 的任何地方，类中可以有多个static块。
在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时 候 执行一次。
因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。
3.4.2. static的独特之处
1、被static修饰的变量或者方法是独立于该类的任何对象，
也就是说，这些变量和方法不属于任何一个 实例对象，而是被类的实例对象所共享。
怎么理解 “被类的实例对象所共享” 这句话呢？
就是说，一个类的静态成员，它是属于大伙的【大 伙指的是这个类的多个对象实例，我们都知道一个类可以创建
多个实例！】，
所有的类对象共享 的，不像成员变量是自个的【自个指的是这个类的单个实例对象】…我觉得我已经讲的很通俗
了， 你明白了咩？
2、在该类被第一次加载的时候，就会去加载被static修饰的部分，而且只在类第一次使用时加载并进行 初始化，
注意这是第一次用就要初始化，后面根据需要是可以再次赋值的。
3、static变量值在类加载的时候分配空间，以后创建类对象的时候不会重新分配。
赋值的话，是可以任 意赋值的！
4、被static修饰的变量或者方法是优先于对象存在的，也就是说当一个类加载完毕之后，即便没有创建 对象，也
可以去访问。
3.4.3. static应用场景
因为static是被类的实例对象所共享，因此如果某个成员变量是被所有对象所共享的，那么这个成员变量 就应该定
义为静态变量。
因此比较常见的static应用场景有：
- 修饰成员变量
- 修饰成员方法
- 静态代码块
- 修饰类【只能修饰内部类也就是静态内部类】
- 静态导包
3.4.4. static注意事项
1、静态只能访问静态。
2、非静态既可以访问非静态的，也可以访问静态的。
五、运算符
1. 8 种运算符
1.1. 基本算数运算符
/ %
1.2. +符号做连接符
用于字符串拼接
1.3. 自增自减运算符
++ --
++ 、-- 只能操作变量，不能操作字面量
++ 、-- 既可以放在变量的后边,也可以放在变量的前边
如果单独使用放前后是没有区别的
如果非单独使用且在变量前,就会先进行变量自增/自减,再使用变量
如果非单独使用且在变量后,就会先使用变量,再进行变量自增/自减
1.4. 赋值运算符
= += -= *= /= %=
扩展赋值运算符隐含了强制类型转换
1.5. 关系运算符
== != > >= < <=
1.6. 逻辑运算符
&& ||
1.7. 位运算符
|：运算规则：只要两个数中的⼀个为1，结果就为1
&：运算规则：同为1，结果为1，否则为0
^：运算规则：不同为1，相同为0，即 0 ^ 0 = 0
<<：左移位
>>：带符号右移，如果是正数就补0，负数就补1
>>>：不带符号右移，无论正数还是负数，始终补0
~：取反，对数值的二进制位进行取反
1.8. 三元运算符
条件表达式 ? 值1 : 值2;
2. 运算符优先级
运算符优先级顺序是：! >算术运算符>关系运算符>&&>||>赋值运算符。
1、运算符优先级顺序
运算符优先级顺序：同一优先级的运算符，运算次序由结合方向所决定的。
简单的记就是：! >算术运算符>关系运算符>&&>||>赋值运算符。
结合性： 2、13 、14是从右至左其他都是从左至右。
2、优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。
表达式的结合次序取决于表达式中各种运算符的优先级。
优先级高的运算符先结合，优先级低的运算符后结合，同一行中的运算符的优先级相同。
3、C语言中大多数运算符的结合性都是从左往右，只有三个运算符是从右往左的。
一个是单目运算符，另一个是三目运算符，还有一个就是双目运算符中的赋值运算符 。
运算符的“结合性”也不需要死记硬背，在不断使用中就记住了。
3. &和&&的区别
&运算符有两种用法：(1)按位与；(2)逻辑与。
&&运算符是短路与运算。
逻辑与跟短路与的差别是非常巨大的，虽然二者都要 求运算符左右两端的布 尔值都是true 整个表达式的值才是
true。
&&之所以称 为短路运算，是因为如果&&左边的表达式的值是 false，右边的表达式会被直 接短路掉，不会进行
运 算。
注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。
4. 代码演示
4.1. 基本的算术算术运算符的使用
public class OperatorDemo1 {
public static void main(String[] args) {
// 基本的算术算术运算符的使用：+ - * / %
int a = 10;
int b = 3;
System.out.println(a + b);// 13
System.out.println(a - b);// 7
System.out.println(a * b);// 30
System.out.println(a / b); // 3.3333 ==> 3
System.out.println(a * 1.0 / b); // 3.3333
System.out.println(3 / 2);// 1
System.out.println(3 * 1.0 / 2); // 1.5
System.out.println(3 / 2 * 1.0); // 1.0
System.out.println(a % b); // 1
}
}4.2. 拆分3位数
需求：拆分3位数，把个位、十位、百位分别输出
public class OperatorTest2 {
public static void main(String[] args) {
// 需求：拆分3位数，把个位、十位、百位分别输出
int data = 589;
// 1. 个位
int ge = data % 10;
System.out.println(ge);// 9
// 2. 十位
int shi = data / 10 % 10;
System.out.println(shi);// 8
// 3. 百位
int bai = data / 100;
System.out.println(bai);// 5
}
}4.3. +符号做连接符的识别
public class OperatorDemo3 {
public static void main(String[] args) {
// 目标：+符号做连接符的识别
int a = 5 ;
System.out.println("abc" + 'a'); // abca
System.out.println("abc" + a); // abc5
System.out.println(5 + a); // 10
System.out.println("abc" + 5 + 'a'); // abc5a
System.out.println(15 + "abc" + 15); // 15abc15
System.out.println(a + 'a'); // 102
System.out.println(a + "" +'a'); // 5a
System.out.println(a + 'a'+" zhengge "); // 102 zhengge
System.out.println("zhengge"+ a + 'a'); // zhengge5a
System.out.println("zhengge"+ ( a + 'a' ));// zhengge102
}
}4.4. 自增自减运算符
public class OperatorDemo4 {
public static void main(String[] args) {
// 自增自减运算符： ++ --
int a = 10;
// a++; // a = a + 1
++a; // a = a + 1
System.out.println(a);// 11
int b = 10;
//b--; // b = b -1
--b;
System.out.println(b);// 9
System.out.println("------------------------------");
// ++ -- 在变量前面 先 +1 | -1 再使用。
int i = 10;
int j = ++i;
System.out.println(i); // 11
System.out.println(j); // 11
// ++ -- 在变量的后面 先使用再 +1 | -1
int m = 10;
int n = m++;
System.out.println(m); // 11
System.out.println(n); // 10
System.out.println("-------------------------");
int k = 3;
int p = 5;
// k 3 4 5 4
// p 5 4 3 4
// rs 3 + 5 - 4 + 4 - 5 + 4 + 2
int rs = k++ + ++k - --p + p-- - k-- + ++p + 2;
System.out.println(k); // 4
System.out.println(p); // 4
System.out.println(rs); // 9
}
}4.5. 赋值运算符
public class OperatorDemo5 {
public static void main(String[] args) {
// 赋值运算符：= += -= *= /= %=
int a = 10;
int b = 200;
// a = a + b;
a += b; // a = (int)(a + b)
System.out.println(a);// 210
byte i = 10;
byte j = 20;
// i = (byte) (i + j);
i += j; // i = (byte) (i + j);
System.out.println(i);// 30
int m = 10;
int n = 5;
//m += n;
//m -= n; // 等价于： m = (int)(m - n)
//m *= n; // 等价于： m = (int)(m * n)
// m /= n; // 等价于： m = (int)(m / n)
m %= n; // 等价于： m = (int)(m % n)
System.out.println(m); // 0
}
}4.6. 关系运算符
public class OperatorDemo6 {
public static void main(String[] args) {
// 关系运算符
int a = 10;
int b = 10;
boolean rs = a == b;
System.out.println(rs);// true
System.out.println(a == b);
System.out.println(a != b); // false
System.out.println(a > b); // false
System.out.println(a >= b); // true
System.out.println(a < b); // false
System.out.println(a <= b); // true
int i = 10;
int j = 5;
System.out.println(i == j); // false
System.out.println(i != j); // true
System.out.println(i > j); // true
System.out.println(i >= j); // true
System.out.println(i < j); // false
System.out.println(i <= j); // false
System.out.println(i = j); // 5 相等判断必须是 == 如果使用=是在进行赋值操作！
}
}4.7. 逻辑运算符
public class OperatorDemo7 {
public static void main(String[] args) {
// 逻辑运算符
double size = 9.8;
double storage = 6;
// 需求：尺寸大于等于6.95 内存要大于等于8GB
// 必须前后都是true结果才是true
System.out.println(size >= 6.95 & storage >=8);// false
// 需求：要么内存大于等于8 要么尺寸大于等于6.95
// 只要有一个是true 结果就一定是true
System.out.println(size >= 6.95 | storage >=8);// true
System.out.println(!true);// false
System.out.println(!false);// true
// 逻辑异或：必须两个不同结果才是true
System.out.println(false ^ true); // true
System.out.println(true ^ false); // true
System.out.println(true ^ true); // false
System.out.println(false ^ false); // false
System.out.println("-----------&& & || |的区别-------------------");
int a = 10;
int b = 20;
System.out.println(a > 100 && ++b > 10);// false
System.out.println(a > 100 & ++b > 10);// false
System.out.println(b);// false
int i = 10;
int j = 20;
System.out.println(i > 2 || ++j > 10);// true
System.out.println(i > 2 | ++j > 10);// true
System.out.println(j);// 20
}
}4.8. 三元运算符
public class OperatorDemo8 {
public static void main(String[] args) {
// 三元运算符
double score = 18;
String rs = score >= 60 ? "考试通过" : "挂科";
System.out.println(rs);// 挂科
// 需求：需要从2个整数中找出较大值
int a = 10000;
int b = 2000;
int max = a > b ? a : b;// 10000
System.out.println(max);
System.out.println("-------------------------");
int i = 10;
int j = 30;
int k = 50;
// 1、找出2个整数的较大值
int temp = i > j ? i : j;//
// 2、拿临时变量与第三个变量的值继续比较
int rsMax = temp > k ? temp : k;
System.out.println(rsMax);// 50
System.out.println("--------------------------");
int rsMax1 = i > j ? (i > k ? i : k) : (j > k ? j : k);
System.out.println(rsMax1);// 50
}
}4.9. 运算符优先级问题
public class OperatorDemo9 {
public static void main(String[] args) {
// 看看Java是否存在优先级，大家以后需要注意优先级问题
System.out.println(10 > 3 || 10 > 3 && 10 < 3); //true
System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false
}
}六、流程控制语句
1. 三种结构
1.1. 顺序结构
顺序结构是编程语言中最简单也是最基础的一种控制结构，它是程序从头到尾依次执行的过程。
Java 中的程序就是按照顺序结构来执行的，每条语句都会被依次执行。
在顺序结构中，程序会按照代码编写的顺序依次执行每个语句，并且每条语句只会执行一次。例如：
int x = 10;
int y = 20;
int z = x + y;
System.out.println(z);在这个例子中，程序首先执行变量声明语句，然后分别给变量 x 和 y 赋值，接着计算 x 和 y 的和并将结果赋值给
变量 z，最后输出变量 z的值。
需要注意的是，虽然顺序结构看上去十分简单，但在实际编程中，如果不合理地安排代码的执行顺序，就可能导
致程序出现错误或者异常。因此，在编写程序时，需要根据具体需求灵活地组织各条语句的顺序，以保证程序能
够正确、高效地运行。
总之：顺序结构是最简单也是最基础的一种控制结构，程序从头到尾依次执行每个语句。
在编写程序时，需要灵活地安排代码的执行顺序，以保证程序正确、高效地运行。
1.2. 分支结构
if
switch
表达式类型只能是byte、short、int、char，
JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long
case给出的值不允许重复且只能是字面量,即不能是变量
如果不写break跳出switch语句，会出现穿透现象
default就是case所给情况都不匹配，即会执行该默认代码
1.3. 循环结构
for循环
while循环
do-while循环
死循环
无限循环即如果没有其它条件干预循环，循环就不会停止下来
循环嵌套
循环嵌套即循环中又包含循环
跳转关键字
break：只能用于结束所在循环, 或者结束所在switch分支的执行
continue：跳出当前循环的当次执行进入下一次循环,且只能在循环中使用
break可以用在嵌套循环中跳出整个外部循环并立即结束它
continue可以用在嵌套循环中跳出外部循环的当次执行进入外部循环的下一次
应用场景
知道循环次数使用for，不知道循环次数建议使用while，
如果特殊要求必须先执行一次再判断循环条件那就用do-while
2. break ,continue ,return 的区别及作用
break 跳出总上一层循环，不再执行循环(结束当前的循环体)continue 跳出本次循环，继续执行下次循
环(结束正在执行的循环 进入下一个循环条件)
return 程序返回，不再执行下面的代码(结束当前的方法 直接返回)
3. 在 Java 中，如何跳出当前的多重嵌套循环
在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，
然后在里层循环体的代码中使 用带有标号的break 语句，即可跳出外层循环。
例如：
public static void main(String[] args) {
ok:
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println("i=" + i + ",j=" + j);
if (j == 5) {
break ok;
}
}
}
}4. Debug
Debug即断点调试(排错),可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况
标注 1：Show Execution Point ，显示执行端点(Alt + F10)；
标注 2：Step Over，跳到下一步(F8)；
标注 3：Step Into，进入代码或者说进入到方法内部(F7)；
标注 4：Force Step Into，强制进入代码或者说进入到方法内部(Alt + Shift + F7)；
标注 5：Step Out，跳到下一个断点或者跳出方法(Shift + F8)；
标注 6：Drop Frame，放弃当前 debug，重新执行 debug；
标注 7：Run to Cursor，运行到光标处(Alt + F9)；
标注 8：Evaluate Expression，评估表达式；
标注 9：View Breakpoints，查看断点，展示更多高级设置；
标注 10：Mute Breakpoints，置灰所有断点，再次点击，恢复；
标注 11：Get thread dunp，获得当前的线程堆栈。
5. 代码案例
5.1. 判断a和b的值是否相等
需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
public class IfDemo01 {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
if(a == b) {
System.out.println("a等于b");
}
//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
int c = 10;
if(a == c) {
System.out.println("a等于c");
}
System.out.println("结束");
}
}5.2. 判断a是否大于b
需求：
判断a是否大于b，如果是，在控制台输出：a的值大于b，如果不是，在控制台输出：a的值不大于b
public class IfDemo02 {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
b = 5;
// 需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，如果不是，在控制台输出：a的值不大于b
if(a > b) {
System.out.println("a的值大于b");
} else {
System.out.println("a的值不大于b");
}
System.out.println("结束");
}
}5.3. 输入星期数，输出对应星期几
需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
if
public class IfDemo03 {
public static void main(String[] args) {
System.out.println("开始");
//需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数(1-7)：");
int week = sc.nextInt();
if(week == 1) {
System.out.println("星期一");
} else if(week == 2) {
System.out.println("星期二");
} else if(week == 3) {
System.out.println("星期三");
} else if(week == 4) {
System.out.println("星期四");
} else if(week == 5) {
System.out.println("星期五");
} else if(week == 6) {
System.out.println("星期六");
} else {
System.out.println("星期日");
}
System.out.println("结束");
}
}switch
public class SwitchDemo {
public static void main(String[] args) {
System.out.println("开始");
//需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数(1-7)：");
int week = sc.nextInt();
switch(week) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的星期数有误");
break;
}
System.out.println("结束");
}
}5.4. 奇偶数
需求：任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还
是偶数。
/**
奇偶数
需求：
任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。
*/
public class IfTest01 {
public static void main(String[] args) {
//为了体现任意给出一个整数，采用键盘录入一个数据(导包，创建对象，接收数据)
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int number = sc.nextInt();
if(number%2 == 0) {
System.out.println(number + "是偶数");
} else {
System.out.println(number + "是奇数");
}
System.out.println("-------------------------");
}
}5.5. 考试奖励
需求：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可
以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
/*
考试奖励
需求：
小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，
奖励：
95~100 山地自行车一辆
90~94 游乐场玩一次
80~89 变形金刚玩具一个
80以下 胖揍一顿
*/
public class IfTest02 {
public static void main(String[] args) {
//小明的考试成绩未知，可以使用键盘录入的方式获取值
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个分数：");
int score = sc.nextInt();
//数据测试：正确数据，边界数据，错误数据
if(score>100 || score<0) {
System.out.println("你输入的分数有误");
} else if(score>=95 && score<=100) {
System.out.println("山地自行车一辆");
} else if(score>=90 && score<=94) {
System.out.println("游乐场玩一次");
} else if(score>=80 && score<=89) {
System.out.println("变形金刚玩具一个");
} else {
System.out.println("胖揍一顿");
}
}
}5.6. 春夏秋冬
/*
春夏秋冬
需求：
一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
春：3、4、5
夏：6、7、8
秋：9、10、11
冬：1、2、12
*/
public class SwitchTest {
public static void main(String[] args) {
//键盘录入月份数据，使用变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份：");
int month = sc.nextInt();
//多情况判断，这里采用switch语句实现
//在每种情况中，完成输出对应的季节
/*
switch(month) {
case 1:
System.out.println("冬季");
break;
case 2:
System.out.println("冬季");
//break;
case 3:
System.out.println("春季");
break;
case 4:
System.out.println("春季");
break;
case 5:
System.out.println("春季");
break;
case 6:
System.out.println("夏季");
break;
case 7:
System.out.println("夏季");
break;
case 8:
System.out.println("夏季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("秋季");
break;
case 11:
System.out.println("秋季");
break;
case 12:
System.out.println("冬季");
break;
default:
System.out.println("你输入的月份有误");
//break;
}
*/
//case穿透
switch(month) {
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
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;
default:
System.out.println("你输入的月份有误");
}
}
}5.7. 跳转语句
public class ControlDemo {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
if (i % 2 == 0) {
// continue;
break;
}
System.out.println(i);
}
}
}5.8. 存钱问题
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的
话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱。
/*
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱。
*/
public class ControlTest {
public static void main(String[] args) {
//小芳的妈妈每天给她2.5元钱
double dayMoney = 2.5;
//她都会存起来，涉及到了求和思想，定义求和变量，初始化值为0
double sumMoney = 0;
//存到100元钱
int result = 100;
//定义一个统计变量，用来纪录存钱的天数，初始化值为1
int dayCount = 1;
//因为不知道要多少天才能够存到100元，所以，这里我们采用死循环来实现，当存到100元的时候，通过break跳转语句让循环结束
while (true) {
//存钱
sumMoney += dayMoney;
//判断存的钱是否大于等于100了，如果是，就退出循环
if(sumMoney >= result) {
break;
}
//每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱
if(dayCount%5 == 0) {
sumMoney -= 6;
System.out.println("第" + dayCount + "天花了6元");
}
dayCount++;
}
//输出统计天数的变量
System.out.println("共花了" + dayCount + "天存了100元");
}
}5.9. do...while
/*
do...while循环结构
*/
public class DoWhileDemo {
public static void main(String[] args) {
int i = 1;
do {
System.out.println("HelloWorld");
i++;
} while (i<=5);
}
}
扫一扫
1866
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
