java流程控制数据与方法

最新推荐文章于 2024-10-05 22:51:28 发布

额么么么么

最新推荐文章于 2024-10-05 22:51:28 发布

阅读量1.7k

点赞数 24

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_48359232/article/details/141164804

版权

Java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

流程控制:

Java中流程控制分为三种结构,任何复杂的业务逻辑都可以通过这三种方式来实现.

1.顺序结构:代码逐语句顺序执行,每句代码都执行。

2.分支结构:有条件的执行某个语句,并非每句都执行。

3.循环结构:有条件的重复执行语句,并非每句都执行。

例如：条件满足

购物满500 打8折 ---------购物满500 ------- 打8折 -----单路分支

购物满500 打8折不满打9折------------------ 满足500 打8折

不满足500打9折 ----双路分支

分支结构：

单路分支

package day04;

import java.util.Scanner;

/**
 * 单路分支的使用演示类:
 */
public class IFDemo {
    public static void main(String[] args) {
        /** 语法演示:
         *  if ----->如果
         *  if(boolean){
         *      //成立所执行的代码块
         *  }
         *  判断过程:
         *          判断if小括号里的boolean 值
         *          若为true 则执行if成立的代码块
         *          若为false 代码跳过if代码块,继续向后执行....
         */
        //购物满500 打8折
        Scanner s = new Scanner(System.in);
        System.out.println("请输入购物金额 ,回车即可");
        double price = s.nextDouble();//购物金额   若要通过显示台接受 则调用 s.nextDouble();
        if (price >= 500) {//如果购物金额大于等于 500
            price *= 0.8;
            System.out.println("打完8折后应付:" + price);
        }
        System.out.println("已付款:" + price);

    }
}

双路分支：

package day04;

import java.util.Scanner;

/**
 * 双路分支使用演示类：
 */
public class ifElseDemo {
    public static void main(String[] args) {
        /* 语法结构：
         *   if(boolean){
         *       //成立所执行的代码块
         *   } else{  否则
         *       //不成立所执行的代码块
         *   }
         *   执行过程：
         *           判断小括号中的条件是否成立
         *           若成立 则执行成立对应的代码块内容。
         *           若不成立 则执行不成立对应的代码块内容。
         * */
    }
}

练习：输入一个价格，如果满500则打8折，不满则9折

public class ifElseDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个价格：");
        int price = scanner.nextInt();
        if (price >= 500) {
            price *= 0.8;
            System.out.println(price);
        } else {
            price *= 0.9;
            System.out.println(price);
        }

    }
}

多路分支：

package day04;
import java.util.Scanner;
public class IfElifDemo {
    public static void main(String[] args) {
        /**  语法结构：
         *   if(条件1){
         *      //条件1成立所执行的代码块
         *   }else if(条件2){
         *     //条件2成立所执行的代码块
         *   }else if(条件3){
         *     //条件3成立所执行的代码块
         *   }
         *    ........
         *    执行过程：
         *           先去判断条件1 是否成立,若成立则执行条件1的代码块
         *        否则再去判断条件2 是否成立,若成立则执行条件2的代码块
         *        否则再去判断条件3 是否成立,若成立则执行条件3的代码块
         */
        //什么情况下会用到多路分支？
        //答：当对一份数据 有 多个的判断条件时 ,我们应该使用多路分支。
    }

}

练习：

*/** ** *需求：根据用户输入的分数来判断用户的成绩等级。 * A. 分数大于等于 90 输出优秀 * B. 分数小于90 并且大于等于 80 输出良好 * C. 分数小于80 并且大于等于70 输出一般 * D. 分数小于70 并且大于等于60 输出及格 * E. 分数小于60 输出不及格 * /

package day04;
import java.util.Scanner;
public class IfElifDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的成绩：");
        double score = scanner.nextDouble();
        if (score > 100 || score < 0) {
            System.out.println("成绩输入错误");
        } else if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else if (score >= 70) {
            System.out.println("一般");
        } else if (score >= 60) {
            System.out.println("及格");
        } else  {
            System.out.println("不及格");
        }

    }

}

/** 练习：通过控制台的方式获取用户输入的年龄根据年龄判断人生阶段

* int age = ?;

* A. 如果 age 大于等于 0 并且小于 5 输出幼年！

* B. 如果 age 大于等于 5 并且小于18 输出青年！

* C. 如果 age 大于等于 18 并且小于 35 输出成年！

* D. 如果 age 大于等于 35 并且小于 50 输出中年！

* E. 如果 age 大于等于 50 并且小于 65 输出中老年！

* F. 如果 age 大于等于 65 并且小于 150 输出老年！

* 否则年龄不合法！

* */

