Java学习笔记2024/1/30
1. 流程控制语句(没学完,接2024/1/29笔记)
1.3 分支结构的基础概念
1.3.1 if语句
package com.angus.processControlStatement.branchingStructure;
import java.util.Scanner;
public class test6_6 {
public static void main(String[] args) {
// 这篇test6_6对应note1和test6
// 是test6代码的改进
// 利用if语句的第三种格式
// 这个知识点做题
//题目:
/*
根据不同的分数送不同的礼物。
如果是95~100分，送自行车一辆
如果是90~94分，游乐场玩一天
如果是80~89分，送变形金刚一个。
如果是80分到0分，揍一顿。
*/
Scanner scanner = new Scanner(System.in);
System.out.println("输入分数");
int fenShu = scanner.nextInt();
// 这题也可以嵌套,写完之后再添一个if else语句就可以了,但是要注意是if将前面的包起来
// 有些题是连后面的else语句也写题目的小需求了,所以在最前面只用添个if语句将else前面的包起来就可以了
if (fenShu >=0 && fenShu <=100){
if (fenShu >= 95 && fenShu <= 100) {
System.out.println("送自行车一辆");//语句体1;
} else if (fenShu >= 90 && fenShu <= 94) {
System.out.println("游乐场玩一天");//语句体2;
} else if (fenShu >= 80 && fenShu <= 89) {
System.out.println("送变形金刚一个");//语句体3;
} else if (fenShu >= 0 && fenShu <= 80) {
System.out.println("揍一顿");//语句体4;
}
} else {
System.out.println("输入错误");//语句体n+1;
}
// 修改后的再次总结：先写完题目需求的代码，再去解决根据需求出现的问题，不要一股脑地就觉得自己碉堡了，想一口气把代码和想到的问题全写出来，这对于自己目前的能力还达不到,而且这样非常容易出问题，如果一旦卡住，这样反而更加浪费时间
// 随笔
// 我现在需要追求最朴实的记笔记方式，这样能让人一眼就看懂了，这就是对于我来说最好的记笔记方式，所以说不要太过于追求那些高大上的记笔记方式，找到适合自己的记笔记方式才是最好的，不然就是有心理疾病，虚荣心强
System.out.println("^^");
}
}
package com.angus.processControlStatement.branchingStructure;
import java.util.Scanner;
public class test7 {
public static void main(String[] args) {
// 随笔
// 有些不必要的笔记就不做了,不然学习进度太慢了
/*在实际开发中，多种情况判断时，会用到if的第三种格式：
需求：
商场都会有VIP的会员制，根据不同的会员会有不同的折扣。
假设商品总价为1000。
键盘录入会员级别，并计算出实际支付的钱。
会员1级：打9折。
会员2级：打8折。
会员3级：打7折。
非会员：不打折，要打也是打骨折。*/
// 随笔
// 还是得分析再写题啊,磨刀不误砍柴工嘛,古人真牛逼
// 分析: 1.if的第三种格式->else if语句,同时要注意有没有嵌套,有嵌套的话再加个if else语句
// 2.总价1000->定义变量价格为整数类型
// 3.键盘录入会员级别->变量为会员级别->定义变量vip级别为整数类型
// 4.计算->算术运算符
Scanner scanner = new Scanner(System.in);
System.out.println("键盘录入会员级别:1-3级");
int vip = scanner.nextInt();
int price = 1000;
if (vip>=1 && vip<=3){
if (vip==1){ // 有嵌套,先写小if,再写大if->先写完题目需求的代码，再去解决根据需求出现的问题->先解决小的,再去解决大的->小的: 3个vip等级,大的: 只有3个vip等级
System.out.println(price * 0.9);
} else if (vip==2) {
System.out.println(price * 0.8);
} else if (vip==3) {
System.out.println(price * 0.7);
}
}
else {
System.out.println("不打折");
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.branchingStructure;
public class test8 {
public static void main(String[] args) {
// if的3种格式总结
// 1->单条件判断
// 2->双条件判断
// 3>多条件判断
// 总结各种情况:
// 1.if语句
// 第一种格式:
// if(关系表达式){
// 语句体;
// }
// 2.if else语句
// 第二种格式:
// if(关系表达式){
// 语句体1;
// } else {
// 语句体2;
// }
// 3.else if语句(这个格式是只有三种情况的时候,如果超过就需要最后加个else)
// 第三种格式:
// if(关系表达式1[表判断]){
// 语句体1;[表执行]
// } else if(关系表达式2){
// 语句体2;
// } else if(关系表达式3){
// 语句体3;
// }
// 4.if else嵌套语句(在if里面嵌套)
// 第四种格式:
// if(关系表达式0){
// if(关系表达式1[表判断]){
// 语句体1;[表执行]
// } else if(关系表达式2){
// 语句体2;
// }
// ...
// }
// else {
// 语句体 n + 1 ;
// }
//这个题使用第三种情况
//汽车无人驾驶会涉及到大量的判断
//当汽车行驶的时候遇到了红绿灯，就会进行判断
//如果红灯亮，就停止
//如果黄灯亮，就减速
//如果绿灯亮，就行驶
if(false){
System.out.println("红灯亮");;
} else if(false){
System.out.println("绿灯亮");;
} else if(true){
System.out.println("黄灯亮");;
}
// 再次说明有时候直接使用字面量写更简单,不要有偏见
System.out.println("^^");
}
}
1.3.2 switch语句
package com.angus.processControlStatement.branchingStructure;
public class branchingStructureNote2 {
public static void main(String[] args) {
// 知识框架: 流程控制语句 -> 分支结构 -> switch语句
// 本章知识点: switch语句
// switch语句表选择
// switch语句格式
// switch(表达式){ // 注意这个表达式里输出的是值,不是表判断了
//
// case 值1: // case具有穿透性,若多个case重复,考虑使用case穿透去简化代码
// 语句体1;
// break; // break太多,想省略,使用 ->
// case 值2:
// 语句体2;
// break;
// ...
// default: // default 1.可以省略但不建议 2.位置建议放在最下面
// 语句体n+1;
// break;
//
// }
// 字面量: 字母,数字,字符,字符串本身的含义
// 变量: 压缩包,不是本身含义,里面包含着其他含义
System.out.println("^^");
}
}
// 快速注释: 块注释 Ctrl+Shift+/package com.angus.processControlStatement.branchingStructure;
public class branchingStructureDemo3 {
public static void main(String[] args) {
String noodles = "汤面";
switch (noodles){
case "拉面":
System.out.println("拉面");
break;
case "汤面":
System.out.println("汤面");
break;
case "炸酱面":
System.out.println("炸酱面");
break;
case "麻辣面":
System.out.println("麻辣面");
break;
default:
System.out.println("方便面");
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.branchingStructure;
public class branchingStructureDemo4 {
public static void main(String[] args) {
// break太多,想省略,使用 ->
String noodles = "汤面";
switch (noodles){
case "拉面" -> {
System.out.println("拉面");
}
case "汤面" -> {
System.out.println("汤面");
}
case "炸酱面" -> {
System.out.println("炸酱面");
}
case "麻辣面" -> {
System.out.println("麻辣面");
}
default -> {
System.out.println("方便面");
}
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.branchingStructure;
public class branchingStructureDemo5 {
public static void main(String[] args) {
// 只有一行代码时,大括号也可以省略
// 我嘞个豆,case里面一直有单独的大括号的,前面一直没写都没注意
// 咦,不对,糊涂了,是才出现的,是->出现的时候才有,但是->没出现的时候case也可以用但是没必要
// -> 的大括号可以省略是因为只有一行代码的时候
String noodles = "汤面";
switch (noodles) {
case "拉面" -> System.out.println("拉面");
case "汤面" -> System.out.println("汤面");
case "炸酱面" -> System.out.println("炸酱面");
case "麻辣面" -> System.out.println("麻辣面");
default -> System.out.println("方便面");
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.branchingStructure;
import java.util.Scanner;
public class test9 {
public static void main(String[] args) {
/*需求：键盘录入星期数，显示今天的减肥活动。
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿*/
Scanner scanner = new Scanner(System.in);
System.out.println("键盘录入星期数1-7，显示今天的减肥活动");
int re = scanner.nextInt();
switch (re){
case 1 : // int类型就是整数,直接写整数就ok了,String类型要写"",char类型要写''
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("输错了");
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.branchingStructure;
import java.util.Scanner;
public class test10 {
public static void main(String[] args) {
/* 需求：键盘录入星期数，输出工作日、休息日。
(1-5) 工作日，(6-7)休息日。*/
Scanner scanner = new Scanner(System.in);
System.out.println("键盘录入星期数1-7，输出工作日、休息日");
int re = scanner.nextInt();
switch (re) {
case 1, 2, 3, 4, 5:
System.out.println("工作日");
break;
case 6, 7:
System.out.println("休息日");
break;
default:
System.out.println("输入错误");
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.branchingStructure;
import java.util.Scanner;
public class test11 {
public static void main(String[] args) {
/* 在实际开发中，如果我们需要在多种情况下选择其中一个，就可以使用switch语句。
当我们拨打了某些服务电话时，一般都会有按键选择。
假设现在我们拨打了一个机票预定电话。
电话中语音提示：
1机票查询
2机票预订
3机票改签
4退出服务
其他按键也是退出服务。请使用swtich模拟该业务逻辑。*/
Scanner scanner = new Scanner(System.in);
System.out.println("按键选择1234");
int choose = scanner.nextInt();
switch (choose){
case 1 -> System.out.println("机票查询");
case 2 -> System.out.println("机票预订");
case 3 -> System.out.println("机票改签");
default -> System.out.println("退出服务");
}
System.out.println("^^");
}
}
1.4 循环结构的基础概念
package com.angus.processControlStatement.circularStructure;
public class note {
public static void main(String[] args) {
// 知识框架: 流程控制语句 -> 循环结构
// 本章知识点: 循环结构
// 三类:
// for循环
// while循环
// do...while循环
// for循环和while循环的区别
// for循环中: 知道循环的次数或者循环的范围
// while循环中: 不知道循环的次数和范围,只知道循环的结束条件
System.out.println("^^");
}
}
1.4.1 for循环
package com.angus.processControlStatement.circularStructure;
public class note1 {
public static void main(String[] args) {
// for循环
// 格式:
// for(初始化语句[第一步];条件判断语句[第二步][第五步][第八步];条件控制语句[第四步][第七步]){
// 循环体语句[第三步][第六步]; //重复执行的代码
// }
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class demo1 {
public static void main(String[] args) {
int i = 1;
for (;i <= 5;i++){
System.out.println("HelloWorld");;
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class test1 {
public static void main(String[] args) {
//需求1：打印1-5
for (int i=1;i<=5;i++){
System.out.println(i);;
}
System.out.println("--------");
//需求2：打印5-1
for (int a=5;a>=1;a--){
System.out.println(a);;
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class test2 {
public static void main(String[] args) {
/* 在实际开发中，需要重复执行的代码，会选择循环实现。
比如：如左图所示。玩游戏的时候，如果网不好那么会经常断线重连。
那么断线重连这个业务逻辑就需要重复执行。
假设现在公司要求，断线重连的业务逻辑最多只写5次。
请用代码实现。
备注：断线重连的业务逻辑可以用输出语句替代。*/
for (int i=1;i<=5;i++){
System.out.println("执行第"+i+"次断线重连");;
}
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class test3 {
public static void main(String[] args) {
/* 需求：在实际开发中，如果要获取一个范围中的每一个数据时，也会用到循环。
比如：求1-5之间的和*/
int sum = 0;
for (int i=1;i<=5;i++){
sum += i;
}
System.out.println(sum);
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class test4 {
public static void main(String[] args) {
/*需求：在实际开发中，如果要获取一个范围中的每一个数据时，会用到循环。
但是此时，大多情况下，不会获取所有的数据，而是获取其中符合要求的数据。
此时就需要循环和其他语句结合使用了。
比如：求1-100之间的偶数和*/
int sum = 0;
for (int i=1;i<=100;i++){
if (i % 2 == 0){ // 先判断再求和,1-100->偶数
sum += i;
}
}
System.out.println(sum);
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
import java.util.Scanner;
public class test5 {
public static void main(String[] args) {
// 快捷键: 变量名.fori
/* 需求：键盘录入两个数字，表示一个范围。
统计这个范围中。
既能被3整除，又能被5整除数字有多少个？*/
// 分析:
// 1.键盘录入->变量
// 2.范围->for
// 3.既..又..->&&
// 4.3整除,5整除->%3==0,%5==0->表判断
// 5.统计->打印count
Scanner scanner = new Scanner(System.in);
System.out.println("键盘录入一个数字，表示初始范围");
int start = scanner.nextInt();
System.out.println("键盘录入一个数字，表示结束范围");
int end = scanner.nextInt();
System.out.println("能3整除,5整除的都有哪些");
int count = 0;
for (int i = start; i <= end; i++) {
if (i % 3==0 && i % 5==0){
System.out.println(i);
count++;
}
}
System.out.println("几个");
System.out.println(count);
System.out.println("^^");
}
}
1.4.2 while循环
package com.angus.processControlStatement.circularStructure;
public class note2 {
public static void main(String[] args) {
// while语句
// 格式:
// 初始化语句;
// while(条件判断语句){
// 循环体语句;
// 条件控制语句;
// }
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class test6 {
public static void main(String[] args) {
/*需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，
假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?*/
// 只知道循环结果,用while
// 分析:
// 1.8844430 -> int定义
// 2.0.1 -> double定义
// 3.折叠 -> *2 ->
// 4.多少次 -> count
double paper = 0.1;
int height = 8844430;
int count = 0;
while (paper < height){
paper = paper * 2;
count++;
}
System.out.println(count);
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class test7 {
public static void main(String[] args) {
// temp 临时的意思
/*需求：给你一个整数 x 。
如果 x 是一个回文整数，打印 true ，否则，返回 false 。
解释：回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
例如，121 是回文，而 123 不是。*/
// 分析:
// 1.核心思路: 把倒过来的数字与原来的进行比较->用 == 直接比较就可以了
// 2.从右往左取值->要记得替换掉已经取的值
// 3.用一部分学过的公式->ge = /1%10
// 4.回文->循环->有判断
int x = 123;
int temp = x;
int i = 0;
while (x != 0){
int right = x / 1 % 10;
x = x / 10;// 我终于知道为什么一个变量经过运算变成一个新的变量还是用原来的变量名了,是为了循环的时候接着运算
i = i * 10 + right;
}
System.out.println(i == temp);
System.out.println("^^");
}
}
package com.angus.processControlStatement.circularStructure;
public class test8 {
public static void main(String[] args) {
/*需求：给定两个整数，被除数和除数（都是正数，且不超过int的范围） 。
将两数相除，要求不使用乘法、除法和 % 运算符。
得到商和余数。*/
// 分析:
// 1.定义被除数->int a
// 2.定义除数->int b
// 3.相除...->不断相减->用到循环->减的次数不知道那就用while
// 4.余数->减到不能减,剩下的那个被除数a
// 5.商->减的次数
int a = 10;
int b = 3;
int count = 0;
while (a > b){
a = a - b;
count = count+1;//直接写count++也可以
}
System.out.println("商为:" + count);
System.out.println("余数为:" + a);
System.out.println("^^");
}
}
1.4.3 do...while循环
package com.angus.processControlStatement.circularStructure;
public class note3 {
public static void main(String[] args) {
// do...while语句
// 用的非常的少,了解一下就OK了
// 格式:
// 初始化语句:
// do{
// 循环体语句;
// 条件控制语句;
// } while(条件判断语句);
// 先执行后判断
System.out.println("^^");
}
}
睡觉去喽