Java的基本概念(3) 判断和循环

最新推荐文章于 2024-04-14 22:49:12 发布

風渐散

最新推荐文章于 2024-04-14 22:49:12 发布

阅读量517

点赞数 1

分类专栏： Java 文章标签： java jvm 算法

本文链接：https://blog.csdn.net/weixin_46253252/article/details/126856800

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一：顺序结构

按照一定顺序正常执行

//顺序结构，正常执行
public class OrderDemo {
    public static void main(String[] args) {
        System.out.println("大道如青天，道彰则恶不显，道晦则神剑出，吾名曳影!");
        System.out.println("时至今日，我还是最欣赏这个外形~");
        System.out.println("那真是一段快意时光!");
        System.out.println("本剑不才~曾以此身破万军!");
    }
}

二：分支结构

①：if语句的第一种格式：

if(关系表达式){
		语句体；
}
执行流程：
	①：首先计算关系表达式的数值
	②：如果关系表达式为true就执行语句体
	③：如果关系表达式为false就不执行语句体
	④：继续执行后面的语句体

package com.fengjiansan.order;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        /*
        需求，需要键盘录入女婿的酒量，如果大于2，则回应，否则不会有任何的回应
         */
        //键盘录入酒量
        Scanner input = new Scanner(System.in);
        System.out.println("请录女婿的酒量");
        int i = input.nextInt();
        //判断酒量大小
        if (i > 2) {
            System.out.println("小伙子，不错");
        }
    }
}

if的注意事项
		1、大括号的开头可以另起一行书写，但是建议写在第一行的末尾
		2、在语句体中，如果只有一句代码，大括号可以省略不写
		3、如果对于一个布尔类型变量判断，不用写==号，直接把变量卸载小括号里面

package com.fengjiansan.order;
public class IfDemo02 {
    public static void main(String[] args) {
        int number = 20;
        if (number >= 10){
            System.out.println(number + "的值大于10");//20的值大于10
        }


        boolean flag = true;
        //如是等号的话相当于赋值，所以直接不写来表示判断
        /*if (flag = true){
            System.out.println("falg的值为" + flag);
        }*/
        if (flag){
            System.out.println("falg的值为" + flag); //falg的值为true
        }

        boolean isFlag = false;
        if(isFlag){
            System.out.println("falg的值为" + flag); //进行表达则不会有结果
        }
    }
}

//Practice
package com.fengjiansan.test;
public class Test1 {
    public static void main(String[] args) {
        /*
        小红：如果你这次考试第一，我就做你女朋友
         */

        int ranking = 1;

        if (ranking == 1){
            System.out.println("小红成为小明的女朋友");
        }
    }
}

package com.fengjiansan.test;

public class Test2 {
    public static void main(String[] args) {
        /*
        自动驾驶，有大量判断
        如果是红灯，就停止
        如果是黄灯，就减速
        如果是绿地。就行驶
         */
        
       //分析，定义三个状态表示灯的状态
       // true 开   false 关
       boolean isLightGreen = false;
       boolean isLightYellow = false;
       boolean isLightRed= true;

       if (isLightGreen){
           System.out.println("GoGoGo");
       }

       if (isLightYellow){
            System.out.println("decelerate");
        }

       if (isLightRed){
            System.out.println("stop"); //此时是红灯
        }
    }
}

②：if语句的第二种格式：

if(关系表达式){
		语句体1;
}else {
		语句体2;
}
执行流程：
	①：首先计算关系表达式
	②：如果关系表达式的值为true则执行语句体1
	③：如果关系表达式的值为false则执行语句体2
	④：执行后面的语句体