package day04;
import java.util.Scanner;
public class practise001 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.println("请输入你的年龄：");
            int age = scanner.nextInt();
            if (age >= 0 && age < 5) {
                System.out.println("幼年");
            } else if (age >= 5 && age < 18) {
                System.out.println("青年");
            } else if (age >= 18 && age < 35) {
                System.out.println("成年");
            } else if (age >= 35 && age < 50) {
                System.out.println("中年");
            } else if (age >= 50 && age < 65) {
                System.out.println("中老年");
            } else if (age >= 65 && age < 150) {
                System.out.println("老年");
            }else {
                System.out.println("年龄不合法");
            }
        } catch (Exception e) {
            System.out.println("错误");
        }
    }
}

多路分支的使用二：

switch case 结构。

只能对整数类型的内容进行判断是否相等,不包括long类型。

适用性：对整数数据进行判断是否相等的效率更高一些,不能使用逻辑运算或关系运算。

JDK1.7以后还支持 String类型, 枚举类型等...

关键字：break; 代表退出到当前书写区域的结束代码块。

default: 默认若代码执行到这里代表上面的case 都没匹配或匹配了但没加break的话 ,默认语句也会执行....

package day04;
import java.util.Scanner;
public class SwitchCaseDemo {

    public static void main(String[] args) {

        //需求： 程序运行,开启服务,根据提示 选择对应的指令。
        Scanner s = new Scanner(System.in);
        System.out.println("请输入指令，1代表中文服务,2代表英文服务,0.代表人工服务");
        int user = s.nextInt();//接收指令 存给 user变量
        switch (user){
            case 1: // if(user == 1)
                System.out.println("中文服务准备开始....");
                break;//退出当前switch代码块 ,直接到switch结束的代码
            case 2: // if(user == 2)
                System.out.println("英文服务准备开始....");
                break;
            case 0: // if(user == 0)
                System.out.println("人工服务准备开始....");
                break;
            default: //默认 若代码执行到这里 代表上面的case 都没匹配  ,输出默认语句....
                System.out.println("输入的指令有误...");
        }
        System.out.println("程序向下运行...");
    }
}

在if中我们是可以结合逻辑运算符和运算符一起使用，但是使用Switch case中是不能出现运算符和逻辑运算法的

使用场景：

对整数数据进行判断是否相等的效率更高一些，这种常见建议使用Switch case

但是如果是判断区间则只能使用if，因为switch case中是不能出现逻辑运算或关系运算

循环结构：

循环：字面意思指的重复执行某个事情,反反复复的过程称之为循环。

Java中循环分为三种：

循环三要素：1.循环变量的初始化 2.基于循环变量的条件 3.循环变量的改变

跑三圈

初始圈数圈数为0

够三圈吗? 不够跑一圈圈数为1

够三圈吗? 不够跑一圈圈数为2

够三圈吗? 不够跑一圈圈数为3

够三圈吗? 够了不跑了

-------------------------------------------

三要素：

1. int count = 0; //循环变量的初始化

2. count < 3 ; //基于循环变量的条件

3 count++; //循环变量的改变

while

package day05;

