Java{6day}-【控制语句、方法、递归算法】

最新推荐文章于 2024-07-25 06:58:26 发布
最新推荐文章于 2024-07-25 06:58:26 发布
阅读量56 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HelloWorld337/article/details/118293812
版权

控制语句

 if 单分支结构 

语法结构：

if(布尔表达式){

        语句块;

} 

/**
 * @ClassName TestIf01
 * @Description 测试if语句，一个简单的骰子游戏。
 * @Author LHY
 * @Date 2021-6-28 9:44
 * @Version 1.0
 **/
public class TestIf01 {

    public static void main(String[] args){

        //double d = Math.random();   //Math.random()生成[0.1)之间的随机数

        int a = (int)(Math.random()*6)+1;   //生成了[1,6)之间的随机数
        int b = (int)(Math.random()*6)+1;
        int c = (int)(Math.random()*6)+1;

        int count = a+b+c;   //三次骰子数总会

        if(count >= 15 ){

            System.out.println("今天手气不错");
        }

        if (count >=10 && count < 15){

            System.out.println("今天手气一般");
        }

        if (count < 10){

            System.out.println("手气不太行");
        }
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println("总共得了"+count+"分");
    }
}

if - eslse双分支结构

语法结构：

if(布尔表达式){

        语句块1；

}else{

        语句块2；

}


/**
 * @ClassName TestIfElse
 * @Description if - else 双分支结构
 * @Author LHY
 * @Date 2021-6-28 10:11
 * @Version 1.0
 **/
public class TestIfElse {

    public static void main(String[] args){

        //随机产生yg[0.0,4.0)区间的半径，并根据半径求圆的面积和周长
        double r = Math.random()*4;      //生成一个[0.0,4.0)之间的半径
        //System.out.println(r);
        double P = 3.14;       //定义一个π

        double c = 2*P*r;      //周长
        System.out.println("半径为"+r+"的圆，其周长为"+c);

        double s = P*r*r;     //面积
        System.out.println("半径为"+r+"的圆，其面积为"+s);

        //如果面积>=周长，则输出“面积大于等于周长”，否则，输出周长大于面积
        if(s >= c){

            System.out.println("面积大于等于周长");
        }else{

            System.out.println("周长大于面积");
        }


    }
}

 if -else if -else多分支结构

语法结构： 

if(布尔表达式1){

        语句块1；

} else if（布尔表达式2）{

        语句块2；

}else{

        语句块n+1；

}

/**
 * @ClassName TestIfElseIfElse
 * @Description if else if else 多分支结构
 * @Author LHY
 * @Date 2021-6-28 10:30
 * @Version 1.0
 **/
public class TestIfElseIfElse {

    public static void main(String[] args) {

        //随机产生yg[0,100)之间的随机年龄
        int age = (int)(Math.random()*100);
        System.out.print(age+"属于");

        //根据年龄判断年龄阶段
        if (age < 15){
            System.out.println("儿童，就是玩");
        }else if(age < 25){
            System.out.println("青年，努力吧");
        }else if (age < 45){
            System.out.println("中年，要保养");
        }else if(age < 65){
            System.out.println("中老年，注意身体");
        }else if(age < 85){
            System.out.println("老年，子孙满堂");
        }else{
            System.out.println("福如东海，寿比南山");
        }
    }
}

switch语句

语法结构：

switch(表达式){

        case 值1:

                语句序列1;

                break;

        case 值2:

                语句序列2;

                break;

        default:

                默认语句;

}

/**
 * @ClassName TestSwitch
 * @Description switch语句
 * @Author LHY
 * @Date 2021-6-28 10:59
 * @Version 1.0
 **/
public class TestSwitch {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //输入大学年级
        System.out.println("请输入你的大学年级：");

        String geade = scanner.next();

        //使用switch来判断年级状态
        switch (geade){
            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;
        }
    }
}
/**
 * @ClassName TestSwitch01
 * @Description switch小练习
 * @Author LHY
 * @Date 2021-6-28 11:12
 * @Version 1.0
 **/