//Practice01
package com.fengjiansan.test;
import java.util.Scanner;
public class Test3 {
    public static void main(String[] args) {
        /*
        需求，键盘录入一个整数，表示身上的钱
        如果大于等于100，就去网红餐厅
        如果小于100，就去沙县小吃
         */
        Scanner input = new Scanner(System.in);
        System.out.println("请输入身上的钱数");
        int money = input.nextInt();
        if (money >= 100){
            System.out.println("去网红餐厅吃饭");
        }else{
            System.out.println("去实惠的沙县小吃吃饭");
        }
    }
}


//Practice02
package com.fengjiansan.test;

import java.util.Scanner;

public class Test4 {
    public static void main(String[] args) {
        /*
        需求：用户在超市实际购买，商品总价为：600
        键盘录入一个整数表示用户实际支付的钱
        如果付款大于等于600，表示付款成功，反之付款失败
         */
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个整数表示付款的钱数");
        int money = input.nextInt();
        if (money >= 600){
            System.out.println("恭喜你付款成功");
        }else {
            System.out.println("对不起你余额不足，付款失败");
        }
    }
}

//Practice03
package com.fengjiansan.test;

import java.util.Scanner;

public class Test5 {
    public static void main(String[] args) {
        /*
        在实际开发中，电影院也会用到if判断
        假设某影院卖了100张票，票的序号为1~100
        其中奇数是左边的位置，偶数为右边的位置
        键盘录入一个整数表示电影票的票号
        根据不同的类型给出不同的提示
        如果号为奇数，那么打印左边
        如果号为偶数，那么打印右边
         */
        Scanner input = new Scanner(System.in);
        System.out.println("请随机输入0~100之间的数");
        int seat = input.nextInt();
        //只有座位票在0~100才能生效，对输入的数据进行校验
       if (seat >= 0 && seat <= 100){
            if (seat/2 ==0){
                 System.out.println("你好你的座位在右边");
            }else{
                 System.out.println("你号你的座位在左边");
            }
       }
    }
}

③：if语句的第三种格式：

if(关系表达式1){
		语句体1;
}else if(关系表达式2){
		语句体2;
}
	...
	else{
	语句体n+1;
}
执行流程：
	①：首先计算关系表达式1的值
	②：如果为true，就执行表达式1，如果为false就执行表达式2
	③：如果为false，就执行表达式2，如果为true就执行表达式3
	④：如果以上结果都为false，就执行n+1的语句体

注意：从上往下进行判断，只要有一个判断为真，就执行对应的语句体，如果所有的判断都为假，就执行else的语句体

//Practice01
package com.fengjiansan.test;

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        /*
       需求：根据不同的分数送不同的礼物
       如果是95~100，送一辆自行车
       如果是90~94，游乐场玩一天
       如果是80~89，送变形金刚一个
       如果是60，揍一顿
         */

        Scanner input = new Scanner(System.in);
        System.out.println("请输入考试的分数");
        int score = input.nextInt();
        //做数据校验，不能超过这以外的数
        if (score >=0 && score <= 100){
            if (score >= 95 && score <= 100){
                System.out.println("送自行车一辆");
            }else if (score >= 90 && score <= 94){
                System.out.println("游乐场玩一天");
            }else if (score >= 80 && score <= 90){
                System.out.println("变形金刚一个");
            }else if (score <= 60){
                System.out.println("饱受一份挨揍");
            }
        }else{
            System.out.println("你录入的数据不合法");
        }
    }
}


//Practice02
package com.fengjiansan.test;

import java.util.Scanner;

public class Test7 {
    public static void main(String[] args) {
        /*
        需求：商品的价格，
        商场都有VIP会员制度，根据会员会有不同的折扣
        假设商品的总价为1000
        键盘录入会员的级别，并计算出实际交付的钱
        会员1级，打9折
        会员2级，打8折
        会员3级，打7折
        非会员：不打折，打折也是腿打折
        打折计算公式：原价  * （折扣 / 10）
         */
        //商品价格
        int price = 1000;
        Scanner input = new Scanner(System.in);
        System.out.println("请录入会员的级别");
        int member  = input.nextInt();
        //做会员数据校验,防止出现非会员情况
        if (member >= 0 && member <= 3){
            if (member == 1){
                System.out.println("会员1级，打9折" + price * 0.9);
            }else if (member == 2){
                System.out.println("会员2级，打8折" + price * 0.8);
            }else if (member == 3){
                System.out.println("会员3级，打7折"+ price * 0.7);
            }else {
                System.out.println("实际支付的钱是" + price);
            }
        }else{
            System.out.println("非会员：不打折，打折也是腿打折");
        }
    }
}