public class WhereDemo {
    public static void main(String[] args) {
        /** while的 语法演示：
         *  三要素：1.循环变量的初始化  2.基于循环变量的条件  3.循环变量的改变
         *  1.
         *  while(2.){
         *      //循环条件成立所执行的代码块
         *       3.
         *  }
         *   执行过程：
         *          先去判断while小括号中的条件是否成立
         *          若成立 则执行循环代码块 执行完后会再次判断while小括号中的条件
         *          若成立 则执行循环代码块 执行完后会再次判断while小括号中的条件
         *          ....
         *          直至判断while小括号中的条件不成立时,代码继续向后执行.....
         *
         * */
        //1.循环变量的初始化  2.基于循环变量的条件  3.循环变量的改变
        int count = 0;//1.
        while (count < 3){
            System.out.println("行动是成功的阶梯,大家都是最棒的！！！");
            count++;
        }
        System.out.println("程序向下继续执行.......");
        

    }

}

练习：

一个球从100米高度坠下,每次弹起是原高度的一半。用while循环来实现。

问：

1.总共弹起多少次? (最小的弹起高度 >= 0.01)

2.总共经过多少米?

package day05;

public class WhereDemo {
    public static void main(String[] args) {
         double sphere = 100;
         double length = 100;
         int count = 0;
         while (sphere / 2 >= 0.01) {
             sphere /= 2;
             count++;
             length += sphere*2;
         }
         System.out.println("小球一共经历了：" + length + "米");
         System.out.println("小球一共弹起：" + count + "次");
    }

}

do while ：

先做一次循环体然后在判断while循环条件,至少做一次循环。

随机数：

Java中提供了可以获取随机数的功能。

Math.random(); 该功能,会返回一个double类型的小数, 0~1(注意取不到1)

package day05;

import java.util.Map;
import java.util.Scanner;

public class DoWhileDemo {
    public static void main(String[] args) {
        /** 语法结构：
         *   三要素：1.循环变量的初始化  2.基于循环变量的条件  3.循环变量的改变
         *   1.
         *   do{
         *      循环体的内容
         *      3.
         *   }while(2.);
         *
         *   执行过程：
         *   代码遇到do的结构,先执行do代码块里面的内容,然后再去判断while小括号中的条件
         *   若成立  则再次执行do代码块里面的内容,然后再去判断while小括号中的条件
         *   ....
         *   直至不成立  循环结束,代码继续向后执行。
         * */
        int count = 0; //循环变量的初始化
        do {
            System.out.println("今天继续努力");
            count++;
        } while (count < 3);
        //猜大小
        /**
         *  运行产生一个随机数(0~100),让用户在显示台中猜数字,若猜大了提示猜大了,若猜小了提示猜小了。
         *  若相等 则 提示猜对了。  2.0:若没有猜对 就要一直猜   不明确循环次数,但已知循环条件： guess != random
         * */
        double ran = Math.random();//返回给一个 double类型数据  随机的范围是0~1  但是取不到1
        System.out.println(ran);
        double ran1 = Math.random() * 100;
        System.out.println(ran1);
        int r3 = (int) (Math.random() * 100);//我们可以将随机出的小数 强转成整数来进行使用。
        System.out.println(r3);

        //如果要求区间  100 ~ 110
        //公式：  (int)(Math.random() * (最大值 - 最小值) +最小值)
        int r4 =  (int)(Math.random() * (110 - 100)+ 100);
        System.out.println(r4);
    }
}

练习：

猜数字的案例

运行产生一个随机数(0~100),让用户在显示台中猜数字,若猜大了提示猜大了,若猜小了提示猜小了。

若相等则提示猜对了。 2.0:若没有猜对就要一直猜不明确循环次数,但已知循环条件：

package day05;

import java.util.Map;
import java.util.Scanner;

public class DoWhileDemo {
        int number = (int)(Math.random() * 100);
        System.out.println(number);
        Scanner scanner = new Scanner(System.in);
        int count1 = 0;
        do{
            System.out.println("请输入你猜测的数字0-99：");
            int n = scanner.nextInt();
            if (n > 99 || n < 0) {
                System.out.println("输入的数字只能是0-99");
            } else if (n < number) {
                System.out.println("小了");
            } else if (n > number) {
                System.out.println("大了");
            } else {
                System.out.println("正确");
                break;
            }
            count1++;
        }while (count1 < 3);


    }
}

for (最常用的循环)

适用性：当已知循环次数,不明确循环条件时,使用。

for循环小括号里面声明的变量,作用的范围只在当前这个for的结构里面。其它地方视为看不到。