public class TestSwitch01 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        //输入一个月份
        System.out.println("请输入当前月份");
        String month = scanner.next();

        switch(month){
            //春季
            case "三月" :
            case "四月" :
            case "五月" :
                System.out.println("春季");
                break;

            //夏季
            case "六月" :
            case "七月" :
            case "八月" :
                System.out.println("夏季");
                break;

            //秋季
            case "九月" :
            case "十月" :
            case "十一月" :
                System.out.println("秋季");
                break;

            //冬季
            case "十二月" :
            case "一月" :
            case "二月" :
                System.out.println("冬季");
                break;

            //其他
            default:
                System.out.println("你别乱输入");
        }

    }
}

while循环

语法结构：

while(布尔表达式){

        循环体;

}

/**
 * @ClassName TestWhile
 * @Description TODO
 * @Author LHY
 * @Date 2021-6-28 14:23
 * @Version 1.0
 **/
public class TestWhile {

    public static void main(String[] args) {

        int a = 0;
        int sum = 0;

        /*while (a<=3){
            System.out.println("Four The One");
            a++;
        }*/
        //1-100累加
        while (a<=100){
            sum += a;//sum = sum+a;
            a++;
        }

        System.out.println(sum);
    }
}

 do while 循环

语法结构：

do{

        循环体

}while(布尔表达式);

/**
 * @ClassName TestDoWhile
 * @Description TODO
 * @Author LHY
 * @Date 2021-6-28 14:41
 * @Version 1.0
 **/
public class TestDoWhile {

    public static void main(String[] args) {

        int a = 0;
        while(a<0){

            System.out.println("----");
        }

        do {
            System.out.println("---");
        }while (a<0);
    }
}

 循环结构 for

语法结构：

for(初始表达式;布尔表达式;迭代因子){

        循环体;

}

/**
 * @ClassName TestFor
 * @Description 使用for循环，打印出a-z的26个字母
 * @Author LHY
 * @Date 2021-6-28 15:30
 * @Version 1.0
 **/
public class TestFor {

    public static void main(String[] args) {

        char az = 'a';

        for (int i=0;i<26;i++,az++){
           
            System.out.print(az+"\t");

        }
    }
}

嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while 与 for 循环可以任意嵌套多层。一般工作中多见的就是两层。 

/**
 * @ClassName TestLoop02
 * @Description 九九乘法表
 * @Author LHY
 * @Date 2021-6-28 17:10
 * @Version 1.0
 **/
public class TestLoop02 {

    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");
            }
            System.out.println();
        }
    }
}
/**
 * @ClassName TestLoop
 * @Description 嵌套循环
 * @Author LHY
 * @Date 2021-6-28 16:54
 * @Version 1.0
 **/
public class TestLoop {

    public static void main(String[] args){
        for(int i = 1;i<=5;i++){
            for(int j = 1;j<=5;j++){

                System.out.print(i+"\t");
            }

            System.out.println();
        }
    }
}

 break语句和continue语句

 break：在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循 环，不执行循环中剩余的语句。

/**
 * @ClassName TestRandomNum
 * @Description 生成 0-100 随机数，直到生成 88 为止，停止循环
 * @Author LHY
 * @Date 2021-6-28 21:01
 * @Version 1.0
 **/
public class TestRandomNum {

    public static void main(String[] args) {
        for (;;){
            int num = (int)(Math.random()*100);
            System.out.println("现在的随机数是："+num);
            if (num==88){
                System.out.println("当前随机数为："+num+"停止循环");
                break;
            }
        }
    }
}

 

continue：continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行 的语句，接着进行下一次是否执行循环的判定。

public class Test17 {
public static void main(String[ ] args) {
int count = 0;//定义计数器
for (int i = 100; i < 150; i++) {
//如果是 3 的倍数，则跳过本次循环，继续进行下一次循环
if (i % 3 == 0){
continue;
}
//否则（不是 3 的倍数），输出该数
System.out.print(i + "、");
count++;//没输出一个数，计数器加 1
//根据计数器判断每行是否已经输出了 5 个数
if (count % 5 == 0)
{ System.out.println();
}
}
}
}