//Practice03
package com.fengjiansan.test;

public class Test8 {
    public static void main(String[] args) {
         /*
        自动驾驶，有大量判断
        如果是红灯，就停止
        如果是黄灯，就减速
        如果是绿地。就行驶
         */
        //分析，定义三个状态表示灯的状态
        // true 开   false 关
        boolean isLightGreen = false;
        boolean isLightYellow = false;
        boolean isLightRed= true;
        if (isLightGreen){
                 System.out.println("GoGoGo");
            }else if (isLightYellow){
                System.out.println("decelerate");
            }else if (isLightRed){
                 System.out.println("stop"); //此时是红灯
        }
    }
}

二-二：分支结构

Switch( 表达式 ){
	case 值1：
			语句体1;
			break;
	case 值2：
			语句体2;
			break;
	case 值3：
			语句体3;
			break;
		......
	default:
			语句体n+;
			break;
}
格式说明：
		①：表达式(将要匹配的值) 取值byte、short、int、char JDK5以后是枚举，JDK7以后是String
		②：case：后面跟的是和表达式进行比较的值(被匹配的值)
		③：break：表示中断，结束的意思，用来结束switch语句
		④：default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似
		⑤：case后面的值是能是字面量，不能是变量
		⑥：case给出的值不允许重复

//Practice01
package com.fengjiansan.swtichDemo;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //兰州拉面、武汉热干面、北京炸酱面、陕西油泼面
        //定义我心里想吃的面
        String noodles = "海鮮面";
        //拿着这个面跟switch四种面进行匹配
        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("吃方便面");
                break;
        }
    }
}

//Practice02
package com.fengjiansan.test;

import java.util.Scanner;

public class Test9 {
    public static void main(String[] args) {
        /*
        需求鍵盤录入星期数，显示今天的活动
        周一：跑步
        周二：游泳
        周三：慢走
        周四：动感单车
        周五：拳击
        周六：爬山
        周日：好好吃一顿
         */
        
        //键盘录入星期数
        Scanner input = new Scanner(System.in);
        System.out.println("请输入星期");
        String week = input.next();
        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("你输入的星期不合法");
                break;
        }
    }
}

2.2.1 switch中default的位置和省略
		1、位置：default不一定写在最后面，可以写在任意位置，只不过习惯写在最下面
		2、省略：default可以省略，语法不会有问题，但是不建议省略
2.2.2 switch 中case
		1、case穿透
					就是语句体没有case的结果
		2、执行流程
					首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配
					如果匹配上了，就会执行对应的语句体，如果此时发现了break，那么结束整个switch
					如果没有发现break，那么程序会继续执行下一个case的语句体，一直到break或者大括号为止
		3、使用场景
					如果多个case语句体重复了，那我们考虑利用case的穿透去简化代码
2.2.3 switch新特性
		1、JDK12
				简化格式：case 值 ->  一段代码  此时式利用了穿透性质

package com.fengjiansan.test;
import java.util.Scanner;

public class Test10 {
    public static void main(String[] args) {
        /*
        需求：键盘录入星期数，输出工作日，休息日
       （1~5）工作日，（6~7）休息日
         */
        Scanner input = new Scanner(System.in);
        System.out.println("请输入星期");
        int week = input.nextInt();
        switch (week){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
                break;
            default:
                System.out.println("你输入的星期不合法");
                /*如果式是JDK12以上可以这样写
                * case 1,2,3,4,5 ->  System.out.println("工作日");
                * case 6,7 ->  System.out.println("休息日");
                * default ->   System.out.println("你输入的星期不合法");
                * */
        }
    }
}