for (int i = 0; i < 3; i++) { //这个地方声明的变量 i 可用范围只在当前这个结构中。

System.out.println("同学们666");

}

for (int i = 0; i < 3; i++) { //这个地方的使用i 并不冲突！

System.out.println("同学们666");

}

基础语法：

package day05;

public class ForDemo {
    public static void main(String[] args) {
        /** 语法结构：
         *  三要素：①循环变量的初始化  ②基于循环变量的条件  ③循环变量的改变、
         *          ①       ②     ③
         *  for(int i = 0; i < 3; i++){
         *      ④循环体
         *  }
         *  执行流程：
         *         先做  ①    ②     ④
         *         再做  ③    ②     ④ ..③    ②     ④ ..
         *         直至  ② 不成立  循环结束
         */
        for (int i = 0; i < 3; i++) {
            System.out.println("666");
        }
        //关键字含义：continue 遇到continue跳过当次循环,直接执行下次循环
        for (int i = 1; i <= 10; i++) {
           if (i % 2 == 0) {
                System.out.println("i：" + i + "是偶数");
                continue;  //如果能执行到这里 跳过循环中的下面代码 进入下次循环
           }
           System.out.println("i：" + i + "奇数");
        }
        //关键字：break  在循环中遇到break 则表示 退出循环体！
        for (int i = 1; i <= 10; i++) {
            if(i > 5){
                System.out.println("麟鑫同学肚子疼...不能再怕跑了");
                break;//退出循环
            }
            System.out.println("麟鑫同学正在呼哧呼哧跑第:"+i+"圈");

        }
        System.out.println("让孩子歇歇吧....");
        
    }
}

双重for循环

for 里套个 for

1.现象:外层for走一轮,内层for走多次

2.外层for控制轮数,内层for控制次数. 也可以理解外层for控制行数,内层for控制列数.

package day05;