注意事项

  • continue 用在 while，do-while 中，continue 语句立刻跳到循环首部，越过了当前循 环的其余部分。
  • ontinue 用在for循环中，跳到for循环的迭代因子部分。

 

方法

 方法（method）就是一段用来完成特定功能的代码片段，类似于其它语言的函数（function）

方法声明格式：

[修饰符1  修饰符2  ....]   返回值类型    方法名(形式参数){

        java语句;... ... ...

}

方法的调用方式：

对象名.方法名(实参列表)

方法的详细说明： 

  • 形式参数：在方法声明时用于接收外界传入的数据。
  • 实参：调用方法时实际传给方法的数据。
  • 返回值：方法在执行完毕后返还给调用它的环境的数据。
  • 返回值类型：事先约定的返回值的数据类型，如无返回值，必须指定为void。

注意事项： 

  1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
  2.  return 语句终止方法的运行并指定要返回的数据。
  3. Java 中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：
  • 基本类型传递的是该数据值的 copy 值。 
  • 引用类型传递的是该对象引用的 copy 值，但指向的是同一个对象。
/**
 * @ClassName TestDrawingMethod
 * @Description 将打印实心正方形和空心正方形封装成方法
 * @Author LHY
 * @Date 2021-6-29 23:08
 * @Version 1.0
 **/
public class TestDrawingMethod {
    //打印实心正方形
    public static void RealSquare(int a){
        for (int i = 1;i<=a;i++) {
            for (int j = 1; j <=a; j++){
                System.out.print("*\t");
            }
            System.out.println();
        }

    }
    //打印空心正方形
    public static void EmptySquare(int a){
        for (int i = 1;i<=a;i++){
            for (int j =1;j<=a;j++){
                if(i==1||i==a){
                    System.out.print("*\t");
                }else if (j==1||j==a){
                    System.out.print("*\t");
                }else{
                    System.out.print("\t");
                }
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        System.out.println("-------------打印实性正方形-------------");
        RealSquare(10);
        System.out.println("-------------打印空心正方形-------------");
        EmptySquare(10);

    }
}

方法的重载(overload) 

 方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会 根据不同的参数自动匹配对应的方法。

重载的方法，实际是完全不同的方法，只是名称相同而已！

 构成方法重载的条件：

  •  不同的含义：形参类型、形参个数、形参顺序不同
  • 只有返回值不同不构成方法的重载，如：int a(String str){}与 void a(String str){}不构成方法重载
  • 只有形参的名称不同，不构成方法的重载，如：int a(String str){}与 int a(String s){}不构成方法重载
public class Test21 {
public static void main(String[ ] args)
{ System.out.println(add(3, 5));// 8
System.out.println(add(3, 5, 10));// 18
System.out.println(add(3.0, 5));// 8.0
System.out.println(add(3, 5.0));// 8.0
// 我们已经见过的方法的重载
System.out.println();// 0 个参数
System.out.println(1);// 参数是 1 个 int
System.out.println(3.0);// 参数是 1 个 double
}
/** 求和的方法 */
public static int add(int n1, int n2) {
int sum = n1 + n2;
return sum;
}
// 方法名相同，参数个数不同，构成重载
public static int add(int n1, int n2, int n3) {
int sum = n1 + n2 + n3;
return sum;
}
// 方法名相同，参数类型不同，构成重载
public static double add(double n1, int n2) {
double sum = n1 + n2;
return sum;
}
// 方法名相同，参数顺序不同，构成重载
public static double add(int n1, double n2) {
double sum = n1 + n2;
return sum;
}
//编译错误：只有返回值不同，不构成方法的重载
public static double add(int n1, int n2) {
double sum = n1 + n2;
return sum;
}
//编译错误：只有参数名称不同，不构成方法的重载
public static int add(int n2, int n1) {
double sum = n1 + n2;
return sum;
    }
}

 

/**
 * @ClassName TestLeat
 * @Description 定义一个方法处理迟到问题
 *              (1)输入参数：迟到时间，月薪。
 *              (2)逻辑处理
 *              1.迟到1-10分钟，警告
 *              2.迟到11-20分钟，罚款100元
 *              3.迟到21-30分钟，罚款200元
 *              4.迟到30分钟以上，扣除半日工资
 *              5.迟到1小时以上，按照旷工计算，扣除3日工资
 *              (3)输出罚款金额
 * @Author LHY
 * @Date 2021-6-29 21:56
 * @Version 1.0
 **/
public class TestLeat {

    public static int Leat(int leatMinute, int monthlySalary){
        int fineMoney = 0;   //罚款

        if (leatMinute<11){
            System.out.println("迟到！！警告！！");
        }else if (leatMinute<21){
            fineMoney = 100;
        }else if (leatMinute<31){
            fineMoney = 200;
        }else if (leatMinute<61){
            fineMoney = (int)(monthlySalary/(21.5*2));
        }else{
            fineMoney = (int)((monthlySalary/21.5)*3);
        }

        return fineMoney;
    }

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("输入您的迟到时间：");
        int leatMinute = scanner.nextInt();
        System.out.println("输入您的月薪：");
        int monthlySalary = scanner.nextInt();

        System.out.println("迟到"+leatMinute+"罚款"+Leat(leatMinute,monthlySalary)+"元");

    }
}

递归结构介绍：

递归的基本思想就是“自己 调 用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺 塔、快排等问题。

递归结构包括两个部分：

