顺序结构
分支语句
if-else条件判断语句
public class FlowControlTest {
/**
* 分支结构一：if-else条件判断
* 格式1：if(条件表达式){
* 语句块；
* }
* 格式2：if(表达式1){
* 语句块1；
* }else{
* 语句块2；
* }
*
* 格式3：if(表达式1）{
* 语句块1；
* }else if(表达式2){
* 语句块2；
* }
* ...
* else{
* 语句块n;
* }
* @param args
*/
public static void main(String [] args){
/**
* 案例一：成年人心率的正常范围是每分钟60-100次。体检时，如果心率不在此范围内，则展示需要做进一步检查
*/
int n = 98;
if (n<60||n>100){
System.out.println("该指标不正常,需要做进一步检查");
}
/**
* 案例二：定义一个整数，判断是偶数还是奇数
*/
int num = 23;
if (num % 2==0){
System.out.println("是偶数");
}else{
System.out.println("是奇数");
}
/**
* if-else嵌套
* 案例三：由键盘输入三个整数分别存入变量num1、num2、num3,对它们进行排序(使用if-else)，并且有效达到输出
*/
/**
* 定义两个整数，分别是small和big,如果第一个整数small大于第二个整数big,就交换。输出显示small、big变量的值
*/
int small = 26;
int big = 25;
if(small>big){
int temp=small;
small=big;
big=temp;
System.out.println("small:"+small+" big:"+big);
}
}
}
Switch-case
import org.apache.commons.math3.stat.descriptive.summary.Sum;
import java.util.Scanner;
/**
* switch-case与if-esle之间的转换
* 1、开发中，能使用switch-case的都能够转化为if-esle
* 2、如果开发中既可以使用swith-case又可以使用if-else;推荐使用switch-case
*
*/
public class SwitchCaseTest {
public static void main(String[] args){
/**
* 分支结构swith-case的使用
* 1、语法结构：
* swith(表达式){
* case 常量1：
* //执行语句1
* //break;
* case 常量2：
* //执行语句2
* //break;
*
* ...
* default:
* //执行语句2
* //break;
*
*1、switch表达式只能是特定的数据类型。如下：byte\short\char\int\枚举（JDK5.0新增）\String(JDK7.0新增)
*2、case后跟的是常量，使用表达式与这些常量做相等的判断，不能进行范围的判断。
* 3、开发中，使用switch-case时，通常case匹配的情况都有限
* 4、break:可以使用在swith-case中。一旦执行break关键字，就跳出当前swith-case结构
*/
int num=0;
switch(num){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
default:
System.out.println("other");
break;
}
/**
* 案例3：使用switch-case实现:对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
*/
// int grade = 95;
// switch (grade){
// case 50:
// System.out.println("不合格");
// break;
// case 80:
// System.out.println("合格");
// break;
// case 95:
// System.out.println("合格");
// break;
// default:
// System.out.println("我也不知道是否合格");
// break;
//
// }
//方法2：
int grade = 97;
switch (grade / 10){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("不合格");
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("合格");
break;
default:
System.out.println("成绩输入有误");
break;
}
/**
* 案例4：编写程序：从键盘上输入2024年的“month"和”day",要求通过程序输出输入的日期为2024年的第几天
*/
Scanner scanner = new Scanner(System.in);
System.out.println("请输入月份：month");
int month = scanner.nextInt();
System.out.println("请输入天：day");
int day = scanner.nextInt();
// switch (month){
// case 1:
// int days=day;
// System.out.println("2024年的第"+days+"天");
// break;
// case 2:
// int days2 = 31+day;
// System.out.println("2024年的第"+days2+"天");
// break;
// default:
// System.out.println("不想计算了");
// break;
// }
int SumDays = 0;
switch(month){
case 12:
SumDays +=30;
case 11:
SumDays+=31;
case 10:
SumDays+=31;
case 9:
SumDays+=30;
case 8:
SumDays+=31;
case 7:
SumDays+=31;
case 6:
SumDays+=30;
case 5:
SumDays+=31;
case 4:
SumDays+=30;
case 3:
SumDays+=31;
case 2:
SumDays+=29;
case 1:
SumDays+=30;
break;
}
System.out.println("2024年的第"+SumDays+"天");
}
}
循环结构
- 理解：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能。
- 循环结构分类
1、for循环
2、while循环
3、do-while循环 - 循环结构四要素
1、初始化部分
2、循环条件
3、循环体
4、迭代部分
For循环
import java.util.Scanner;
public class ForTest {
/***
* 循环结构之一：for循环
* 1、java中规范了3种循环结构：for、while、do-while
* 2、凡是循环结构，就一定会有4个要素
* 1、初始化条件
* 2、循环条件 -->一定是boolean类型/表达式
* 3、循环体
* 4、迭代部分
* for循环的格式
* for(①：②：④){
* ③
* }
*
*
* @param args
*/
public static void main(String[] args){
/**
* 1、输出5行HelloWorld
*/
for(int i=1;i<=5;i++){
System.out.println("HelloWorld");
}
//2.需求2
int num=1;
for(System.out.println('a');num<3; System.out.println('c'),num++){
System.out.println('b');
}//abcbc
//3.遍历1-100以内的偶数，并获取偶数的个数，获取所有偶数的和
int count =0;
int sum=0;
for(int i=1;i<=100;i++){
if(i%2==0){
count+=1;
sum+=i;
}
}
System.out.println("偶数的个数："+count+","+"偶数的和"+sum);
//4.输出所有的水仙花数、所谓水仙花是指一个3位数，其各个位上的数字立方和等于其本身。例如：153=1*1*1+3*3*3+5*5*5
for(int i=100;i<=999;i++){
int Ge = i%10;
int Shi = i/10 %10;
int Bai = i/100;
if(i==Ge*Ge*Ge+Shi*Shi*Shi+Bai*Bai*Bai){
System.out.println(i);
}
}
//5.输入两个正整数m和n,求其最大公约数和最小公倍数.比如：12和20的最大公约数是4，最小公倍数是60
//最大公约数:方法一
int num1=0;
Scanner scanner = new Scanner(System.in);
//获取m和n中的较小值
int m = scanner.nextInt();
int n = scanner.nextInt();
int min = (m>n)?n:m;
for (int i=1;i<=min;i++){
if(m%i==0&&n%i==0){
num1=i;
}
}
if (num1==0){
System.out.println("该数无最大公约数");
}else{
System.out.println("最大公约数位："+num1);
}
//最大公约数：方法二(推荐)
for (int i=min;i>=1;i--){
if(m%i==0&&n%i==0){
System.out.println(i);
break;
}
}
//最小公倍数
int max = (m>n)?m:n;
for(int i=max;i<m*n;i++){
if(i%m==0&&i%n==0){
System.out.println("最小公倍数为："+i);
break;
}
}
}
}
while循环
import java.util.Scanner;
public class WhileTest {
/**
* 1、凡是循环结构，就一定会有4个要素
* ①：初始化条件
* ②：循环条件---->一定是boolean类型的变量或表达式
* ③：循环体
* ④：迭代部分
*
* 2、while的格式
* ①
* while(②){
* ③
* ④
* }
*
* 3、执行过程：①-->②-->③-->④-->②-->③-->④。。。②
* 4、for循环和while循环相互之间可以转换
* 5、for循环和while循环的小区别：初始化条件的作用域不同。while循环中初始化条件在for循环结束后，依然有效。
* @param args
*
*/
public static void main(String[] args){
//1、遍历1-100内的偶数，并获取偶数的个数、获取所有偶数的和
int sum=0;
int count=0;
int i=1;
while(i<=100){
if(i%2==0){
count+=1;
sum+=i;
}
i++;
}
// System.out.println(sum+""+count);
//2、猜数字游戏：随机生成100以内的数，猜这个随机数是多少？
//从键盘输入数，如果大了，提示大了；如果小了，提示小了；如果对了，就不在猜了，并统计一共猜了多少次。
int num = (int)(Math.random()*100)+1;
Scanner scanner = new Scanner(System.in);
// int scan1 = scanner.nextInt();
System.out.println("请输入数字：");
// int guesscount=1;
// while(num!=scan1){
// if(scan1>num){
// System.out.println("大了");
// }else{
// System.out.println("小了");
// }
// guesscount++;
// }
// System.out.println("请输入1-100范围内的一个整数");
// scan1 = scanner.nextInt();
// guesscount++;
int count_num = 0;
for(int j=1;j<=100;j++){
int scan1 = scanner.nextInt();
count_num++;
if(scan1>num){
System.out.println("大了");
continue;
}else if(scan1<num){
System.out.println("小了");
continue;
}else{
System.out.println("猜对了");
break;
}
}
System.out.println(count_num);
//3、世界最高的山峰是珠穆朗玛峰,他的高度是8848.86米，假如我有一张足够大的纸，他的厚度是0.1毫米。
//请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
//1、声明珠峰的高度、纸的默认厚度
double paper=0.1;
double zf = 8848860;
int count1=0;
while(paper<=zf){
paper*=2;
count1++;
}
System.out.println("paper的高度为："+(paper/1000+",超过了珠峰的高度"));
System.out.println("共折纸"+count1+"次");
}
}
do-while循环
import java.util.Scanner;
public class DoWhileTest {
/**
* 1、do-while的格式
* ①
* do(
* ③
* ④
* )while(①)；
* 2、执行过程：1-3-4-2-3-4...2
* 3、说明：
* do-while循环一定至少执行一次循环体
* for、while、do-while三者之间可以互相转换
* do-while循环结构，在开发中，相较于for、while循环来讲、使用较少
*
*/
public static void main(String [] args){
//需求：遍历100以内的偶数，并输出偶数的个数和总和
int sum=0;
int count=0;
int i=1;
do{
if(i%2==0){
sum+=i;
count+=1;
}
i++;
}while(i<=100);
System.out.println("count:"+count+",sum:"+sum);
//声明变量balance并初始化为0，用以表示银行账户余额，下面通过ATM机程序实现存款，取款等功能。
//1、存款 2、取款 3、显示余额 4、退出 请选择(1-4)
Scanner scanner = new Scanner(System.in);
double balance = 0;
boolean flag = true; //控制循环
do{
System.out.println(
"====================ATM======================\n"+
"1、存款\n"+
"2、取款\n"+ "3、显示余额\n"+"4、退出"
);
int selection = scanner.nextInt();
switch(selection){
case 1:
System.out.println("请输入存款金额：");
double money1 = scanner.nextDouble();
if(money1>0){
balance+=money1;
}
break;
case 2:
System.out.println("请输入取款的金额");
double money2 = scanner.nextDouble();
if(money2>0 && money2<=balance){
balance-=money2;
}else{
System.out.println("输入的数据有误或余额不足");
}
break;
case 3:
System.out.println("账户余额为："+balance);
System.out.println("感谢使用，欢迎下次光临！");
break;
case 4:
flag=false;
break;
default:
System.out.println("输入有误，请重新输入");
}
}while(flag);
//关闭资源
scanner.close();
}
}
如何选择各种循环
- 遍历有明显的循环次数(范围)的需求，选择for循环
- 遍历没有明显的循环次数(范围)的需求，选择while循环
- 如果循环体语句至少执行一次，do-while循环
- 本质上：三者之间完全可以相互转化，都能实现循环的功能
无限循环
无线循环结构的使用
1、格式while(true) 或 for(;😉
2、死循环后面不能有执行语句
3、开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，开控制循环体的结束（使用break）。
//从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
int count1 = 0;//初始化整数的个数
int count2 =0;//初始化负数的个数
boolean flag1 = true;
while(flag1){
int num1 = scanner.nextInt();
if(num1>0){
count1+=1;
}
else if(num1<0){
count2+=1;
}
if(num1==0){
flag1=false;
break;
}
}
System.out.println(count1+" "+count2);
嵌套循环
/**
* 嵌套循环的使用：
* 1、嵌套循环：是指一个循环结构A的循环体是另一个循环结构B
* -外层循环：循环结构A
* -内层循环：循环结构B
* 2、说明
* 1）内层循环充当了外层循环的循环体
* 2）对于两层嵌套循环来说，外层循环控制行数，内存循环控制列数
* 3）举例：外层循环执行m次，内层循环执行n次，则内层的循环的循环体共执行m*n次
* 4）实际开发中，不会出现三层以上的循环结构
*/
public class ForForTest {
public static void main(String[] args){
/**
* *
* **
* ***
* ****
* *****
*/
for(int i=1;i<=5;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
//****** i 1 j 6 i+j=7 j=7-i
//***** 2 5
//**** 3 4
//*** 4 3
//** 5 2
//* 6 1
for(int ii=1;ii<=6;ii++){
for(int jj=1;jj<=7-ii;jj++){
System.out.print("*");
}
System.out.println();
}
/* i(第几行) j(每一行中-的个数) k(每一行中*的个数) 2*i+j=10 --->j=10-2*i
* 1 8 1 k=2*i-1
* * * 2 6 3
* * * * * 3 2 5
* * * * * * * 4 4 7
* * * * * * * * * 5 0 9
* * * * * * * * 4
* * * * * * * 3
* * * * * 2
* * *
*
*/
//上半部分
for(int i1=1;i1<=5;i1++){
//-
for(int j1=1;j1<=10-2*i1;j1++){
System.out.print(" ");
}
//*
for(int k1=1;k1<=2*i1-1;k1++){
System.out.print("* ");
}
System.out.println();
}
//下半部分
for(int i2=1;i2<=4;i2++){
//-
for(int j2=1;j2<=2*i2;j2++){
System.out.print(" ");
}
//*
for(int k2=1;k2<=9-2*i2;k2++){
System.out.print("* ");
}
System.out.println();
}
// 九九乘法表
/*
1*1=1
2*1=2 2*2=4
3*1=3 3+2=6 3*3=9
4*1=4 4*2=8 4*3=9 4*4=16
*/
for(int i3=1;i3<=9;i3++){
for(int j3=1;j3<=i3;j3++){
System.out.print(i3 + "*" + j3 +"="+i3*j3+"\t");
}
System.out.println();
}
}
}
典型案例
public class ClassicCaseTest {
public static void main(String[] args){
/*
题目：找出100以内所有的素数(质数)？100000以内的呢？
目的：不同代码的实现方式，可以效率差别很大
分析：素数(质数)：只能被1和他本身整除的自然数。-->从2开始，到这个数-1为止，此范围内没有这个数的约数。则此数是一个质数
比如：2、3、5、7、11、13、17、19、23、...
--->换句话说，从2开始到这个自然数-1为止，不存在此自然数的约数。
*/
//方式1
// for(int i=2;i<=99;i++){
// int number =0;//记录i的约数的个数
// //判断是否为质数
// for(int j=2;j<i;j++){
// if(i%j==0){
// number++;
// }
//
// }
// if(number==0){
// System.out.println(i);
// }
// }
//方式2
// for(int i=2;i<=99;i++){
// boolean isFlag = true;
// for(int j=2;j<i;j++){
// if(i%j==0){
// isFlag=false;
// }
// }
// if(isFlag){
// System.out.println(i);
// }
// }
//方式3
boolean flag = true;
for(int i=2;i<=99;i++){
for(int j=2;j<i;j++){
if(i%j==0){
flag=false;
}
}
if (flag){
System.out.println(i);
}
flag=true;
}
}
}
项目
import java.util.Scanner;
public class Demo {
/*
==================谷粒记账软件==================
1、收支明细
2、登记收入
3、登记支出
4、退出
请选择(1-4):
*/
private static Scanner scanner = new Scanner(System.in);
/*
用于界面菜单的选择。该方法读取键盘，如果用户输入1-4中任意一个字符，厕方法返回。返回值为用户键入字符
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);
c = str.charAt(0);
if (c != '1' && c != '2' && c != '3' && c != '4') {
System.out.println("选择错误，请重新输入：");
} else
break;
}
return c;
}
/*
用于确认选择的输入。该方法从键盘读取'Y' 或 'N'。并将其作为方法的返回值
*/
public static char readConfirmSelection(){
char c;
for(;;){
String str = readKeyBoard(1,false).toUpperCase();
c = str.charAt(0);
if(c=='Y' || c =='N'){
break;
}else{
System.out.println("选择错误,请重新输入");
}
}
return c;
}
/*
用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数，并将其作为方法的返回值
*/
public static int readNumber(){
int n;
for(;;){
String str = readKeyBoard(4,false);
try{
n = Integer.parseInt(str);
break;
}catch (NumberFormatException e){
System.out.println("数字输入错误，请重新输入：");
}
}
return n;
}
/*
用于收入和支出说明的输入。该方法从家农安读取一个不超过8个长度的字符串，并将其作为方法的返回值。
*/
public static String readString(){
String str = readKeyBoard(8,false);
return str;
}
private static String readKeyBoard(int limit ,boolean blankReturn) {
//从控制台读取用户信息，并将其作为字符串返回给程序使用
//该方法是通过标准输入流(System.in)和缓冲输入流(Buffered Reader)实现的
String line = "";
while (scanner.hasNextLine()){
line = scanner.nextLine();
if(line.length()==0){
if(blankReturn)
return line;
else continue;
}else if(line.length()<1 || line.length()>limit){
System.out.println("输入长度(不大于)"+limit+") 错误,请重新输入：");
continue;
}
break;
}
return line;
}
public static void main(String[] args){
// System.out.println("=============谷粒记账软件===========\n" +
// "\t\t\t1、收支明细\t\t\t\n" +
// "\t\t\t2、登记收入\t\t\t\n" +
// "\t\t\t3、登记支出\t\t\t\n" +
// "\t\t\t4、退出\t\t\t\n" +
// "\t\t\t请选择(1-4)\t\t\t\n");
//
// boolean flag = true;
// do {
// System.out.println(
// "\t\t\t请选择(1-4)\t\t\t\n"
// );
// Scanner scanner = new Scanner(System.in);
// int number = scanner.nextInt();
// switch (number) {
// case 1:
// System.out.println("收支明细");
// Double money = scanner.nextDouble();
// System.out.println("");
// break;
// case 2:
// System.out.println("登记收入");
// break;
// case 3:
// System.out.println("登记支出");
// break;
// case 4:
// System.out.println("退出");
// flag=false;
// break;
// }
// }while(flag);
boolean flag = true;
//初始金额
int balance= 100000;
String info = "";
while (flag){
System.out.println("-----------------------谷粒记账软件-----------------------\n");
System.out.println(" 1 收支明细");
System.out.println(" 2 登记收入");
System.out.println(" 3 登记支出");
System.out.println(" 4 退 出\n");
System.out.println(" 请选择(1-4)");
char selection = readMenuSelection();
switch (selection){
case '1':
System.out.println("-------------------当前收支明细记录-------------------");
System.out.println("收支\t账户金额\t收支金额\t说 明\n");
System.out.println(info);
System.out.println("---------------------------------------------------");
break;
case '2':
System.out.println("本次收入金额：");
int money = readNumber();
if(money>0){
balance+=money;
}
System.out.println("本次收入说明：");
String addDesc = readString();
info+="收入\t" + balance + "\t" + money + "\t" + addDesc + "\n";
System.out.println("----------------------登记完成---------------------- ");
break;
case '3':
System.out.println("本次支出金额：");
int money1 = readNumber();
if(money1>0 && balance>=money1){
balance-=money1;
}
System.out.println("本次支出说明：");
String addDesc1 = readString();
info+="收入\t" + balance + "\t" + money1 + "\t" + addDesc1 + "\n";
System.out.println("----------------------登记完成---------------------- ");
break;
case '4':
System.out.println("\n确认是否退出(Y/N):");
char isExit = readConfirmSelection();
if(isExit == 'Y'){
flag=false;
}
break;
}
}
}
}
关键字break和continue的使用
/**
* 1、break和continue关键字的使用
*
*break: 使用范围：swith-case、循环结构中；结束或跳出当前循环结构 相同点：在次关键字的后面不能声明执行语句
*continue:循环结构中 结束(或跳出)当此循环
* 2、了解带标签的break和continue的使用
* 3、开发中，break的使用频率要远高于continue。
* */
public class BreakContinueTest {
public static void main(String[] args){
for(int i=1;i<=10;i++){
if(i%4==0){
continue;
}
System.out.println(i);
}
/*
123
123
123
123
*/
label:for(int ii=1;ii<=4;ii++){
for(int jj=1;jj<=10;jj++){
if(jj%4==0){
break label;
//continue label;
}
System.out.print(jj);
}
System.out.println();
}
}
}
Scanner:键盘输入功能的实现
import java.util.Scanner;
public class ScannerTest {
/**
* 使用Scanner获取不同类型数据的步骤
* 1、导包 import java.util.Scanner
* 2、提供(或创建)一个Scanner类的实例
* 3、调用Scanner类中的方法。获取指定类型的变量
* 4、关闭资源，调用Scanner类的close()
*
*
* Scanner类中提供了获取byte\short\int\long\float\double\boolean\string类型变量的方法。
* 注意：没有提供获取char类型变量的方法。需要使用next().charAt(0)
*/
public static void main(String[] args){
/**
* 案例：请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况
*/
Scanner scanner = new Scanner(System.in);
System.out.println("欢迎光临你来我往交友网");
System.out.println("请输入你的网名：");
String name = scanner.next();
System.out.println("name="+name);
System.out.println("请输入你的年龄：");
int age = scanner.nextInt();
System.out.println("age="+age);
System.out.println("请输入你的体重：");
double weight = scanner.nextDouble();
System.out.println("weight="+weight);
System.out.println("你输入你是否单身");
boolean one =scanner.nextBoolean();
System.out.println("是否为单身："+one);
System.out.println("请输入你的性别");
String gender = scanner.next();
System.out.println("gender="+gender);
}
}
如何获取一个随机数
public class RandomTest {
/**
* 获取一个随机数：
* 1、可以使用java提供的API:Math类的random()
* 2、random调用后，会返回一个[0.0,1.0]范围的double型的随机数
*
* 需求：获取一个[0,100]范围的随机整数？
*
* 获取一个[a,b]范围内的随机整数
* (int)(Math.random()*(b-a+1))+a
*/
public static void main(String[] agrs){
double number = Math.random();
int number_int = (int)(number*101); //获取一个[0,100]范围的随机整数
System.out.println(number_int);
int number2 = (int)(number*100+1);//获取一个[1,100]范围的随机整数
System.out.println(number2);
}
}
扫一扫
1355
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