//Practice02
//订机票
package com.fengjiansan.test;

import java.util.Scanner;

public class Test11 {
    public static void main(String[] args) {
        /*
        需求：假设现在我们拨打了一个机票预定电话
        电话语言提示：
        1 机票查询
        2 机票预定
        3 机票改签
        4 退出服务
        其他按键也是退出服务，请使用switch模拟该业务逻辑
         */
        Scanner  input = new Scanner(System.in);
        System.out.println("请输入按照语言提示");
        int phone = input.nextInt();
        switch (phone){
            case 1:
                System.out.println("机票查询");
                break;
            case 2:
                System.out.println("机票预定");
                break;
            case 3:
                System.out.println("机票改签");
                break;
            case 4:
                System.out.println("退出服务");
                break;
            default:
                System.out.println("退出服务");
                break;
                /*
                或者根据JDK12的新特性
                case 1 -> System.out.println("机票查询");
                case 2 -> System.out.println("机票预定");
                case 3 -> System.out.println("机票改签");
               // case 4 -> System.out.println("退出服务"); 可以不写
                default -> System.out.println("退出服务");
                 */
        }
    }
}

三：循环结构

什么是循环？
		就是重复做某事
		具有明确的开始跟关闭
		格式：
			for(初始化语句,条件判断语句,条件控制语句){
				循环体语句; 
		  	}
	执行流程：
			①：执行初始化语句
			②：执行条件判断语句，看其结果是true还是false，
						如果是false，循环结束
						如果是true，循环继续
			③：执行条件控制语句

//eg 打印10次hello world
for(i = 1 , i <= 10 ,i++){
	System.out.println("helloworld");
}

//Practice01
package com.fengjiansan.test;
public class Test12 {
    public static void main(String[] args) {
        /*
        打印1~5
         */
        for (int i = 1; i <=5 ; i++) {
            System.out.println(i);
        }
        /*
        倒着打印
         */
        for (int i = 5; i >=1 ; i--) {
            System.out.println(i);
        }
    }
}

//Practice02
package com.fengjiansan.test;
public class Test13 {
    public static void main(String[] args) {
        /*
        需求：断线重连，假设现在公司要求，短线重现连的业务组织逻辑最多写5次
        请用代码实现
       备注：断线连接的逻辑可以用逻辑输出
         */
        for (int i = 5; i >=1 ; i--) {
            System.out.println("断线重连现在还有" + i);
        }
    }
}

//Practice03
package com.fengjiansan.test;
public class Test14 {
    public static void main(String[] args) {
        /*
        用求和来计算1~5的和
         */
        //定义一个初始值
        int number = 0;
        for (int i = 1; i <= 5; i++) {
            number+=i;  // number = number + i;
        }
        System.out.println("1~5之间的和为：" + number);
    }
}

//Practice04
package com.fengjiansan.test;

public class Test15 {
    public static void main(String[] args) {
        /*
        求和 ：1~100之间的偶数和
         */
        //定义两个个初始值
        int sum = 0;
        for (int i = 1; i <=100 ; i++) {
          if (i % 2 == 0){
              sum+=i;
          }
        }
        System.out.println("偶数和为：" + sum); //2550
    }
}

//Practice05
package com.fengjiansan.test;

import java.util.Scanner;

public class Test16 {
    public static void main(String[] args) {
        /*
        需求：键盘录入两个数，表示一个取值范围，统计这个范围中
        既能够被3整除又能被5整除的数
         */
        Scanner input = new Scanner(System.in);
        System.out.print("请输入第一个数,");
        int number1 = input.nextInt();
        System.out.print("请输入第二个数,");
        int number2 = input.nextInt();
        //统计可以整除的个数
        int count = 0;
        for (int i = number1; i <= number2; i++) {
            if (i % 3 == 0 && i % 5 == 0) {
                System.out.println("这个可以整数的数为：" +i);
                count ++;
            }
        }
        System.out.println("这个可以整除的个数为:" + count);
    }
}