public class ForDemo2 {
    public static void main(String[] args) {
        //案例: 九九乘法表
        for (int i = 1; i < 10 ; i++){  //外层for  控制轮数
            for (int j = 1; j <= i; j++) {  //内层for  控制次数
                System.out.print(i + " * " + j + " = " + i * j + "\t");
            } //内层for的结束位置
            System.out.println();
        } //外层for的结束位置
        System.out.println("****************************************************************");
        /**
         * 
         *  *  *  *  *  * 
         *  *  *  *  *  * 
         *  *  *  *  *  * 
         *  *  *  *  *  * 
         *  *  *  *  *  * 
         * 
         * */
        for (int i = 1; i < 6; i++){
            for (int j = 1; j < 6; j++) {
                System.out.print(" * ");
            }
            System.out.println();
        }
        System.out.println("****************************************************************");
        /**
         *     *
         *    ***
         *   *****
         *  *******
         * *********
         * 
         * */
        int n = 5;  // 这里可以设置等腰三角形的高度
        for(int i = 1; i <= n; i++) {
            // 打印空格
            for(int j = 1; j <= n - i; j++) {
                System.out.print(" ");
            }
            // 打印星号
            for(int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

数组

数组:指的是一组数据,通常代表一组相同元素类型（每一个数组都只能存放同一种类型）的集合.数组是引用类型.

适用性:当需要大量存储同一类型的多个数据时,就可以使用数组.

学习目标：

1.数组的定义和初始化

2.数组的访问(使用)

3.数组相关的属性(变量), 输出数组中每个元素的内容....

数组可以理解为衣柜, 鞋柜 , 橱柜

定义:

变量定义：

int score;//声明一个int类型的变量名为score -----------里面只能存一个数据

数组定义：

int[] scores;//声明了一个int类型的数组数组名为scores ---------里面可以存储多个都是int类型的数据

double[] c;//声明了一个double类型的数组数组名为c ---------里面可以存储多个都是double类型的数据

package day06;

public class ArrayDemo {
    public static void main(String[] args) {
        // 1. 数组的定义（声明）
        int[] a;

        // 2. 数组的初始化分为两种：
        // 静态初始化： 当声明数组是，已知数组的存储个数个存储内容，则可以选择使用这种方式
        int[] b = {1, 2, 3}; //静态初始化的方式只能这样写，这能在一行中实现。
        int[] c = {10, 20, 30}; //位c这个数组开辟了三块空间，分别存储了10  20  30
        int[] c1 = new int[]{10, 20, 30, 40}; //这种方式使用的比较少，

        // 动态初始化: 当声明数组时，已知数组的存储个数，但是不知道内容，可以选择使用这种方式。
        int[] d = new int[3];//创建了一个int数组，开辟了三块空间。

        // 3. 数组的访问
        d[0] = 10; //代表访问d这个数组下标为0的区域，并赋值10；
//      d[3] = 20; //ArrayIndexOutOfBoundsException 数组下表访问越界异常错误！
        d[1] = 100; //代表访问d这个数组下标为1的区域，并赋值100；
        d[2] = 200; //代表访问d这个数组下标为2的区域，并赋值200；
        System.out.println(d[0]); //输出打印d这个数组下标为0的区域内容
        System.out.println(d[1]); //输出打印d这个数组下标为1的区域内容
        System.out.println(d[2]); //输出打印d这个数组下标为2的区域内容
        //------------------------------------------------------------------

        // 4. 打印整个数组中的每个元素。
        int[] e = {10, 20, 30, 40, 50};
        //数组提供了一个属性：length 代表数组的长度， 注意长度是从1开始计算的。
        //使用方式： 数组名.length
        //通过for循环来依次访问数组中每个元素的过程  称之为： 遍历数组。
        for (int i = 0; i < e.length; i++) {
            System.out.println(e[i]);
        }

    }
}

练习:

1.声明一个数组里面存储 50,90,60,60000,100,800 这几个数据

2.编写一个程序,求出上述数组中里最大的数据

提示:可以声明一个int 的 max变量 ,假设数组第一个元素为最大值并存储给max,依次拿max与后面的元素作比较

若max小于比较的当前数组元素,则将当前数组元素赋值给 max变量,总之保证max变量中存储的始终是最大的即可

package day06;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] array1 = {50, 90, 8000, 60, 30, 100, 56};
        int max = 0;
        for (int i = 0; i < array1.length; i++) {
            if (max < array1[i]) {
                max = array1[i];
            }
        }
        System.out.println(max);

    }
}

方法

方法的定义：方法表示的是功能。

方法的适用性：

当在程序中,遇到一段重复冗余的代码时,我们可以用方法来进行封装(包装)。

方法的语法：

[访问修饰符] 返回值类型方法名([参数]){ 方法体 }

访问修饰符：

后续会讲。

返回值类型：

² 当方法体中的业务代码产生了结果,需要将结果返回给调用者时,我们需要在返回值类型的地方写上对应结果的类型,例如 : return 结果；

² 如果没有返回值,我们用void来去表示无返回值。

方法名：建议用小驼峰命名法(见名知意)。

方法参数：

当实现本方法的业务逻辑时,需要让调用者传递数据后才能完成对应业务,则可以写方法参数。若没有需求,则不写。

方法体：存放本方法对应的功能逻辑的位置。

方法的分类：

1.无参无返回值的方法

package day06;
/***
 *  无参数无返回值的方法
 *  使用场景： 往往都是用来封装一段重复的业务逻辑时使用的形式。
 */
public class MethodDemo01 {
    public static void main(String[] args) {
        //如下的代码是 多次定义 多次使用 ----冗余重复， 不利于修改
//        System.out.println("直拳");
//        System.out.println("摆拳");
//        System.out.println("上勾拳");
//
//        System.out.println("直拳");
//        System.out.println("摆拳");
//        System.out.println("上勾拳");
//
//        System.out.println("直拳");
//        System.out.println("摆拳");
//        System.out.println("上勾拳");

        //方法的调用 3次
        attack();
        attack();
        attack();
    }