  • 定义递归头：解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就 是递归的结束条件。
  • 递归体：解答：什么时候需要调用自身方法。

 注意事项

  • 任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并 且易于理解和调试，并且不强调效率问题时，可以采用递归。
  • 在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

递归的缺陷 

简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递 归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

/**
 * @ClassName TestRecursion
 * @Description 使用递归算法完成阶乘：1!+2!+3!+4!+5!
 * @Author LHY
 * @Date 2021-6-29 23:24
 * @Version 1.0
 **/
public class TestRecursion {

    public static long Recursion(int n){
        if (n==1){
            return 1;
        }else{
            return n*Recursion(n-1);
        }
    }

    public static void main(String[] args) {
        long sum = 0;
        for (int i=1;i<=5;i++){
            sum += Recursion(i);
        }

        System.out.println(sum);

    }
}

 

低温青年
关注
数据结构与算法——Java实现 6.递归
m0_73983707的博客
09-20 763
计算机科学中，递归是一种解决计算问题的方法，其中解决方案取决于同一类问题的更小子集① 自己调用自己，如果说每个函数对应着一种解决方案，自己调用自己意味着解决方案是一样的(有规律的)② 每次调用，函数处理的数据会较上次缩减(子集)，而且最后会缩减至无需继续递归③ 内层函数调用(子集处理)完成，外层函数才能算调用完成（内层完成，外层才能完成——先处理子问题。
Java——递归
Stewie Lee的博客
06-13 3785
回溯算法是一种系统化地搜索问题解空间的方法，主要用于解决组合优化问题。它通过递归地构建候选解，并在发现候选解不满足问题条件时回溯，从而尝试其他可能的选择。回溯算法的核心思想是不断尝试和撤销选择，直到找到所有可能的解决方案或者确认无解。
从零开始学Java--day04--流程控制语句(二)&方法
Jwwwy的博客
02-19 236
从零开始学Java--day04--流程控制语句(二)&方法
Java--递归
lanleihhh的博客
11-12 1028
递归 普通方法: 递归方法: 递归:递归将原本的问题转化为更小的同一问题(也就是函数/方法调用自身) 使用递归:代码中先写递归到底(递归结束条件)的情况,再写递归调用 先来看一个求累加的问题:1+2+3+…+100 最开始的时候我们使用循环去做,从1一直加到100或从100一直加到1 package com.company.project.homework; public class homework2 { public static void main(String[] args) {
java算法实现-1
jylee的博客
07-25 803
1. 算法编程 1：请编写Java代码实现实现以下逻辑与输出 ？ 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 正确回答通过率：56.0% [ 详情 ] 推荐指数： ★★★★ 试题难度： 中级 试题类型： 编程题 ▸ 写笔记 试题回答参考思路： >> 1.程序分析： 兔子的规律为数列1,1,2,3,5,8
Java0基础_day10-递归
zhugeheihei的博客
11-09 401
标签：递归算法 1.递归定义：直接/简介调用自身方法的过程 2.递归优点：简单、优雅 3.递归思想：将问题规模减少，划分为同类型但规模减少的子问题 4.递归关键：递归出口 5.递归本质：函数重复调用自身，将其压栈至初始条件最后弹栈至空的过程。 6.递归举例： 7.递归辅助方法 有时，我们对递归进行改进，使其更为简便，尤其适用于数组和字符串问题。 本质上，递归辅助方法是重载的带额外参数的递归方法。 8.递归模板 如上图所示，递归包括两个要点，即递归出口和递归返回关联...
Java基础:类与对象,递归,方法
lanssssss的博客
07-22 998
访问修饰符 返回值类型 方法名(参数表){//方法体语句;return 返回值;基本数据类型的传递是值传递，传递的是值的副本。引用数据类型的传递在表面上看起来像是引用传递（因为它传递的是对象的引用），但实际上仍然是值传递（传递的是引用值的副本）。这个副本和原始引用都指向同一个对象，因此可以通过引用修改对象的状态，但无法通过引用本身改变它指向的对象（即不能改变引用的“地址”）。Java中的递归是一种强大的编程技术，它允许一个方法直接或间接地调用自身。
Java基础篇(03)：流程控制语句，和算法应用
【积累】，是一个长期持续的过程。
07-26 257
流程控制语句对任何一门编程语言都是非常重要的，Java中基于流程控制程序执行的不同步骤和代码块。
day46---数据结构与算法（一）
ZHUSHANGLIN的博客
06-25 1259
定义在计算机科学领域，数据结构是一种数据组织、管理和存储格式，通常被选择用来高效访问数据数据结构是一种存储和组织数据的方式，旨在便于访问和修改可以说，程序 = 数据结构 + 算法，它们是每一位程序员的基本功，下来我们通过对一个非常著名的二分查找算法的讲解来认识一下算法。
Java常用控制语句：if-else和switch-case
在Java编程中，控制语句是一种用于控制程序流程的语句，其主要作用是根据条件执行不同的代码块或跳转到不同的代码位置。在控制流程中，if-else语句和switch-case语句是两种常用的控制语句。 if-else语句使用场景...
java初学者学习源代码day05.zip
07-03
这可能包括for循环、while循环，或者涉及到递归的概念，用于展示循环控制和程序流程控制。 这些源代码文件对于初学者来说是很好的实践素材，通过阅读和运行代码，可以学习到以下Java核心概念： - 类定义：了解如何...
Java入门7-面向对象基础
qq_48687155的博客
09-17 1478
面向对象基础
Java 2.0--基础阶段（建立编程思想）
Sunblogy的博客
07-26 1578
@TOCJava重学 第二章 Java了解 一、Java诞生 1、1995 年 sun正式发布Java第一个版本（创始人：gosling） 2、最新版本Java15（使用时期不长） 3、Java现在属于甲骨文公司
嵌入式-优质嵌入式项目之低功耗STM32F411开发板设计-原理图+PCB源文件+例程+驱动.zip
10-16
嵌入式_优质嵌入式项目之低功耗STM32F411开发板设计_原理图+PCB源文件+例程+驱动
毕业设计论文Hadoop+Django+Hive+Vue气象数据分析可视化大屏系统.docx
10-16
毕业设计论文
山东大学软件学院系统安全名词解释+大题复习总结
最新发布
10-16
lfb老师大三上的网安限选课，自己整理总结名词解释和大题，熟练背诵基本可得高分
重现Jun的FOC项目-FOC无刷电机.zip
10-16
重现Jun的FOC项目-FOC无刷电机
基于Spring Boot+Dubbo+Nacos+MyBatis加注解方法实现微服务调用的种子项目，用于快速构建A.zip
10-16
基于Spring Boot+Dubbo+Nacos+MyBatis加注解方法实现微服务调用的种子项目，用于快速构建A
基于MATLAB车牌识别技术实现面板GUI.zip
10-16
旅行商问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值