锦苏的个人笔记
首先声明：这个笔记是根据韩顺平老师，讲的Java课程全程来学习并且做笔记的，如果各位小伙伴们，需要从事Java行业那么从开始决定学习了，就不要放弃，三天打鱼两天晒网这是我的真实写照，我希望不是大家的真实写照，我这样的人都能够坚持下来，你们还有什么理由去放弃呢？在啰嗦几句，学习不是给谁学的，是给自己学的，我想告诉你们的是，无论是学习也好生活上做事的风格也好，都要抱有一种敬畏感，慢慢的审视自己，静下心来认真的思考，每一件小事的含义，去扣其中的细节方面，好好沉淀，事情不是一蹴而就的，慢下来才能够获得你想要的结果。
最后这是韩老师的Java课程，是我觉得最好的课程之一了。希望大家好好学习。
【【零基础 快速学Java】韩顺平 零基础30天学会Java】https://www.bilibili.com/video/BV1fh411y7R8?p=410&vd_source=dc4d55b1cc66d4054e9335ecd9dac61e
[TOC]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SYuG182M-1676275870698)(./assets/image-20221129172538774.png)]
2.填写项目名和项目路径，这里要强调一下，我们应该创建自己的代码路径，然后确保项目所属路径，万一错了里面的东西就很乱（强迫症患者）。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zNpeV2wk-1676275870699)(./assets/image-20221128223419752.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jugj2dmg-1676275870699)(./assets/image-20230128103354138.png)]
public class BianLinag {
//编写一个main方法
public static void main(String[] args) {
/* 1.
变量必须先声明 后使用
变量必须在该区域有变量名和类型(数据类型) 2.变量的三要素:1.值 2.变量名 3.数据类型 */
int a = 12;
System.out.println(a);
//int a=12; 不能在同一区域定义同一变量 a可以更改值 a=50;
a = 50; //a="jack" 报错
//更改a的值 a在同一数据类型变化就是说如果是int类型定义的a不能在其他数据类型使用
System.out.println("你好" + a);
/*2.
基本的数据类型 有以下几种主要是基本数据类型和引用类型
* 1.字节型: byte占一个字节 2.短整形: short占2个字节 3.长整型: (1)int 占4个字节 (2)long 占8个字节
* 2.浮点型(小数型):(1)float(单精度) 4个字节 (2) double 8个字节 (双精度)
* 3.布尔型:boolean 存放true 和false 真和假
* 4.String 引用类型:类,接口,数组.
*/
int n1 = 1; //Java整数默认为int类型 小数默认是double类型
long n2 = 1L;// 声明long必须后面加'l' 'L'
double n3 = 1.1f; // 声明float必须后面加'f' 'F'
char n4 = 'a';
System.out.println((int) n4);//输出他的数字型加int System.out.println((int)n4);
String sb="1";
int sb1=Integer.parseInt(sb);
System.out.println(sb1);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0AZqDqdk-1676275870700)(./assets/image-20230128103115741.png)]
int a = 11;
a++; //自增 a = a+1 自身使用的时候都是一样的效果
++a; //自增 a = a+1
System.out.println("a=" + a);
/*作为表达式的时候
前++: ++a先增加后赋值
后++: a++先赋值后增加
*/
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-skU4oQ94-1676275870700)(./assets/关系运算符.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T4rterQd-1676275870700)(./assets/image-20221111105241249.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GxtuK4bC-1676275870701)(./assets/image-20221111115105372.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mw87r4BX-1676275870701)(./assets/image-20221111115657989.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XjIYpEgS-1676275870701)(./assets/image-20221111120200124.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w2U3sEt9-1676275870701)(./assets/image-20221111210728012.png)]
规则
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QvIOeCkQ-1676275870702)(./assets/image-20221112145108743.png)]
区别
代码演示
int i = 15;
int j = 50;
if (i > 20 && ++j <100 ){
System.out.println("ok200");
} //因为 i>20是错的所以后面的直接就不在判断就不能输出
System.out.println("i=" + i + "j=" + j );
if (i>20 & ++j < 100 ){
System.out.println("ok200");
} //都为假所以不能输出 "ok200"
System.out.println("i=" + i + "j=" + j ); //i=20 j=51
//因为逻辑非还要判断后面的 ++j 所以 j=51
规则
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bU6CmyrJ-1676275870702)(./assets/image-20221112144904977.png)]
区别
例子
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KXMT9n4r-1676275870702)(./assets/image-20221112143512537.png)]
代码演示
//逻辑或(|) 和 短路或(||)
//1.短路或(||): 如果第一个判断为真的话后面的判断直接不执行
//2.逻辑或 (|): 不管第一个判断是否为真为假后面的都要判断
int s = 20;
int b = 50;
//短路或 ||
if (s < 21 || ++b > 60){
System.out.println("ok200");
} //s>21为真直接判断为真执行 不判断++b b=50
System.out.println( "s=" + s + "\t" +"b=" + b );
//逻辑或 |
if (s < 21 | ++b > 60){
System.out.println("ok200");
}
System.out.println( "s=" + s + "\t" +"b=" + b );
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8mOdPK0A-1676275870703)(./assets/image-20221112213317373.png)]
//取反 F <-> T; 两个互换
System.out.println("60>20");//T
System.out.println("!(60>20)");//F
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EJN9zGaf-1676275870703)(./assets/image-20221112235928971.png)]
介绍
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HCbxj6U1-1676275870703)(./assets/image-20221114091227906.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vyp52yvv-1676275870703)(./assets/image-20221114093051002.png)]
介绍 口诀一真大师
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dmvts2Xr-1676275870704)(./assets/image-20221114094454170.png)]
int a= 20;
int b= 66;
//a>b 为F
int c= a>b ？ a++ : b++;//为f返回b的值 先返回然后在+1 b=67 c=66
System.out.println("a=" + a +"\n"+ "b=" + b + "\n" + "c=" + c); //分别 a=20 b=67 c=66
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ewgw4h75-1676275870704)(./assets/image-20221114101609003.png)]
表达式1和表达式2不能要赋给可以接收的变量的类型（或可以自动转换的类型）
运算符的优先级
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YlUB82TP-1676275870710)(./assets/image-20221114125311628.png)]
1.包名小写，类名首字母大写
//引入Java.util下的Scanner类
import java.util.Scanner;
public class love {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
// myScanner是Scanner的对象
System.out.println("你的名字");
String name =myScanner.next();
System.out.println("你今年多大了");
int age = myScanner.nextInt();//接收用户输入int
System.out.println("输入你的薪水");
double Gender = myScanner.nextDouble();
System.out.println("人的信息如下"+"\n"+"名字="+name+ "\t" +"年龄"+ age + "\t"+"薪水"+Gender);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PVkgNpHB-1676275870710)(./assets/image-20221114150805285.png)]
00010111
1+2+4+0+16=23
0235
5+24+128=157
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oW3tmsCm-1676275870711)(./assets/image-20221114182403932.png)]
0x234
4+3*16+2*16*16=564
####二进制转八进制
把二进制拆分为3组在进行计算
11010100
(11)(101)(100)=354
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-knrD9t4B-1676275870711)(./assets/image-20221114185029079.png)]
把二进制拆分为2组在进行计算
10100101
(1010)(0101)=A5
236
可以看成(10)(011)(110)=10011110
1456
(0001)(0100)(0101)(0110)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0fznh5iv-1676275870711)(./assets/image-20221115151837815.png)]
概念：原码就是符号位加上真值的绝对值，第一位用符号位表示其余位表示值
[+1] 原=0000 0001
[ -1] 原=1000 0001
因为第一位是符号位，所以8位二进制的取值范围是：
[1111 1111 0111 1111] 即[-127,127]
反码的表示方法是:
正数的反码是其本身
负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.
[+1] = [00000001] 原 = [00000001]反
[-1] = [10000001] 原 = [11111110] 反
补码的表示方法是:
正数的补码就是其本身
负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1 (即在反码的基础上+1)
[+1] = [00000001]原 = [00000001]反 = [00000001]补
[-1] = [10000001]原 = [11111110]反 = [11111111]补
二. 为何要使用原码, 反码和补码
计算机可以有三种编码方式表示一个数.
对于正数因为三种编码方式的结果都相同:
[+1] = [00000001]原 = [00000001]反 = [00000001]补
但是对于负数:
[-1] = [10000001]原 = [11111110]反 = [11111111]补
机器可以只有加法而没有减法
计算十进制的表达式: 1-1=0
如果用原码表示：
1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2
让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用 原码表示一个数.
如果用反码表示:
1 - 1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原
= [0000 0001]反 + [1111 1110]反
= [1111 1111]反
= [1000 0000]原
= -0
用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在"0"这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有[0000 0000]原和[1000 0000]原两个编码表示0.
用补码表示:
1-1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原
= [0000 0001]补 + [1111 1111]补
= [0000 0000]补
=[0000 0000]原
=0
这样0用[0000 0000]表示, 而以前出现问题的-0则不存在了.而且可以用[1000 0000]表示-128:
(-1) + (-127) = [1000 0001]原 + [1111 1111]原
= [1111 1111]补 + [1000 0001]补
= [1000 0000]补
=-128
注：-1-127的结果应该是-128, 在用补码运算的结果中, [1000 0000]补 就是-128. 但是注意因为实际上是使用以前的-0的补码来表示-128, 所以-128并没有原码和反码表示.(对-128的补码表示[1000 0000]补算出来的原码是[0000 0000]原, 这是不正确的)
使用补码, 不仅仅修复了0的符号以及存在两个编码的问题, 而且还能够多表示一个最低数. 这就是为什么8位二进制, 使用原码或反码表示的范围为[-127, +127], 而使用补码表示的范围为[-128, 127].
(-1) + (-1) = [1000 0001]原 + [1000 0001]原
= [1111 1111]补 + [1111 1111]补
= [1111 1110]补 //负数原码=补码-1，再同位取反，符号位不变
=[1000 0010]原
=-2
因为机器使用补码, 所以对于编程中常用到的32位int类型, 可以表示范围是: [-231, 231-1] 因为第一位表示的是符号位.而使用补码表示时又可以多保存一个最小值.
7位位运算符分别是（&，|，^，~，>>、<<和>>>）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dQYMcDoU-1676275870711)(./assets/image-20221115155009035.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BCRxnRrQ-1676275870712)(./assets/image-20221115210224806.png)]
1001 0101
——————————
0101 1001
0001 0001//结果
案例
//推导按位与计算的过程(&) 两位全是1 结果为1 否则为0
System.out.println(3&5);//结果为1 推导如下
//1.先得到它的原码
//因为正数的三码都是一样的所以我们得到3的补码为下
//int占4个字节 第一位为0 得到3的补码
// 00000000 00000000 00000000 00000011
//5的补码同上面推导的一样 为下
// 00000000 00000000 00000000 00000101
//2.计算他们的补码
// 00000000 00000000 00000000 00000011
// 00000000 00000000 00000000 00000101
// 00000000 00000000 00000000 00000001//得到计算后的补码
//但是计算机是以运算后的原码呈现的所以我们要的得到计算他的原码 正数三码相等 所以就是一样的
0110 1001
—————————
1101 0110
_________
1111 1111//结果
案例
//推导按位或 2|3 两位有一个1结果为1 否则为0
System.out.println(2|3); //结果为三 推导如下
//1.得到2的原码 2: 00000000 00000000 00000000 00000010
//得到3的原码 3: 00000000 00000000 00000000 00000011
//正数三码合一,补码同上
//2.计算补码
// 00000000 00000000 00000000 00000010
// 00000000 00000000 00000000 00000011
// 00000000 00000000 00000000 00000011
案例
//推导按位异或 ^ (5^6) 两位有一个为1，一个为0结果为1 否则为0
System.out.println(5^6);//结果为3 推导如下
//1.得到原码 5: 00000000 00000000 00000000 00000101
//2.得到原码 6: 00000000 00000000 00000000 00000110
//三码合一 补码同上
//计算补码
// 00000000 00000000 00000000 00000000 000000101
// 00000000 00000000 00000000 00000000 000000110
// 00000000 00000000 00000000 00000000 000000011
1100 0111
_________
0100 0001
—————————
1000 0110//结果
0000 1110
—————————
1111 0001//结果
案例
System.out.println(~ -6); //结果为5 推导如下
//1.先得到原码 10000000 00000000 00000000 00000110
//因为负数得补码=反码+1 所以先把原码取反 符号位不变
//取反 11111111 11111111 11111111 11111001 得到补码
// 按位取反 0->1 1->0
// (~ -6) 最后得到 00000000 00000000 00000000 00000110
int a= 4 >> 3 ; // 4/(2^3)=0
//4的原码 00000000 00000000 00000000 00000000 (100)补出来的
int b = 4<<3 ; //4*(2^3)=32
//原码： 00000000 0000000 00000000 00（1）00000 本来是00000100
int c = 4 >>>3 ;
//00000000 00000000 00000000 00000100 1向右溢出3 > 00000000
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JeoBzpMd-1676275870712)(./assets/image-20230128102636415.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hufyzp3P-1676275870712)(./assets/image-20221116083350122.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bl9Cpe1G-1676275870712)(./assets/image-20221116084453370.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7HqtcrZl-1676275870712)(./assets/image-20221116095904317.png)]
import java.util.Scanner; //引入Scanner
public class SequentialControl {
public static void main(String[] args) {
//顺序结构
//1. 单分支练习
// 判断刘钊成是18岁 如果是就输出"奖励你单身100年"
Scanner scanner = new Scanner(System.in);
System.out.println("请输入刘钊成年龄");
int age =scanner.nextInt();
System.out.println("小刘单身多少年");
String dans = String.valueOf(scanner.nextInt());
if (age ==18 ){
System.out.println("奖励你单身100年");
}else {
System.out.println(dans+"单身100年去吧");
}
}
}
判断一个年份是否为闰年 条件符合一下二者之一
1.能被4整数 但不能被100整除;2.能被400整除
代码如下:
import java.util.Scanner; //引入Scanner
public class Practice01 {
public static void main(String[] args) {
// 条件:1. 年份能被4整除 但不能被100整除 和 2.能被400整除 两个条件是或的关系
//定义 year为年份
// 条件1解析 year % ==0 && 100 !=0
//条件2解析 year %
Scanner scanner = new Scanner(System.in);
System.out.println("请输入年份");
int year =scanner.nextInt(); //接受用户输入的年份
if ((year % 4 == 0 && year % 100 != 0) || year / 400 == 0 ){
System.out.println(year+"是闰年");
}else {
System.out.println(year+"不是闰年");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dd5s3QXT-1676275870713)(./assets/image-20221116201450754.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W6sp9MBs-1676275870713)(./assets/image-20221116205953471.png)]
用我的话来表达吧:第一条语句为真直接执行为假就执行下一条语句以此类推直到为真如果全是错那么就执行else里面的代码
/*判断陈鹏的芝麻信用分:
1.为大于200,输出信用极好
2.在100-200之间输出信用优秀
3.80-100之间为良好 其他情况为信用不及格
*/
import java.util.Scanner; //引入Scanner
public class MultibranchDemon {
public static void main(String[] args) {
//用多分支嵌套来实现上面的题目要求
//思路分析 先定义一个 credit 表示芝麻信用
//第一层如果是 credit ==250 就输出信用极好 不是250
// 就判断 100 < credit < 200 输出
// 80 < credit <150
//代码实现
Scanner scanner = new Scanner(System.in);
System.out.println("请输入陈鹏的芝麻信用分");
int credit = scanner.nextInt();
if (credit>200){
System.out.println("陈鹏的信用为"+credit+"信用极好");
}else if (credit>100 && credit<=200){
System.out.println("陈鹏的信用为"+credit+"信用优秀");
}else if (credit>=80 && credit<=100){
System.out.println("陈鹏的信用为"+credit+"信用良好");
}else {
System.out.println("陈鹏的信用为"+credit+"信用不及格");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-brozIG8D-1676275870713)(./assets/image-20221116220605192.png)]
/**题目:
* 参加歌手比赛,如果初赛成绩大于11.0进入决赛否则提示淘汰,并根据性别提示进入男子组或者女子组;
* */
import java.util.Scanner;
public class Branch01 {
public static void main(String[] args) {
//嵌套分支
//分析 得分 score double 类型定义分数 gender 定义男女
//分数大于11.0 进入进入下一级判断
//代码实现
Scanner scanner = new Scanner (System.in); //new 一个scanner对象
System.out.println("输入决赛成绩");
double score = scanner.nextDouble();
if ( score >11){
//大于11.0进入决赛
System.out.println("请输入性别"); //进去性别输入
char gender = scanner.next().charAt(0);
if (gender == '男'){
System.out.println("进入男子组决赛"); //输入男提示
}else if (gender == '女'){
System.out.println("进入女子组决赛"); //同上
}else{
System.out.println("输入有误请重新输入");
}
}else {
System.out.println("sorry,你被淘汰了");
}
}
}
出票系统: 根据淡旺季的月份和年龄，打印票价
4 -10 旺季:
成人(18-60) : 60 儿童 (<18) : 半价 老人 (>60) :1/3
淡季:
成人: 40其他: 20
/**
* 出票系统: 根据淡旺季的月份和年龄，打印票价
* 4 -10 旺季:
* 成人(18-60) : 60 儿童 (<18) : 半价 老人 (>60) :1/3
* 淡季:
* 成人: 40其他: 20
*/
//思路分析 month 定义月份 年龄 定义
//month>=4 && mon<=10 就 进入
import java.util.Scanner;
public class Branch02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入月份:");
int month = scanner.nextInt();
System.out.println("请输入年龄:");
int age = scanner.nextInt();
if (4 <= month && month <= 10) {
if (18 <= age && 60 >= age) {
System.out.println("成人票价为60");
} else if (age > 0 && 18 > age) {
System.out.println("小孩票价为30");
} else if (age > 60) {
System.out.println("老人的票价为20");
} else {
System.out.println("别瞎搞好好输入年龄");
}
} else if (18 <= age && 60 >= age) {
System.out.println("成人票价为40");
} else if ((age > 0 && age <= 18) || (age > 60 && age <= 100)) {
System.out.println("票价为20");
} else {
System.out.println("别瞎搞好好输入年龄");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hh2x95Id-1676275870713)(./assets/image-20221117180236314.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nE6nCeRR-1676275870714)(./assets/image-20221117195017272.png)]
/**案例 学习switch语句
* 请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
* a 表示星期一，b 表示星期二 …
* 根据用户的输入显示相应的信息.要求使用 switch**/
import java.util.Scanner;
public class Switch {
public static void main(String[] args) {
Scanner myscanner = new Scanner(System.in);
System.out.println("输入今天周几:");
char week = myscanner.next().charAt(0);
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("周四学Java");
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("switch语句结束,程序继续");
}
}
Switch细节
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3WUFQrwe-1676275870714)(./assets/image-20221117211909775.png)]
1.使用 switch把小写类型的char型转为大写(键盘输入)。只转换a, b,c, d, e.
其它的输出other
import java.util.Scanner;//引入键入值
public class switch02 {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入要转换的字母:");
char a = myScanner.next().charAt(0);
switch (a){
case 'a':
System.out.println("转换的结果为A");
break;
case 'b':
System.out.println("转换的结果为B");
break;
case 'c':
System.out.println("转换的结果为C");
break;
case 'd':
System.out.println("转换的结果为D");
break;
case 'e':
System.out.println("转换的结果为E");
break;
default:
System.out.println("other");
}
}
}
2.对学生成绩大于60分的， 输出"合格"。低于60分的，输出"不合格"。(注:输入
的成绩不能大于100),提示成绩/60
double score = 1;
if (score >= 0 && score <= 100){
switch ((int)(score/60)){ //强转为int
case 0:
System.out.println("成绩不合格"+score);
break;
case 1:
System.out.println("成绩合格"+score);
break;
}
}else {
System.out.println("请输入正确的成绩");
}
3.根据用于指定月份， 打印该月份所属的季节。3,4,5 春季6,7,8夏季9,10,11
秋季12,1,2冬季 [课堂练习，提示使用穿透]
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入月份:");
int month = myScanner.nextInt();
switch (month){
case 12:
case 1:
case 2:
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;
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cu19bGsv-1676275870714)(./assets/image-20221118083102921.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b6U0zJvt-1676275870714)(./assets/image-20221118091732074.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OfaBMnqb-1676275870715)(./assets/image-20221118094954155.png)]
int count=3;
for (int i=0,j=0; i<count; i++,j+=2){
System.out.println("i="+i+"j="+j);
}
//输出
//i=0j=0
//i=1j=2
//i=2j=4 i=2程序就结束了
//思路分析 先定义一个 变量来接受个数 number = 0;
//在定义一个变量来接受 总和 sum=0;
//接下来写代码
public class For02 {
public static void main(String[] args) {
int number = 0;//接受4的个数
int sum = 0; //总和
for(int i=0; i<100; i++){
if (i % 4 == 0){
System.out.println("i="+i);
number ++;//个数
sum +=i; //总和
}
}
System.out.println("个数="+number);
System.out.println("总和="+sum);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WdFMsFHs-1676275870715)(./assets/image-20221119100323124.png)]
public class For02 {
public static void main(String[] args) {
int sum = 5;
for (int i =0; i<=sum ; i++){
System.out.println(i + "+"+(sum - i) +"="+sum);
} //化繁为简 先死后活
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CFFm3hRi-1676275870715)(./assets/image-20221119100854497.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b5uzbOUO-1676275870715)(./assets/image-20221119102329752.png)]
public class while01 {
//while循环 循环语句先执行然后执行循环迭代知道条件为假结束
//案例
//每天都要好好学习*10
public static void main(String[] args) {
int i =1;
while (i <=10){
//循环条件
i++; //循环语句
System.out.println("我亦无他,唯手而熟"+"*"+i);//循环迭代
}
}
}
public class while01 {
//while循环 循环语句先执行然后执行循环迭代知道条件为假结束
//案例
//1.打印 1-100之间所有能被3整除的数
//2.打印40-500之间的偶数
public static void main(String[] args) {
//1.化繁为简:先打印1-100之间的数
// int i = 0;
// while ( i < 100){
// i++;
// if (i % 3 == 0){
// System.out.println(i);
// }
// }
//2.化繁为简:先打印40-200之间的数
int j = 40; //初始变量
while (j <= 500){
if (j % 2 == 0){
System.out.println(j+"\t");
}
j++;
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E3I1EsjZ-1676275870715)(./assets/image-20221119125640447.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I7UG6sTo-1676275870716)(./assets/image-20221119134123345.png)]
public class DoWhile {
public static void main(String[] args) {
//使用do..while循环输出10句每天都要好好学习
int a = 1; //初始化变量
do {
System.out.println("每天都要好好学习"+a);//循环语句
a++;//循环迭代
}while(a<=10);//循环条件
}
}
1)打印1-100 [学生做]
2)计算1- -100的和[学生做]
3)统计1- 200之间能被5整除但不能被3整除的个数 (DoWhileExerc
4)如果李三不还钱，则老韩将一直使出五连鞭， 直到李三说还钱为止
[System.out.println(“老韩问:还钱吗? y/n”)] do…while
/**
1)打印1-100
2)计算1- -100的和
3)统计1- 200之间能被5整除但不能被3整除的个数
4)如果李三不还钱，则老韩将一直使出五连鞭， 直到李三说还钱为止
[System.out.println("老韩问:还钱吗? y/n")] do...while*/
public class DoWhile {
public static void main(String[] args) {
//1)打印1-100
//2)计算1- -100的和
int i = 1;//初始化变量
int j = 0;//计算i的和
do {
System.out.println(i);//循环语句
++i; //循环迭代
j += i;
}while (i <= 100);
System.out.println("总和为"+j);
System.out.println("=================");
//3)统计1- 200之间能被5整除但不能被3整除的个数
int a =1 ;//初始化变量
int b =0 ;//能被五和三整除的变量
int c =5 ;//定义不能5的变量
int d =3 ;//3的变量
do {
if (a % c == 0 && a % d !=0){
//如果判断是对的就执行这里
System.out.println(a);
b++;
} a++;
}while (a <= 200); //循环条件
System.out.println("1-200之间能被5整除但不能被3整除的个数"+b+"个");
//4)如果李三不还钱，则老韩将一直使出五连鞭， 直到李三说还钱为止
// 思路先定义一个变量接受李三的回答
Scanner myScanner = new Scanner(System.in);
char answer =';';
do {
System.out.println("闪电五连鞭");
System.out.println("你还钱吗?y/n");
answer = myScanner.next().charAt(0);
System.out.println("他的回答是:"+answer);
}while (answer != 'y');//只要不等于y就不执行这个条件了
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AfTb28X3-1676275870716)(./assets/image-20221119190720598.png)]
public class for03 {
//双重for 执行
public static void main(String[] args) {
for (int i =0 ;i < 3 ; i++ ){
for (int j=0; j<4 ;j++){
//这个for循环可以看成里面的循环语句
System.out.println("i="+i+"j="+j);
}
}//分析 先判断
// 第一次循环 i=0 j=0 i=0 j=1 i=0 j=2 i=0 j=3
// 第二次循环 i=1 j=0 i=1 j=1 i=1 j=2 i=1 j=3
// 第二次循环 i=2 j=0 i=2 j=1 i=2 j=2 i=2 j=3
}
}
1.统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
2.统计三个班及格人数，每个班有5名同学。
/**
* 1.统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
* 2.统计三个班及格人数，每个班有5名同学。
*/
import java.util.Scanner;
public class For04 {
public static void main(String[] args) {
//1. 化繁为简
//先统计一个班的成绩情况 i 表示班级 j表示同学
//2.统计三个班 计算3个班的平均分 b表示班级 g表示班级个数
//3.定义一个变量统计所有同学的分数 Total score
//4.定义一个变量及格的学生 passNum
Scanner myScanner = new Scanner(System.in);
int g = 3; //表示班级的个数
int j = 5; //表示班级同学的个数
double sum = 0;//用来接受班级的总分
double TotalScore =0 ;
int passNum =0;//定义及格的学生
for (int b = 1; b <= 3; b++){
for (int i = 1; i <= j; i++) {
System.out.println("请输入第个" + b +"个班第" + i + "个同学的成绩:");
double score = myScanner.nextDouble(); //score 来接收输入的分数
if (score >=60){
passNum++; //三个班及格的人数
}
sum += score;
System.out.println("成绩为:" + score);
}//内部循环语句
//sum 统计了所有班的成绩 把总分累计到TotalScore里去
TotalScore += sum;
System.out.println("第"+b+"班的平均分为" + (sum / j));
}
System.out.println("三个班的总分为="+TotalScore+"三个班的平均分为"+TotalScore/(j*g));
System.out.println("三个班的及格人数为"+passNum);
}
}
3.打印出九九乘法表
//3.打印出九九乘法表
public class for03 {
//双重for 执行
public static void main(String[] args) {
//打印九九乘法口诀表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + (i * j) + "\t");//不加ln就不换行
}
System.out.println("\n");//输出对了就换行
}
}
}
public class for05 {
public static void main(String[] args) {
/* 打印一个空心金字塔
*
* *
* *
* *
*********
思路分析:
1.先打印一个矩形
*******
*******
*******
*******
*******
2.打印半个金字塔
*
**
***
****
*****
3.打印整个金字塔
* //每层都是2*层数-1 有4个空格 空格=总层数-当前层
***
*****
*******
*********
4.打印空心金字塔
* //1-4层都是第一个位置* 第五层 全部都是*
* *
* *
* *
*********
5.先死后活 定义总层数的变量 TotalLayer 总的
*/
int TotalLayer = 10;
for(int i = 1;i <= TotalLayer;i++){
//i表示层数
//在输出*之前还要输出空格 = 总层数-当前层
for(int k =1;k <= TotalLayer - i;k++){
System.out.print(" ");
}
//控制每层打印*的个数
for (int j = 1;j <= 2 * i - 1;j++){
if (j == 1 || j == 2 * i - 1 || i == TotalLayer){
System.out.print("*");
}else {
//其他情况输入空格
System.out.print(" ");
}
}
//判断第一个1-4层都是第一个位置* 第五层 全部都是*
//if (j == 1 || j == 2 * i - 1 || i == TotalLayer){}
//每层打印完了就换行
System.out.println("");
}
}
}
表述:当执行到break 条件成立时候直接退出循环
提前终止(结束)循环
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bbiDvy95-1676275870716)(./assets/image-20221120144256702.png)]
测试代码:
public class Break{
public static void main(String [] args){
for(int i =0;i < 10;i++){
if(i==3){
break;
}//当i=3时循环结束
}System.out.println("i="+i)
}
}
public class Break01 {
public static void main(String[] args) {
liu1: //外层for循环标签 我自己定义的
for (int i = 1; i < 12;i++){
liu2: //内层for循环标签 也是我自己定义的
for (int j =1;j < 10;j++){
if (j == 4){
break ; } System.out.println("i="+i+"j="+j);
}
}
}
}
1:打印1-100之间的数 求当和第一次大于40的时候的值
public class Break02 {
public static void main(String[] args) {
//打印打印1-100之间的数 求当和大于40的时候的值
int sum =0; //用来接受和大于40的变量
for(int i = 1;i <= 100;i++){
sum += i;//记录i的值
if(sum > 40){
System.out.println("当前数和>40" + "当前数="+i )
break;
}
}
}
}
2:实现登录验证，有3次机会，如果用户名为"丁真" ,密码"666"提示登录成功，否则提示还有几次机会，请使用for+ break完成
import java.util.Scanner; //引入Scanner对象
public class Break03 {
public static void main(String[] args) {
// 2:实现登录验证，有3次机会，如果用户名为"丁真" ,密码"666"提示登录成功，
// 否则提示还有几次机会，请使用for+ break完成
//思路分析
//1.创建一个Scanner对象 接受用户输出的用户名和密码
//2.定义 name 接受用户名 定义 passwd接受密码
//3.登录三次就是循环三次
//4.在定义一个 chance 提示登录次数
//代码实现
Scanner myScanner = new Scanner(System.in);
String name ="";
String passwd ="";
int chance =3;
for (int i = 1;i <=3 ; i++){
System.out.println("请输入用户名：");
name = myScanner.next();
System.out.println("请输入密码");
passwd = myScanner.next();
if("丁真".equals(name) && "666".equals(passwd)){
System.out.println("恭喜你，登录成功~");
break;
}
chance--;
System.out.println("你还有几次登录" + chance + "机会");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0NimoWrL-1676275870716)(./assets/image-20221124142718181.png)]
流程图:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P2DuQGRU-1676275870717)(./assets/image-20221124144200379.png)]
public class continue01 {
public static void main(String[] args) {
int i = 0; //循环初始变量化
while(i <= 4){
//循环条件
i++; //循环迭代
if (i == 2){
continue; //不执行下面语句，直接执行循环条件
}
System.out.println("i="+i);
}
}
}
//输出结果为 i=3 I=4 i=5
细节
public class Continue02 {
public static void main(String[] args) {
//Continue细节
luo1: //定义的标签1
for (int i = 0; i < 4 ; i++){
luo2://定义的标签2
for (int j = 0; j < 10; j++){
if (j == 2){
//判断分别输出什么值
continue; //等价于 luo2:
}
System.out.println("i=" + i + "j=" + j );//输出4组（0，1，3，4，5，6，7，8，9）
}
}
}
} //如果continue 后面加上标签luo1: 输出的结果就是3组(0,1)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z9d4wGuN-1676275870717)(./assets/image-20221124151831784.png)]
public class Return {
public static void main(String[] args) {
//当return遇到方法时，表示跳出方法，如果使用main方法时，表示直接退出main方法
for(int i = 1; i <= 3; i++){
if (i == 3){
System.out.println("你好"+i);
return; //这里直接退出主方法 main
}
System.out.println("Hello Word");
}//输出2次(Hello Word) 一次 (go on..)
System.out.println("go on..");
}
}
1-8题
1.编程实现如下功能
某人有100,000元,每经过一次路口，需要交费,规则如下:
1)当现金> 50000时,每次交5%
2)当现金< = 50000时,每次交1000
编程计算该人可以经过多少次路口，要求:使用while break方式完成
public class Zuoye01 {
public static void main(String[] args) {
/*1.编程实现如下功能
某人有100,000元,每经过一次路口，需要交费,规则如下:
1)当现金 > 50000时,每次交5%
2)当现金 <= 50000时,每次交1000
编程计算该人可以经过多少次路口，要求:使用while break方式完成
思路分析:
1.定义 money 来保存 100000
2.题目要求分析有三种情况 :
1) money > 50000
2) money <= 50000 && money >= 1000
3) money < 1000 来保存一个变量count保存通过路口*/
//代码实现
double money = 100000; //还有多少钱
int count = 0; //累积过得路口
while (money >= 1000) {
if (money > 50000) {
//过路口
money *= 0.95; //过了这个路口后,还有还这么多钱
count++;
} else {
//下面的条件 money <= 50000
money -= 1000;
count++;
}
}
System.out.println("这么多钱" + "100000" + "可以过这么多路口" + count + "次");
}
}
import java.util.Scanner; //引入Scanner对象
public class HomeWork02 {
public static void main(String[] args) {
/*2实现用户输入一个整数，属于哪个范围:大于0;小于0;等于0
思路:先引入Scanner对象 输入的整数;
用if else判断大于小于0或者等于0
**/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个整数:"); //用户输入的数
int i = myScanner.nextInt();//接收用户输入的整数
if (i > 0){
System.out.println("这位数" + i + ">0");
}else if (i == 0){
System.out.println("这位数" + i + "<0");
}else {
System.out.println( i + "小于0");
}
}
}
3.判断一个年份是否为闰年
import java.util.Scanner; //引入Scanner对象
public class HomeWork03 {
//3.判断一个年份是否为闰年
public static void main(String[] args) {
/*思路分析 读懂题目 因为每4年就是闰年所以要能被4整除 还有被400整除的也是闰年
那么现在就简单了 让用户输入一个数 如果满足以上条件的话就判断为闰年
用 year 来接收用户输入的年份
**/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入年份:"); //用户输入的年分
int year = myScanner.nextInt(); //接收用户输入的年份
if (year % 4 ==0 || year %400 == 0){
//判断是否满足润年的条件
System.out.println(year + "是闰年");
}else {
System.out.println(year + "不是闰年");
}
}
}
4.判断 1-1000以内的水仙花数，所谓水仙花数是指一个3位数， 其各个位上数字立方
和等于其本身。例如: 153 = 111 + 333 + 555
public class HomeWork04 {
public static void main(String[] args) {
/*4.判断 1-1000以内的水仙花数，所谓水仙花数是指一个3位数， 其各个位上数字立方
和等于其本身。例如:
153 = 1*1*1 + 3*3*3 + 5*5*5 I
思路分析:
1.水仙花数就是每个位的数3次方相加 所以我们要先到他的 个位 十位 百位
先定义标记记录起始位置 count
个位: g n % 10
十位: s n / 10 % 10
百位: b n / 100
* */
//定义起始位置
int count = 0;
//打印1-1000的数 因为是三位数所以起始位置是100
for (int i = 100; i < 1000; i++){
//取出个位
int g = i % 10;
//取出十位
int s = i / 10 % 10;
//取出百位
int b = i / 100;
//判断以上的数取出的三位数的次方相加是否等于其本身
if (g * g * g + s * s * s + b * b * b == i){
//如果是的话就记录
count++;
System.out.println(i);
}
}
System.out.println("1000以内的水仙花数有"+count<