    //无参无返回值的方法定义
    //自定义的方法如果不调用，那么是不会执行的。
    //方式是一次定义，多次使用
    static void attack() {
        System.out.println("直拳");
        System.out.println("摆拳");
        System.out.println("上勾拳");
    }
}

2.有参无返回值的方法

package day06;
/**
 * 有参无返回值方法的使用
 * */
public class MethodDemo02 {
    public static void main(String[] args) {
        //当调用的方法有参数时，需要传递对应方法定义时需要的类型实际参数（实参）
        // 调用传递的参数是实际参数
        sayHi("666", 18); // 调用方法
    }
    // 方法表示的是一个功能。
    // 做一个问好的功能， 希望调用者来决定到底问谁好！
                    //String name 表示的是形参：占用一个坑，具体里面的内容，由调用者传递 多个形参使用逗号进行隔开
    static void sayHi(String name, int age) { // 方法的定义
        //这里在问好的时候，不可能是只对一个人问好，是给很多人使用的。
//        System.out.println("老六同学你好！");
        System.out.println(name + "同学你好！ 我的年龄是：" + age );

    }
}

3.无参有返回值的方法

package day06;

/**
 * 无参有返回值的方法的使用
 *  使用场景：
 *      当方法体的业务逻辑完成时，需要传递给调用者的信息，则使用无参有返回值的方法的使用
 * */
public class MethodDemo03 {
    public static void main(String[] args) {
        // 调用有返回值的方法时，可以根据需要来进行接收返回的数据类型
        double a = getPI();
        System.out.println(a);

    }
    // 做一个功能， 调用者调用这个功能，可以拿到一个 π 值 3.14159265
    // 一旦方法定义了有返回值类型，方法体在结束代码块之后，一定要用return 来返回结果，否则报错

    static double getPI() {
        // return 代表退出并返回的意思。
        return 3.14159265;
    }
}

4.有参有返回值的方法

package day06;

/**
 * 有参有返回值的方法使用；
 */
public class MethodDemo04 {
    public static void main(String[] args) {
        /**
         * 小桥去写一个代码计算1+1的代码
         *      写一个代码 计算10000 + 888的代码
         *      写一个代码 计算16541 + 4154151的代码
         *  在上面的需求中，变换的就只有加数和被加数
         * */
        int a = sum(1, 1);
        int b = sum(10000, 888);
        int c = sum(10000, 10000);
        // 要不要返回值取决于调用者，调用方法时，需不需要用到这个结果，如果需要 则写返回值，调用者可以接收
        //若一个方法，只是为了显示结果，调用者不需要，则可以不用写返回值。
    }
    //定义有参数有返回值的方法
    static int sum(int x, int y) {
        return x + y;
    }
}

方法的重载：

适用性：当方法的功能是一样的,但是由于方法的参数个数或参数类型不一样时,那么这些方法可以用一个名字来表示。

好处：对应调用者(使用功能)而言,不需要区分,只需要根据自己的需求,传递进入实际参数即可,由程序来根据传入的实际参数来具体执行对应存在的方法。

    double result = sum(1.5, 1.5);
        System.out.println(result);
                sum(10,10,10);

                //当同一个功能 有多种不同的使用时  应该让程序去区分我们使用是哪个功能,而不应该让调用者通过名字来区分

                //打印的功能  同样也实现了方法的重载: 功能一样,但是满足由于参数类型不同  所有可以用同一个方法名表示
                System.out.println(100);
                System.out.println(1.5);
                System.out.println("hello");
                System.out.println(true);
                System.out.println('o');


                }
//方法的功能是一样的,但是方法的参数个数 或 参数类型 不一样 ,可以使用方法的重载
//方法的重载：方法的功能是一样的,但是方法的参数个数 或 参数类型 不一样时,那么这些方法可以用一个名字来表示

static int sum(int a, int b) {  //定义有参数有返回值的方法
        return a + b;
        }
static double sum(double a, double b) {
        return a + b;
        }
static int sum(int a, int b, int c) {
        return a + b + c;
        }

如上面的代码，这里如果我想实现两个数字相加，还有三个数字相加小数相加，每一种方式都是需要自己定义，但是如果定义过多，记不住名字，那么就会出现错误，但是他们都有一个共同点都是加法，那么就将所有的方法名都写成一样的，在调用的时候你输入数据就会自动进行判断，这就是方法的重载，。

数组和方法相关的练习：

