2022年回顾java基础内容一。
目录内容。
目录
目录内容。
第一部分了解就java的第一个成序。
分解步骤，了解原理。在此之前你要安装好JDK。
第二部分了解java开发工具IDEA.
本人以javaIDEA2018为例。
IDEA的打开与关闭
IDEA的文件中的项目 模块 包 类名的层层关系
IDEA 软件的字体色彩配置
IDEA 常用的快捷键
p SVM加tab键输出：
public static void main(String[] args) {
$sout加tab键输出：
System.out.println();
ctrl+a, ctrl+C,
ctrl +v 和 ctrl +s
ctrl+y
ctrl+alt+l
IDEA下载的地址链接
第三部分了解java的注释.
第四部分了解java的变量及注意事项.
变量的定义 数据类型 变量名=赋给的值
八大基本数据类型。
驼峰式命名规则）：当名称由多词组成时，请确保第一个词的首字母应小写而其余词的首字母则应大写。注意事项：数据类型应按照从小到大的顺序排列（例如byte）。
第五部分区分java的自动类型与强制类型。
第六部分了解java的运算符。
运算符 基本运算符
//+ 连接符识别
自增自减运算符
关系运算符
复合运算符+= -= * = /= .条件运算符
一、数据类型标识：字符串类型通常使用双引号表示 //定义一个字符串 二、运算符操作 复合赋值运算的具体实现如下：
整数a初始化为1后进行赋值操作：a = a + 1。
执行减法操作：a = a - 1。
执行乘法操作：a = a * 1。
执行除法操作：a = a / 1。
执行取模操作：a = a % 1。
这些复合赋值操作与对应的单步赋值语句具有完全相同的功能。
条件运算符（即三元运算符）：其格式上表现为：当条件满足时取操作子2；不满足时取操作子3。
规则如下：
- 只有当第一个操作子为布尔型数据时才可执行此运算。
- 当第一个操作子值为true时；整个表达式的计算结果即为左侧的操作数值。
- 应确保右侧两个操作子的数据类型一致。
关于变量管理： - 变量通常被定义在一个特定区域内；超出该区域范围则无法引用该变量。
- 变量的作用域由其所处的具体区域决定；例如函数或类体内定义之变量仅在其内部可见。
System.out.println("---------------三元运算符-----------------"); double score = 98; double sc = 56; String r = (score >= 60) ? "及格" : "不及格" + score; System.out.println("成绩" + r); String re = (sc >= 60) ? "及格" : "不及格" + sc; System.out.println("成绩" + re); System.out.println("============案例分析===========");
比较运算符
- 关系运算符 ：>、>=、<、<=、== 和 != 注意：由关系运算符构成的表达式的计算结果总是boolean类型
注意：关系运算符的优先级要低于算数运算符
逻辑运算符：
- 单目否定算子
!以及&&和||用于实现条件判断。 - 真值转换规则：
!（非）：只有当输入值是true时输出false。&&（与）：仅当所有输入值均为true时返回true。||（或）：只要任何一个输入值是true就返回true。
需注意的是，在优先级上它位于关系运算符之下。
在涉及这些算子的操作中：
- 如果使用
&&进行操作，则一旦第一个条件被确定为false，则会跳过对第二个条件的评估。 - 同样地，在涉及
||的操作中，则会提前终止后续条件的评估过程。
第七部分了解java的控制流程语句。
if语句
当某个布尔型变量或条件表达式被判断为真时执行特定操作
运行的规则是：当if小括号中的条件为true时, 程序会进入大括号内的语句块; 如果条件不满足, 则会终止该if分支结构并进入其后的语句.
boolean boo = true; if(boo){ System.out.println("111"); }
package com.WorkFlow;
/** * 2022年2月10日Java流程控制 * 流程控制结构 * @1if分支结构 /public class ChengXunA { public static void main(String[] args) { /* * 场景一心跳 * int hr = 30; * 当心跳速率低于60或高于100时 * 输出信息："心跳数据不正常" + hr + "请你再仔细查看一下" * 输出信息:"查看结束in the end" */ int hr = 30; if (hr < 60 || hr > 100) { System.out.println("心跳数据不正常" + hr + "请你再仔细查看一下"); System.out.println("查看结束in the end"); System.out.println("=================================================="); } ////考试场景之二：科一考试 int score = 93; if (score >= 90 && score <= 100) { System.out.println("成绩合格"); }
System.out.println("输出等式标记");
// 二层分支
double money = 5000;
if (money >= 1314) {
输出成功提示信息;
} else {
输出资金不足提示信息;
}
/** * 场景三你去发红包 */ double money=5000; if(money>=1314){ System.out.println("发送成功");
} else { 打印"钱不够"信息 } /** * 情况四年你在医院进行结算 */ // 比如你当前拥有的金额为4000元 double money = 4000; if (money >= 5000) { 打印"结算成功"; }
} else { System.out.println("无法完成付款金额不足"); } System.out.println("----------------------------------------------------"); //@3 情况三结账异常 //例如订单金额不足 /** * int money =100; * if(money < 150){ * System.out.println("无法结账 money不够"); * } else { * System.out.println("成功结账 money充足"); * } / int money =150; if(money < 150){ System.out.println("无法结账 money不够"); } else{ System.out.println("成功结账 money充足"); }
}
//@4 多层条件判断 //例如驾驶学校评分系统 /* * int score =99; * if(score >=60 && score <70){ * System.out.println("成绩为C级"); * } else if (score >=70 && score <80){ * System.out.println("成绩为B级"); * } else if (score >=80 && score <=90) { * System.out.println("成绩为A级"); * } else if (score >=90 && score <=100) { * System.out.println("特优成绩 A++级"); * } else { * System.out.println("评分异常，请联系管理员重新评估"); * } */ int scores =99; if(scores >=60 && scores <70){ System.out.println("成绩为C级"); } else if (scores >=70 && scores <80){ System.out.println("成绩为B级"); } else if (scores >=80 && scores <=90) { System.out.println("成绩为A级"); } else if (scores >=95 && scores <=100) { System.out.println("特优成绩 A++级"); } else { System.out.println("评分异常，请联系管理员重新评估"); }
}}if-elseif(布尔类型的布尔型表达式/数值型变量){ 执行第一条指令块; }else{ 执行第二条指令块; }
执行的规则： 如果if括号内的表达式结果为true，则会执行位于大括号内的语句块1；否则则会执行位于大括号内的语句块2。例如：如果if括号内的表达式结果为false，则会执行位于大括号内的语句块2。
多重分支结构：如果（布尔型变量名/数值表达式）{执行语句块1；elseif（布尔型变量名/数值表达式）{执行语句块2；} elseif（布尔型变量名/数值表达式）{执行语句块3；}否则{执行语句块4；}
当程序遇到if多分支结构时
循环语句的结构
循环4要素：1.起始点2.执行的操作3.变化的方向与幅度4.终止位置
for package com.WorkFlow;
public class ChengXunC { public static void main(String[] args) { /** * 目标 for 循环的内容 * For 循环内容 *2022年2月10号java的流程控制 */ for (int i = 0; i < 4; i++) { System.out.println("Hellow World"); }
输出三条水平线。
初始化变量i为0；
当i小于5时执行操作；
在每次迭代中打印一条消息："Hellow World 你好事件"；
循环结束后继续下一个i值；
最后再次输出三条水平线。
for (int i = 1; i < 6; i++) { System.out.println("Hellow World 你好世界"); }
}
} package com.WorkFlow;
创建名为ChengXunE的Java类，并定义一个名为main的静态方法。
初始化整型变量i为0。
进入do-while循环结构，在循环体内部打印消息'Hello World'。
将变量i递增一次。
循环结束条件为(i < 3)。
System.out.println("============"); // 输出一个连接符符号至控制台。
for (int j = 0; j < 5; j++) { // 执行五次循环体，并在每次迭代中打印一条消息。
System.out.println("Hellow world"); // 在每次迭代中输出一条提示消息。
}
for (int j = 0; j <2; j++) { // 执行两次循环体。
System.out.println("JAVA Hellow "); // 在每次迭代中输出一条带有Java风格的消息。
}
while
while while循环： while(循环条件的判断){循环体} 执行规则：
当程序遇到一个 while 循环时,它首先会评估其对应的布尔表达式的值,若其对应的布尔表达式的值为真,则会执行其中包含的所有语句块;这个过程会在遇到该语句右侧的大括号时触发一次重新评估,直至检测到布尔表达式的值变为假为止,此时整个 while 循环的操作就会停止并退出
package com.WorkFlow;
【
//定义变量 double H=8848860; double P=0.1; //定义变量 int count =0; //定义while循环 while(P){>
System.out.println("次数"+count); System.out.println(P);
}
}do while死循环 package com.WorkFlow;
import java.util.Scanner;
【
/while (true){ System.out.println("死循环123"); }/
/* do{ System.out.println("死循环"); }while (true);*/
int okpassworld=520; //定义死循环 Scanner scanner = new Scanner(System.in);
使用无限循环结构持续运行
通过调用System.out.println方法显示提示信息"请输入密码"
从扫描器获取用户的整数值并存储在变量passworld中
当passworld等于okpassworld时{
调用System.out.println打印'登录成功信息'并执行break语句。
}否则{
调用System.out.println打印'密码错误提示信息'。
}
}
}}
Switch case
基于数值类型的表达式执行顺序的选择结构中包含多个分支选项，在每一分支选项中根据特定条件判断并执行相应的操作序列；该选择结构由多个case子项以及一个default子项组成，在特定条件下依次对应不同的操作序列集合；当所有case子项对应的条件都不满足时则会触发default子项的操作序列集合
当程序遇到switch结构时，在其后面的每个case中插入一个条件判断块：该条件块会对括号中的数值和当前case后的数值进行逐一对比；若判断结果为真，则会依次执行该case及其之后的所有语句（包括default后的语句）；若无匹配，则跳过后续所有语句。
注意：当switch语句后部不需要default时，在遇到break关键字时整个switch语句会终止
package com.WorkFlow;
public class ChengXunB { public static void main(String[] args) { /** * 2022年2月10号java的流程控制 * 注意事项 * 1 double不支持 * 2 case 后面数值不能重复 * 3 不写break switch 有穿透性 */// double a=0.1+0.2;// switch (a){ } String week ="周四"; switch (week){ case "周一": System.out.println("干代码"); break; case "周二": System.out.println("干代码"); break; case "周三": System.out.println("干代码"); break; case "周四": System.out.println("去玩干代码"); break; case "周五": System.out.println("干代码"); break; case "周六": System.out.println("干代码"); break; case "周七": System.out.println("干代码"); break; default: System.out.println("数据有误");
} }}
案例一
案例二
案例三
案例四
案例五
总结思维导图。
思维导图二
第一部分了解就java的第一个成序。
分解步骤，了解原理。在此之前你要安装好JDK。
**运行流程说明
步骤一：启动记事本并新建一个空白文档。
步骤二：将生成的代码内容复制到记事本中进行编写。
步骤三：启动CMD后依次执行以下操作：
- 使用键盘快捷键Win+R调出任务管理器并打开CMD窗口；
- 在命令提示符下输入javac并按回车键确认；
- 观察命令提示符窗口中的状态消息来判断JDK是否成功安装。
**@5显示上面的文件后确认JDk已安装完成，并通过运行命令javac -version获取JDK版本号的信息。
@6如图所示。
**@5显示上面的文件后确认JDk已安装完成，并通过运行命令javac -version获取JDK版本号的信息。
@6如图所示。
第二部分了解java开发工具IDEA.
本人以javaIDEA2018为例。
IDEA的打开与关闭
Flie --> close Project 关闭项目
IDEA的文件中的项目 模块 包 类名的层层关系
IDEA 软件的字体色彩配置
IDEA 常用的快捷键
通过按住Tab键配合psvm工具实现代码编辑功能；## public static void main(String[] args) {；通过按住Tab键配合S O U T（代表System.out）实现打印信息；使用Ctrl+A选择全段落、Ctrl+C复制、Ctrl+V粘贴和Ctrl+S保存这些快捷键；Press Ctrl+Y to undo the last operation；Press Ctrl+Alt+L to enter the specific mode or function.
IDEA下载的地址链接
第三部分了解java的注释.
package com.Day2;
/** * java学习路线一
* 了解java第一个程序的来历。
* 了解 IDEA软件的基础使用方案
* 了解java的注释
* 了解java的字面值
* 了解java的变量
* 了解java的八大基本数据类型
* 了解java的自动类型和强制类型转换
* 了解java的流程控制语句 if if else for while do while
* */
//注释不会影响java程序
/** * 文档注释
* 学习注释内容
*/
/**
//单行注释 ctrl+/ 多行注释 Ctrl+shift+/
/*
多行注释
*/
public class Nodemain {
public static void main(String[] args) {
//输出语句内容为我开始学习就JAVAV语句内容
System.out.println("单行注释 ctrl+/ 多行注释 Ctrl+shift+/");
System.out.println("我开始学习就JAVAV语句内容");
}
}第四部分了解java的变量及注意事项.
**变量的定义
数据类型 变量名=赋给的值**
package com.Day2;
/** * 变量
* 2022/2/4
*/
public class Variable {
public static void main(String[] args) {
double money =6.0;
System.out.println(money);
//从righ往left看
money =money+6.0;
System.out.println(money);
System.out.println("======================");
int age=22;
System.out.println(age);
age=34;
System.out.println(age);
}
}
八种基础数据命名规则**
驼峰式命名法：对于包含多词的名称，在第一个单词的第一个字母使用小写字母，在其余每个单词的第一个字母使用大写字母。
- 注意：
- 数据类型的大小顺序为 byte 小于 short 小于 int 小于 small 长于 long 小于 float 小于 double。
- 整数值型的数据类型的大小小于浮点数值型。
- 当多种不同数值类型的数值参与运算时，
其结果将对应于所有参与运算的数据类型的大小中的最大值。
第五部分区分java的自动类型与强制类型。
较小的数据类型的变量映射到较大数据类型的变量即为"自动types转换"。较大的data types无法被small data types直接assign（forced types conversion遵循format"small data type variable=largest data type variable" ,这允许larger data type被smaller ones接收,但会带来一系列problems）
第六部分了解java的运算符。
运算符
基本运算符
int a=20;
int b=3;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a+1.0/b);
System.out.println(a%b);
System.out.println(20/3+1.0);//+ 连接符识别
int f=34;
System.out.println("abc"+'a');
System.out.println("abc"+a);
System.out.println(5+a);
System.out.println("abc"+5+'a');
System.out.println(15+"abc"+15);
System.out.println(a+'a');
System.out.println(a+""+'a');
System.out.println(a+'a'+"itemate");
System.out.println("iteryte"+a+'a');
System.out.println(a+'a');自增自减运算符
System.out.println("自增自减运算符");
int r=10;
a++; //a=a+1
System.out.println(a);
++ -- 先+1；or 先-1
int q=12;
int u=++q;
System.out.println(q);关系运算符
int a=10;
int b=10;
boolean rs= a==b;
System.out.println(rs);
System.out.println(a==b);
System.out.println(a!=b);
System.out.println(a>=b);
System.out.println(a>b);
System.out.println(a<=b);
System.out.println(a<b);
int aa=10;
int bb=40;
System.out.println(aa==bb);
System.out.println(aa!=bb);
System.out.println(aa>=bb);
System.out.println(aa>bb);
System.out.println(aa<=bb);
System.out.println(aa<bb);
System.out.println(aa=bb);复合运算符+= -= * = /=
.条件运算符
一、引用数据类型：
字符串String,用""引起来
//定义一个字符串
二、运算符
以下是一些常见的复合运算符：
int a = 1;
a += 1相当于a = a + 1；
a -= 1相当于a = a - 1；
a *= 1相当于a = a * 1；
a /= 1相当于a = a / 1；
a %= 1相当于a = a % 1；
注释
注释的作用域
打印三元运算符
定义double型变量score并赋值为98；
定义双精度浮点型变量sco并赋值为56；
创建String型变量r并根据score值判断是否及格并拼接相应文字；
请查看以下测试结果：" + r + "；...
创建String型变量re并根据sco值判断是否及格并拼接相应文字；
请查看以下测试结果：" + re + "；...
案例内容：
比较运算符
3. 比较运算符（也称关系运算符）及其表示形式：包括大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、等于（==）、不等于 (!=) 的关系运算符集合。请注意：由这些关系运算符组成的表达式的计算结果必然是布尔型数据类型。
**注意：关系运算符的优先级要低于算数运算符
**
**逻辑运算符:!(一元运算符) && ||
逻辑非！：非真即假，非假即真
逻辑与&&:只要有一个操作数为假，这个表达式的结果就为假
逻辑或||：只要有一个操作数为真，这个表达式的结果就为真
注意：逻辑运算符的优先级要低于关系运算符
逻辑短路：
逻辑与参与的表达式中只要第一个操作数为false，将不会运行第二个操作数
逻辑或参与的表达式中只要第一个操作数为true，将不会运行第二个操作数**
第七部分了解java的控制流程语句。
if语句
**if
单分支结构：
if(boolean类型的条件表达式/数值/boolean类型变量){
语句块;
}
循环语句的结构
循环四要素：
第一部分为起点位置；
第二部分是执行的操作内容；
第三部分是起始到终点的变化量；
第四部分是终止状态。
for
package com.WorkFlow;
public class ChengXunC {
public static void main(String[] args) {
/**
- 该 for 循环的目的
- 此 for 循环的内容
- 2022年2月10日 Java 流程控制示例
/
for (int i = 0; i < 4; i++) {
System.out.println("Hello World");
}*
System.out.println("------------------");
for (int i = 0; i < 5; i++) {
System.out.println("Hello World 您好事件");
}**
System.out.println("=============");** >
for (int j = 1; j < 6; j++) { // 注意变量初始化的变化
System.out.println("Hello World 您好世界"); // 变量命名更加明确
}** >
}** >
}** >
package com.WorkFlow;** >
public class ChengXunE { > public static void main(String[] args) { // 添加了对初始化语句的简要说明
/* 初始化语句 / > int i = 0; // 更加明确地说明变量类型
/ 使用 do-while 循环 / > do{ // 改变了句式结构
System.out.println("Hello World"); // 简化了语序
} while (i < 3); // 调整了语序以增强可读性* >
System.out.println("============"); // 添加了对循环次数的简要提示
.for (int j = 0; j <5; j++){// 使用点号增强可读性
System.out.println("Hello world");// 简化了空格使用
} while (j <2);// 调整了语序以增强可读性**
}**
****
while
**while
while循环：
while(循环条件的判断){循环体}
执行规则：**
当程序遇到while循环时首先要进行一次相应的初始判断；如果这次初始判断的结果满足某种特定情况则随后立即进入到相应的一系列操作步骤中，在此过程中会持续不断地执行所有的代码指令直至完成对应的大括号部分的操作流程；然后在每次操作之后都要重新回到最初的初始判断环节继续重复整个过程直至满足某个特定终止条件。
package com.WorkFlow;
/
- 2022年2月10号java的流程控制
/
public class ChengXunD {
public static void main(String[] args) {
//while循环
int i=0;
while (i<3){
System.out.println("Hellow world");
i++;
}
System.out.println("================");***//定义变量
double H=8848860;
double P=0.1;
//定义变量
int count =0;
//定义while循环
while(P<H){
P =2;
count++;
}***System.out.println("次数"+count);
System.out.println(P);**
}
**}
do while
死循环
package com.WorkFlow;**
import java.util.Scanner;
/
- 2022年2月10号java的流程控制
- 死循环的魅力
/
public class DeadForG {
public static void main(String[] args) {
/for ( ; ;) {
System.out.println("Hellow world");
}/***/*while (true){
System.out.println("死循环123");
}*/***/ do{
System.out.println("死循环");
}while (true);
/***int okpassworld=520;
//定义死循环
Scanner scanner = new Scanner(System.in);****while (true){
System.out.println("请输入密码");
int passworld = scanner.nextInt();****if(passworld==okpassworld) {
System.out.println("登录成功");
break;
}else {
System.out.println("密码有误");
}**}
**}
}**
Switch case
基于数值类型的表达式的switch语句：
基于数值类型的表达式{
根据特定数值执行的一系列指令 case 数值1;
根据特定数值执行的一系列指令 case 数值2;
根据特定数值执行的一系列指令 case 数值3;
……
根据特定数值执行的一系列指令 case n;
}
默认情况下执行的一系列指令 default;
执行规则：
当程序看到switch结构时，会用小括号的数值与case后面的数值进行一一的比较，比较是否相等，如果相等，将会执行case后面的所有的一系列语句并且包括
default后面的一系列语句，如果都没有匹配上，那么程序会执行default后面的一系列语句**注意：
switch后面可以不要default
当switch结构中遇到break关键字时，整个switch结构结束
**package com.WorkFlow;
**public class ChengXunB {
public static void main(String[] args) {
/**
- 2022年2月10号java的流程控制
- 注意事项
- 1 double不支持
- 2 case 后面数值不能重复
- 3 不写break switch 有穿透性
/
// double a=0.1+0.2;
// switch (a){
//
// }
String week ="周四";
switch (week){
case "周一":
System.out.println("干代码");
break;
case "周二":
System.out.println("干代码");
break;
case "周三":
System.out.println("干代码");
break;
case "周四":
System.out.println("去玩干代码");
break;
case "周五":
System.out.println("干代码");
break;
case "周六":
System.out.println("干代码");
break;
case "周七":
System.out.println("干代码");
break;
default:
System.out.println("数据有误");***}
}
}**
案例一
package com.WorkFlow;
/** * 案例
* 采用的知识点有 if分支 面向对象Scanner
* 2022年2月10号java的流程控制
*/
import java.util.Scanner;
public class AnLI1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入你的消费金额：");
double sMoney = sc.nextDouble();
if (sMoney<=0) {
System.out.println("你输入有！！！！！");
}else if(sMoney<50) {
System.out.println("换购活动需要50元，谢谢你的参加");
}else if(sMoney>=50){
System.out.println("1 满50元， 加2瓶可乐");
System.out.println("2 满100元 ，加3瓶酸奶");
System.out.println("3 满100元，有10元面粉");
System.out.println("4 满200元，30元的喝喝");
System.out.println("5 满100元， 加5本子");
System.out.println("6 满300元， 加15个本子算20元");
System.out.println("0 不换");
System.out.println("请输入你的序号");
int a =sc.nextInt();
if(a>5 ||a<0) {
System.out.print("你输入有误！如有需要轻重开始");
}else {
if(a==6 && sMoney>=200) {
System.out.println("满300元， 加15本子");
System.out.println("本次消费总额为："+(sMoney+40));
}else if(a==5 && sMoney>=100) {
System.out.println(" 满100元，90元的喝喝");
System.out.println("本次消费总额为："+(sMoney+45));
}else if(a==4 && sMoney>=200) {
System.out.println(" 满200元，30元的喝喝");
System.out.println("本次消费总额为："+(sMoney+30));
}else if(a==3 && sMoney>=100) {
System.out.println(" 满100元，有10元面粉");
System.out.println("本次消费总额为："+(sMoney+10));
}else if(a==2 && sMoney>=100) {
System.out.println(" 满100元 ，加3瓶酸奶");
System.out.println("本次消费总额为："+(sMoney+19));
}else if(a==1 && sMoney>=50) {
System.out.println(" 满50元， 加2瓶可乐");
System.out.println("本次消费总额为："+(sMoney+4));
}else if(a==0 ) {
System.out.println("欢迎光临！！！");
}else {
System.out.println("你没有达到相应金额");
}
}
}
}
}
案例二
package com.WorkFlow;
/** * 2022年2月10号java的流程控制
* 省去了break
*/
import java.util.Scanner;
public class AnLi2 {
public static void main(String[] args) {
//1.创建Scanner对象
Scanner scanner = new Scanner(System.in);
//2.提示用户输入年份并且获取年份
System.out.println("请输入年份");
int year = scanner.nextInt();
//3.提示用户输入月份并且获取月份
System.out.println("请输入月份");
int month = scanner.nextInt();
//4.提示用户输入日期并且获取日期
System.out.println("请输入日期");
int day = scanner.nextInt();
//5.定义一个变量去统计一共过了多少天
int sum = 0;
switch(month){
case 12:
if(month==12){
sum = sum+day;
}else{//过满了整月
sum = sum+31;
}
case 11:
if(month==11){
sum = sum+day;
}else{//过满了整月
sum = sum+30;
}
case 10:
if(month==10){
sum = sum+day;
}else{//过满了整月
sum = sum+31;
}
case 9:
if(month==9){
sum = sum+day;
}else{//过满了整月
sum = sum+30;
}
case 8:
if(month==8){
sum = sum+day;
}else{//过满了整月
sum = sum+31;
}
case 7:
if(month==7){
sum = sum+day;
}else{//过满了整月
sum = sum+31;
}
case 6:
if(month==6){
sum = sum+day;
}else{//过满了整月
sum = sum+30;
}
case 5:
if(month==5){
sum = sum+day;
}else{//过满了整月
sum = sum+31;
}
case 4:
if(month==4){
sum = sum+day;
}else{//过满了整月
sum = sum+30;
}
case 3:
if(month==3){
sum = sum+day;
}else{//过满了整月
sum = sum+31;
}
/** * 二月份 判断
*/
case 2:
if(month==1){
sum = sum+day;
}else{//过满了整月并且要判断是闰年还是平年
if((year%400==0)||(year%4==0&&year%100!=0)){//闰年
sum = sum+29;
}else{//平年
sum = sum+28;
}
}
case 1:
if(month==1){
sum = sum+day;
}else{//过满了整月
sum = sum+31;
}
}
System.out.println(year+"年"+month+"月"+day+"日是该年的第"+sum+"天");
System.out.println("-------------------------------------------------");
System.out.println(year+"年"+month+"月"+day+"日是该年的第"+sum+"天");
}
}
案例三
package com.WorkFlow;
/** * 判断奇数偶数
* 2022年2月10号java的流程控制
*/
public class AnLI3 {
public static void main(String[] args) {
/** * 案例一
*/
int sum = 0;
//fori tab
for (int j = 0; j <= 5; j++) {
sum += j;
System.out.println("输出一到五的和为" + sum);
}
System.out.println("=====输出一到五的和为" + sum);
/** * 方案一
*案例二
* for if判断
*/
int su = 0;
for (int j = 0; j <= 10; j++) {
if (j % 2 == 1) {
su += j;
}
}
System.out.println("一到10的奇数和为" + su);
//方案二
int so = 0;
for (int j = 0; j <= 10; j += 2) {
so += j;
}
System.out.println(so + "=========");
//案例三
int s = 0;
for (int j = 0; j <= 10; j++) {
if (j % 2 == 0) {
su += j;
}
}
System.out.println("一到10的偶数和为" + su);
System.out.println("-------------------------------------------------------");
}
}
案例四
package com.WorkFlow;
public class AnLi4 {
public static void main(String[] args) {
/** * 实体 if for 套用
* 2022年2月10号java的流程控制
*/
int count =0;
for (int i = 100; i <=999; i++) {
//个为
int ge=i%10;
//
int shi=i/10%10;
//
int bei=i/100;
if ((ge*ge*ge+shi*shi*shi+bei*bei*bei)==i){
System.out.println(i+"\t");
count++;
}
}
System.out.println(" ");
System.out.println("个数为 "+count);
}
}
案例五
package com.WorkFlow;
/** * 九九乘法表
*/
public class AnLI5 {
public static void main(String[] args) {
for (int i = 1; i <= 9; ++i) {
//System.out.println(i+"-------------------------------------------------------");
for (int j = 1; j <= i; ++j) {
//System.out.println(j+"=================================");
System.out.print(i + "*" + j + "=" + i * j + " ");
}
System.out.println();
}
}
}总结思维导图。
思维导图二