②：while循环

格式：
		初始化语句;
		while（条件判断语句）{
				循环体语句;
				条件控制语句;
		  	}
		  	循环控制语句；
	执行流程：
			①：初始化语句只执行一次
			②：判断语句为true，循环继续
					判断语句为false，循环结束

package com.fengjiansan.whileDemo;

public class WhileDemo01 {
    public static void main(String[] args) {
        int i=1;
        while(i <=100 ){
            System.out.println(i);
            i++;
        }
    }
}

for和while的区别

相同点：
			运行规则都是一样的
不同点：	
			for循环中，控制循环变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次访问到了
			while循环中，控制循环的变量，对while循环来说，不归属语法结构，在while循环结束后，该变量还可以继续使用

//Practice01
package com.fengjiansan.test;

public class Test17 {
    public static void main(String[] args) {
        /*
        需求：目前已知道世界上最高的山峰是珠穆朗玛(8844.43米=8844430毫米)
        假如我有一张足够大的纸，他的厚度是0.1毫米
        请问我需要对折几次 可以折成珠穆朗玛峰的高度
         */
        double hill = 8844430l; //珠峰高
        double paper = 0.1; //纸张厚度
        int count = 0; //统计次数
        //不知道循环的次数，不知道循环的范围，此时用为while反之用for
        while(paper < hill){
            //折叠纸张
            paper *= 2;
            count++;
        }
        System.out.println("折叠的次数是：" + count);
    }
}


//Practice02
package com.fengjiansan.test;

public class Test18 {
    public static void main(String[] args) {
        /*
        需求：给你一个整数X
        如果X是一个回文整数，打印true,否则,返回false
        解释：回文数是指（从左往右）和倒叙(从右往左)读都是一样的整数
        例如：121，而不是123
         */
        int x = 1234;
        int temp = x;
        int num = 0;
        while(x != 0){
            //从右往左获取，每一位的数字
            int ge = x % 10;
            //修改X记录的值
            x = x / 10;
            //把接受的字符进行拼接
            num = num * 10 +ge;
        }
        System.out.println(num);
        System.out.println(x);
        System.out.println(num == temp );
    }
}

//Practice03
package com.fengjiansan.test;
public class Test19 {
    public static void main(String[] args) {
        /*
        需求：给定两个数，被除数和除数(都是正数，且不超过int的值)
        将两数相除，要求不使用乘法，除法和取模
        得到商和余数
         */
        //被除数
        int dividend = 100;
        //除数
        int divisor = 10;
        int count = 0;
        //如果被除数一直大于除数，那就一直减法，得到商跟余数
        while(dividend >= divisor){
            dividend -= divisor;
            count++;
        }
        System.out.println(dividend);
        System.out.println("减的次数是：" + count);
    }
}

③：do…while循环

格式：
		初始化语句;
		do{
				循环体语句;
				条件控制语句;
		  	}while(条件判断语句);
	执行流程：
			①：先执行后判断                基本很少用到

四：循环高级

无限循环： 一直循环，不会停下
	格式一：	for(;;){ 循环语句体 }
	格式二：	while(true){ 循环语句体 }
	格式三：	do{  循环语句体 }while(true);
跳转控制语句：
	再循环的过程中，跳到其他语句执行，不执行当次的循环
	①：continue

package com.fengjiansan.skiplop;
public class SkipLopDemo01 {
    public static void main(String[] args) {
        for (int i = 1; i <=5 ; i++) {
            if(i == 3){
                continue;//跳出当次循环
            }
            System.out.println(i);
        }
    }
}