//需求：写一个程序,求出数组中每个元素相加和。

Int[] arr = {10, 40, 60, 80, 10};

//如何数组中的每个元素？通过for循环遍历数组

//利用一个遍历累加每个元素的数据

package day06;

public class practise01 {
    public static void main(String[] args) {
        // 需求：写一个程序，求出数组中每个元素相加和
        int[] a = {10, 20, 30, 40};
        int sum = getArrayAll(a);
//        for (int i = 0; i < a.length; i++) {
//            sum += a[i];
//        }
        System.out.println(sum);
    }
    static int getArrayAll(int[] list) {
        int sum = 0;
        for (int i = 0; i < list.length; i++) {
            sum += list[i];
        }
        return sum;
    }


}

练习：

//需求：做一个方法,用于获取三位数的数据每一位相加和,并把相加和的结果返回出去

//例如：传入 111 则返回百位 + 十位 +个位的和为 3

//百位如何求拿传入的数据/100 十位如何求 (拿传入的数据 – 百位*100)/10 个位如何求拿传入的数据 % 10

package day06;

public class practise01 {
    public static void main(String[] args) {
        System.out.println(getSum(987));
    }

    //需求：做一个方法,用于获取三位数的数据每一位相加和,并把相加和的结果返回出去
    //例如： 传入 111   则返回 百位 + 十位 +个位 的和 为  3
    //百位如何求 拿传入的数据/100     十位如何求 (拿传入的数据 – 百位*100)/10      个位如何求 拿传入的数据 % 10
    static int getSum(int number) {
        if (number < 100 || number > 999)  {
            return -1;
        } else {
            int get_wei = number % 10;
            int shi_wei = number / 10 % 10;
            int bai_wei = number / 100;
            return get_wei + shi_wei + bai_wei;
        }
    }

}

练习：

//需求：做一个方法,可以用来求10以内的阶乘和例如：传入 5 12345 的结果

// 方法名: getFactorial 要不要参数要不要返回值。

package day06;

public class practise01 {
    public static void main(String[] args) {
        System.out.println(getFactorial(10));
    }


    //需求：做一个方法,可以用来求10以内的阶乘和   例如：传入 5    1*2*3*4*5 的结果
    // 方法名: getFactorial   要不要参数要不要返回值。
    static int getFactorial(int number) {
        if (number > 1) {
            int sum = 1;
            for (int i = 1; i < number + 1; i++) {
                sum *= i;
            }
            return sum;
        } else {
            return -1;
        }

    }


}

练习：找出100 到 1000 以内的水仙花数

//水仙花数是自幂数的一种,三位数的个位十位百位的3次幂相加等于原来的数据。

//例如：153 ----- 1^3 + 5^3 + 3^3 = 153

package day06;

public class practise01 {
    public static void main(String[] args) {
        System.out.println(getDaffodils(153));
        System.out.println("******************************");
        getDaffodils1();


    }
    //水仙花数是自幂数的一种,三位数 的 个位  十位  百位 的3次幂 相加等于 原来的数据。
    //例如：153   ----- 1^3 + 5^3 + 3^3   =  153
    static String getDaffodils(int number) {
        if (number < 100 || number > 999)  {
            return "错误只能输入100 - 900";

        } else {
            int get_wei = number % 10;
            int shi_wei = number / 10 % 10;
            int bai_wei = number / 100;
            int sum = (int)(Math.pow(get_wei, 3)) + (int)(Math.pow(shi_wei, 3)) +  (int)(Math.pow(bai_wei, 3));
            if (number == sum){
                return number + "是水仙花数";
            } else {
                return number + "不是水仙花数";
            }
        }
    }

    //计算一千以内的水仙花数
    static void getDaffodils1() {
        for (int i = 100; i < 1000; i ++) {
            int get_wei = i % 10;
            int shi_wei = i / 10 % 10;
            int bai_wei = i / 100;
            int sum = (int)(Math.pow(get_wei, 3)) + (int)(Math.pow(shi_wei, 3)) +  (int)(Math.pow(bai_wei, 3));
            if (i == sum){
                System.out.println(i + "是水仙花数");
            }
        }
    }

}