②：break；直接从某一次循环终止，结束整个循环

package com.fengjiansan.skiplop;
public class SkipLopDemo01 {
    public static void main(String[] args) {
        for (int i = 1; i <=5 ; i++) {
            if(i == 3){
                break;//直接中止本次循环
            }
            System.out.println(i);
        }
        for (int i = 1; i <=5 ; i++) {
            System.out.println(i);
            if(i == 3){
                break;//先执行，在判断，还是会执行当前的循环，执行完后结束整个循环
            }
        }
    }
}

五：练习

①：逢七过

package com.fengjiansan.practice;

public class Practice01 {
    public static void main(String[] args) {
        /*
        逢七过
        游戏规则：从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数时都要说过：过
        需求：使用程序在控制台打印出1-100之间的满足逢七过规则的数据
         */
        for (int i = 1; i <= 100 ; i++) {
            if (i % 10 == 7 || i / 10 % 10 ==7 || i % 7 ==0 ){
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }
    }
}

②：求平方根

package com.fengjiansan.practice;

import java.util.Scanner;

public class Practice02 {
    public static void main(String[] args) {
        /*
        需求：键盘录入一个大于等于2的整数x，计算并返回X的平方根
        结果只保留整数部分，小数将被舍去
         */
        Scanner input = new Scanner(System.in);
        System.out.println("请录入一个大于等于2的整数");
        int num = input.nextInt();
        for (int i = 1; i < num ; i++) {
            if (i * i ==num){
                System.out.println(i +"就是" + num + "算数平方根");
            }else if (i * i >= num){
                System.out.println((i - 1 ) + "就是" + num + "整数部分");
                break;
            }
        }
    }
}

③：求质数

package com.fengjiansan.practice;

import java.util.Scanner;

public class Practice03 {
    public static void main(String[] args) {
        /*
        需求：键盘录入一个正整数X，判断该整数是否为一个质数
        质数：如果能被本身和1整除的数
         */
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个正整数");

        //标记number是否为一个质数
        boolean flag = true; //最初就认为number就是一个质数
        int number = input.nextInt();
        for (int i = 2; i < number ; i++) {
            if (number % 1 ==0 ){
                flag = false;
                //System.out.println(i +"不是质数");
                break;
            }
        }
        if (flag){
            System.out.println(number +"是一个质数");
        }else {
            System.out.println(number + "不是一个质数");
        }
    }
}

④：猜数字小游戏

生成随机数：
		Java帮我们生成一个类叫Random这个类就可以生成随机数
		①：导包
		import Java.util.Random
		②：创建对象
		Random random = new Random();
		③：生成随机数
		int  random = reandom.nextInt(随机数的范围)；
		 //表示从1-100，想要从几个数开始+多少，还要注意括号里面的数跟加数加起来要等一最大值-1
        int number = random.nextInt(100) + 1;
        //生成的数一定是从0开始的
    //包头不包尾，包左不包右

package com.fengjiansan.practice;

import java.util.Random;
import java.util.Scanner;

public class Practice04 {
    public static void main(String[] args) {
        /*
        需求：程序自动生成一个1~100之间的随机数，使用程序实现猜出这个数字是多少？
         */
        int count = 0;
        Random random = new Random();
        //表示从1-100，想要从几个数开始+多少，还要注意括号里面的数跟加数加起来要等一最大值-1
        int number = random.nextInt(100) + 1;
        //生成的数一定是从0开始的
        //包头不包尾，包左不包右
        Scanner scan = new Scanner(System.in);
        while (true){
            System.out.println("请输入你要猜的数字");
            int guessNumber = scan.nextInt();
            count++;
            if (count == 3 ){
                System.out.println("猜中了");
                break;
            }
            if (guessNumber > number){
                System.out.println("大了");
            }else if (guessNumber < number){
                System.out.println("小了");
            }else {
                System.out.println("猜中了");
                break;
            }
        }
    }
}