java第一阶段（day04）方法

已于 2022-09-01 09:40:33 修改
阅读量253 收藏
点赞数
分类专栏： 第一阶段 文章标签： java 开发语言 后端
于 2022-02-14 19:10:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshine195/article/details/122930408
版权

每日随机

public static void main(String[] args) {
    //摇号  1-30
    //double randomNum = Math.random()*30+1;//0.0-30.0  包头不包尾
    //System.out.println(randomNum);
    //1000-10000
    //(Math.random()*9000+1000)
    int[] array = {5};//维护之前随机过的数字
    //循环遍历 参与过这些号码
    int num;
    while (true) {
        boolean flag = false;
        num = (int) (Math.random() * 30 + 1);
        for (int i : array) {
            if (num == i) {
                flag = true;
                break;
            }
        }
        //从开始到末尾一直比较  都与随机数字不等的话 结束外层循环
        if (!flag) {
            break;
        }
    }
    System.out.println("随机的数字:" + num);

}

方法

//psvm/main
public static void main(String[] args) {

}

1. 组成部分

[1. 访问权限修饰符]   public 公共的   private   protected 默认/缺省
    
[2. 普通修饰符]       static 静态的   final  synchronized  native  abstract
    
3. 方法的返回值类型----> 所有的数据类型都可以充当方法的返回值类型
    ---> 只能返回一种数据类型
    1.1 void 无返回值类型---> Void类   
    1.2 有返回值类型
    
4. 方法名称----> 变量名  类名  方法名 都属于标识符。只要自己命名的东西
      ---> 规范: 小写驼峰  目前方法名唯一
      
5. 形式参数---->形参
    1.1 无参 a()
    1.2 有参 所有的数据类型都可以充当参数   b(int a,String s)
        其实就是局部变量
    
[6. {}]   方法体  编写功能代码

2. 分类

一般是结合返回值和形式参数进行分类。

1.1 无参无返回值

1.2 无参有返回值

1.3 有参无返回值

1.4 有参有返回值

3. 自定义方法

3.1 无参无返回值

学习中+写作业+功能测试

//方法与方法之间是平级的关系
//创建无参无返回值方法
public static void demo() {
    System.out.println("demo.............");
}

public static void a() {
    System.out.println("a.............");
}

在方法里面调用方法

  //方法入栈 先进后出
    public static void main(String[] args) {
        System.out.println("main开始....................");

        //调用a方法
        a();

        System.out.println("main结束....................");
    }

3.2 无参有返回值

//需求: 模拟用户登录
public static boolean userLogin() {

    String username = "admin";
    String password = "admin";
    Scanner input = new Scanner(System.in);
    System.out.println("请录入用户名:");
    String name = input.nextLine();

    System.out.println("请录入密码:");
    String pass = input.nextLine();

    if (!username.equals(name) || !password.equals(pass)) {
        return false;
    }

    //jdhffgd
    return true;
}

public static void main(String[] args) {

        System.out.println("main开始....................");

        //调用demo方法
        //对于方法的返回值  谁调用它  就把数据返给谁
        //int num = demo();//接收返回值
        //int result = num + 100;

        if(userLogin()){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
        System.out.println(userLogin());

        System.out.println("main结束...................." );

    }

3.3 有参无返回值

//参数传递:  值传递
// 1.基本数据类型作为形参  传递的是数据
// 2.引用数据类型作为形参 传递的是内存地址值(引用传递)
// 3. String： 数据不可变 1.11  private final byte[] value;

1. 基本数据类型

//创建有参无返回值
//形式参数: 参数个数  参数类型
public static void demo1(int num1) {
    System.out.println("demo1.。。。。。。。。。。。");
    if (num1 < 0) {
        System.out.println("num1是一个负数");
        return;
    }
    num1 += 100;
    System.out.println("num1运算之后的数据:" + num1);//200
}

 public static void main(String[] args) {

        System.out.println("main开始..................");
        //调用方法
        //调用有参的方法  必须传参  实际参数---> 实参
        //int num1 = 100;
        //demo1(num1);
        System.out.println("main结束..................");

        //System.out.println("main里面的num1的数据:" + num1);
        //参数传递: 基本数据类型作为形参  传递的是数据

    }

2. 引用数据类型_数组

//修改数组的第一个数据
public static void demo2(int[] array) {
    //提前预判 避免出现一些不正常的现象
    if (array == null) {
        System.out.println("参数不能为null");
        return;
    }
    int length = array.length;
    if (length == 0) {
        System.out.println("[]");
        return;
    }

    array[0] = 100;
    //遍历所有的数据
    /*for (int i : array) {
            System.out.println("元素是:" + i);
        }*/
    System.out.println("demo2修改之后的数组元素：" + Arrays.toString(array));//[100, 2, 3]
}

public static void main(String[] args) {

    System.out.println("main开始..................");

    //int[] array = new int[]{1, 2, 3};
    //demo2(array);
    //System.out.println("main里面的array的数据:" + Arrays.toString(array));// [1,2,3] [100,2,3]
}

3. 引用数据类型_String

public static void demo3(String str) {
    System.out.println("demo3修改之前的数据:" + str);
    str = "hello";
    System.out.println("demo3..........str：" + str);
}

String str = "abc";
demo3(str);
System.out.println("main里面str的数据:" + str);//hello  abc   String的数据不可变的 常量 final char[] value;

4. 可变参数

//用户注册
//用户名  密码  年龄  简介---> 获得数据数量不固定的
//不清楚具体传输多少个数据的时候  可以使用可变参数进行维护
//数据类型...变量名称
//一个方法里面有且只有1个可变参数  必须在方法形参的最后一个位置上
//可变参数就是一个一维数组   传参的时候可以传递>=0个数据
//底层使用的时候比较多。 封装的时候   反射

public static void userRegister(String... params) {
    System.out.println("params:" + Arrays.toString(params));//[]
}

3.4 有参有返回值

/**
     * 模拟实现计算器功能
     *
     * @param num1     第一个数字
     * @param num2     第2个数字
     * @param operator 运算符
     * @return 运算之后的结果
     */
public static double cal(int num1, int num2, String operator) {
    if ("/".equals(operator) || "%".equals(operator)) {
        if (num2 == 0) {
            System.out.println("除数不能为0");
            //不需要返回数据  还要结束当前这个方法  终止当前程序
            //1.可以使用手动产生异常  throws
            //2.System.exit(-1);
            System.exit(-1);//终止当前程序
        }
    }
    double result = 0;
    switch (operator) {
        case "+":
            result = num1 + num2;
            break;
        case "-":
            result = num1 - num2;
            break;
        case "*":
            result = num1 * num2;
            break;
        case "/":
            result = num1 / num2;
            break;
        case "%":
            result = num1 % num2;
            break;
        default:
            System.out.println("录入运算符不符合要求!");
            System.exit(-1);
    }
    return result;
}

4.课堂练习

1.随机产生1-30的数，出现的不能再出现

public class Random {

        public static void main(String[] args) {

            int[] array = {1,2};//维护之前随机出现过的数字，出现的将不让其出现
            //循环遍历 参与过这些号码
            int num;            
            while (true) {
                boolean flag = false;     //表示此次产生的随机数与之前不同
                num = (int) (Math.random() * 30 + 1);
                for (int i : array) {     
                    if (num == i) {       
                        flag = true;
                        break;           //如果相等，跳出此次for循环，下面的if为false，也不执行，再次执行while循环
                    }                    //如果遍历结束不等，flag还是false值，在if中为true，执行，然后退出while循环
                }
                if (!flag) {
                    break;
                }
            }
            System.out.println("随机的数字:" + num);

        }
    }

2.无参无返回值(方法与方法之间是平级的关系)

public class MethodDemo1 {

    public static void demo() {
        System.out.println("demo.............");
    }

    public static void a() {
        //调用demo方法   我们方法在同一个文件中  方法名称();
        demo();
        System.out.println("a.............");
    }

       //方法入栈 先进后出
     public static void main(String[] args) {       //jdk会从main方法开始运行
        System.out.println("main开始....................");
        //调用a方法
        a();
        System.out.println("main结束....................");
    }
}

3.无参有返回值

public class MethodDemo2 {

    public static void main(String[] args) {
        System.out.println("main开始....................");
        //调用demo方法
        //对于方法的返回值  谁调用它  就把数据返给谁
        //int num = demo();        //接收返回值
        //int result = num + 100;
        if (userLogin()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
        System.out.println(userLogin());

        System.out.println("main结束....................");
    }

    public static void a() {
        System.out.println("djshsdgds");
        return;                           //没有返回值的方法，可以不写return语句 或者return；
    }

    //需求: 模拟用户登录
    public static boolean userLogin() {

        String username = "admin";
        String password = "admin";
        Scanner input = new Scanner(System.in);
        System.out.println("请录入用户名:");
        String name = input.nextLine();

        System.out.println("请录入密码:");
        String pass = input.nextLine();

        if (!username.equals(name) || !password.equals(pass)) {
            return false;
        }
        return true;
    }

    //创建无参有返回值 返回值类型很灵活  结合需求分析
    //在有返回值的方法中: 在方法体里面必须写 return 语句;   return 数据;
    public static int demo() {
        //必须返回一个与返回值类型相似(类型转换)/相同的数据;
        //动态录入2个数据  比较
        Scanner input = new Scanner(System.in);
        System.out.println("录入第1个数据:");
        int num1 = input.nextInt();
        System.out.println("录入第2个数据:");
        int num2 = input.nextInt();

        if (num1 > num2) {
            return 100;                       //看到return，就结束方法
        }
        System.out.println("a-----------------");
        return 200;
    }
}

4.有参无返回值

public class MethodDemo3 {
    //一个方法就是一个栈帧     栈帧: 局部变量表

    public static void main(String[] args) {
        System.out.println("main开始..................");
        //调用方法
        //调用有参的方法  必须传实际参数(简称实参）
        //int num1 = 100;
        //demo1(num1);     调用demo1，把实参100传给它

        //int[] array = new int[]{1, 2, 3};---------------------------------对应demo2
        //demo2(array);
        //System.out.println("main里面的array的数据:" + Arrays.toString(array));
        //实参若为数组，传回的是内存地址值

        //String str = "abc";----------------------------------------对应demo3
        //demo3(str, 100);
        //System.out.println("main里面str的数据:" + str);
        //String的数据不可变的

        userRegister("admin", "1234", "男", "河南郑州", "100");

        System.out.println("main结束..................");
        //System.out.println("main里面的num1的数据:" + num1);
        //参数传递:  值传递
        // 1.基本数据类型作为形参  传递的是数据
        // 2.引用数据类型作为形参 传递的是内存地址值(引用传递)
        // 3.String： 数据不可变 1.11  private final byte[] value;

    }

    //用户注册
    //用户名  密码  年龄  简介---> 获得数据数量不固定的
    //不清楚具体传输多少个数据的时候  可以使用可变参数进行维护      使用方法：数据类型...变量名称
    //一个方法里面有且只有1个可变参数  必须在方法形参的最后一个位置上
    //可变参数就是一个一维数组   传参的时候可以传递>=0个数据
    //底层使用的时候比较多。 封装的时候   反射

    public static void userRegister(String... params) {
        System.out.println("params:" + Arrays.toString(params));   //["admin", "1234", "男", "河南郑州", "100"]
    }

    //一个方法最多可以有多少个形参?  <=4
    public static void demo3(String str, int num) {           //传入了“abc”和100
        System.out.println("demo3修改之前的数据:" + str);       //此时为“abc”
        str = "hello";
        System.out.println("demo3..........str：" + str);
    }


    //修改数组的第一个数据
    public static void demo2(int[] array) {
        //提前预判 避免出现一些不正常的现象
        if (array == null) {
            System.out.println("参数不能为null");
            return;
        }
        int length = array.length;
        if (length == 0) {
            System.out.println("[]");
            return;
        }

        array[0] = 100;
        //遍历所有的数据
        /*for (int i : array) {
            System.out.println("元素是:" + i);
        }*/
        System.out.println("demo2修改之后的数组元素：" + Arrays.toString(array));//[100, 2, 3]
    }

    //创建有参无返回值
    //形式参数: 参数个数  参数类型
    public static void demo1(int num1) {
        System.out.println("demo1.。。。。。。。。。。。");
        if (num1 < 0) {
            System.out.println("num1是一个负数");
            return;
        }
        num1 += 100;
        System.out.println("num1运算之后的数据:" + num1);//200

    }
}

4.1 有参无返回值-01 (可传多个参数)

public class MethodDemo301 {

    public static void main(String[] args) {
        System.out.println("main开始..................");
        userRegister("admin", "1234", "男", "河南郑州", "100");
        System.out.println("main结束..................");
    }

    public static void userRegister(String... params) {
        System.out.println("params:" + Arrays.toString(params));   //["admin", "1234", "男", "河南郑州", "100"]
    }

}

4.2 有参无返回值-02 (String)

public class MethodDemo302 {

    public static void main(String[] args) {
        System.out.println("main开始..................");
        String str = "abc";
        demo3(str, 100);
        System.out.println("main里面str的数据:" + str);         //这里为“abc”
        System.out.println("main结束..................");
    }

    public static void demo3(String str, int num) {           //传入了“abc”和100
        System.out.println("demo3修改之前的数据:" + str);       //此时为“abc”
        str = "hello";
        System.out.println("demo3修改之后的数据：" + str);     //这里为"hello"
    }

}

4.3 有参无返回值-03 （数组）

public class MethodDemo303 {

    public static void main(String[] args) {
        System.out.println("main开始..................");
        int[] array = new int[]{1,2,3};                         //int[] array = new int[0];
        // 或者 int[] array = new int[]{};  是数组长度为0，是[]，数组并不为空，向堆内存申请了空间
        //int[] array = null;    这是直接参数为null。数组为空，此时array不指向任何对象
        demo2(array);
        System.out.println("main里面的array的数据:" + Arrays.toString(array));       //[100,2,3]
        System.out.println("main结束..................");
    }

    public static void demo2(int[] array) {
        //提前预判 避免出现一些不正常的现象
        if (array == null) {
            System.out.println("参数不能为null");
            return;
        }
        int length = array.length;
        if (length == 0) {
            System.out.println("[]");
            return;
        }

        array[0] = 100;
        //遍历所有的数据
        /*for (int i : array) {
            System.out.println("元素是:" + i);
        }*/
        System.out.println("demo2修改之后的数组元素：" + Arrays.toString(array));     //[100, 2, 3]
    }
}

4.4 有参无返回值-04

public class MethodDemo304 {

    public static void main(String[] args) {
        System.out.println("main开始..................");
        int num1 = 100;
        demo1(num1);
        System.out.println("num1的值为:" + num1);                      //100
        System.out.println("main结束..................");
    }

    public static void demo1(int num1) {
        System.out.println("demo1.。。。。。。。。。。。");
        if (num1 < 0) {
            System.out.println("num1是一个负数");
            return;
        }
        num1 += 100;
        System.out.println("num1运算之后的数据:" + num1);                  //200
    }

}

5.有参有返回值

public class MethodDemo4 {

    public static void main(String[] args) {
        //使用有参有返回值: 模拟实现计算器功能
        //整数之间运算  byte  short  int  long

        /*double num = cal(10, 0, "+");
        System.out.println(num);*/

        long lon1 = 1000L;
        long lon2 = 2000L;

        cal(lon1, lon2, "*");
    }

    //在一个文件里面 很多重名的方法  一般是出现在工具类里面
    //方法重载: overload
    //1. 方法名必须相同的
    //2. 形参列表必须不同
    //3. 与修饰符/返回值类型无关

    private static int a(int a) {
        return 0;
    }

    public static double cal(long num1, long num2, String operator) {
        if ("/".equals(operator) || "%".equals(operator)) {
            if (num2 == 0) {
                System.out.println("除数不能为0");
                //不需要返回数据  还要结束当前这个方法  终止当前程序
                //1.可以使用手动产生异常  throws
                //2.System.exit(-1);
                System.exit(-1);                          //终止当前程序
            }
        }
        double result = 0;
        switch (operator) {
            case "+":
                result = num1 + num2;
                break;
            case "-":
                result = num1 - num2;
                break;
            case "*":
                result = num1 * num2;
                break;
            case "/":
                result = num1 / num2;
                break;
            case "%":
                result = num1 % num2;
                break;
            default:
                System.out.println("录入运算符不符合要求!");
                System.exit(-1);
        }
        return result;
    }

//可在方法前面也加文档注释
    /**
     * 模拟实现计算器功能
     *
     * @param num1     第一个数字
     * @param num2     第2个数字
     * @param operator 运算符
     * @return 运算之后的结果
     */
    public static double cal(int num1, int num2, String operator) {
        if ("/".equals(operator) || "%".equals(operator)) {
            if (num2 == 0) {
                System.out.println("除数不能为0");
                //不需要返回数据  还要结束当前这个方法  终止当前程序
                //1.可以使用手动产生异常  throws
                //2.System.exit(-1);
                System.exit(-1);//终止当前程序
            }
        }
        double result = 0;
        switch (operator) {
            case "+":
                result = num1 + num2;
                break;
            case "-":
                result = num1 - num2;
                break;
            case "*":
                result = num1 * num2;
                break;
            case "/":
                result = num1 / num2;
                break;
            case "%":
                result = num1 % num2;
                break;
            default:
                System.out.println("录入运算符不符合要求!");
                System.exit(-1);
        }
        return result;

    }
}

5.课后作业（ 幸运抽奖 ）

public class Lucky {

    public static void main(String[] args) {
        startGame();
    }

    private static void startGame() {
        Scanner input = new Scanner(System.in);
        String answer;
        boolean regFlag = false;                            //注册标志
        boolean loginFlag = false;                          //登录标志
        do {
            System.out.println("\n*********** 欢迎进入大富翁抽奖系统 ***********\n");
            System.out.println("                   1.注 册 ");
            System.out.println("                   2.登 录 ");
            System.out.println("                   3.抽 奖 ");
            System.out.println("                   5.查询所有的会员信息 ");
            System.out.println("                   4.退 出 \n");
            System.out.println("*********************************************\n");

            System.out.print("请选择要进行的操作(1-4)： ");
            int choice = input.nextInt();
            switch (choice) {
                case 1:
                    regFlag = register(input);                      //实际参数用的input，利用参数传递，为了用第一句话
                    break;
                case 2:
                    loginFlag = login(input, regFlag, loginFlag);
                    break;
                case 3:
                    lucky(input, loginFlag);
                    break;
                case 4:
                    System.out.println("程序退出");
                    input.close();                                 //程序退出也要释放资源
                    return;
            }
            System.out.println("是否继续?y/n");
            answer = input.next();
        } while ("y".equals(answer));

        System.out.println("程序结束");
        input.close();

    }

    private static void lucky(Scanner input, boolean loginFlag) {
        if (!loginFlag) {
            System.out.println("请先登录");
            return;
        }
        System.out.println("录入会员卡号:");
        int memberNo = input.nextInt();

        int[] array = new int[5];
        for (int i = 0; i < 5; i++) {
            array[i] = (int) (Math.random() * 9000 + 1000);
        }
        System.out.println("本日的幸运卡号:" + Arrays.toString(array));
        for (int num : array) {
            if (num == memberNo) {
                System.out.println(memberNo + "是幸运会员");
                return;
            }
        }
        System.out.println(memberNo + "不是幸运会员");
    }

    private static boolean login(Scanner input, boolean regFlag, boolean loginFlag) {
        //已经成功地注册数据
        if (!regFlag) {
            System.out.println("请先注册");
            return false;
        }
        if (loginFlag) {
            System.out.println("您已经成功登陆过了，无需重复登录");
            System.out.println("是否切换账号登录y/n");
            String s = input.next();
            if ("n".equals(s)) {
                return true;
            }
        }
        int count = 3;
        String loginName;
        do {
            count--;
            System.out.println("请填写登录信息 ");
            System.out.print("请输入用户名： ");
            loginName = input.next();

            System.out.print("请输入密码： ");
            String loginPass = input.next();

            //比较----> 与注册时候的信息比较（信息存储数组中了）
            for (int index = 0; index <= totalCount; index++) {
                if (loginName.equals(nameArray[index]) && loginPass.equals(passArray[index])) {
                    System.out.println("欢迎你:" + loginName);
                    return true;
                }
            }
            if (count == 0) {
                System.out.println("机会使用完毕，返回主页面");
                return false;
            }
            System.out.println("登录失败，还剩下" + count + "次机会，请重新登录!");
        } while (true);

    }

    public static int totalCount = 0;//维护的数组中有小的元素个数  以及一个人所有信息的索引位置
    public static String[] nameArray = new String[10];
    public static String[] passArray = new String[10];
    public static int[] randomNoArray = new int[10];

    //在一个方法中: 如何获得另外一个方法里面的变量?
    // 1. 参数传递
    // 2. 全局变量:  放在方法之外   所有的方法都可以访问全局变量
    private static boolean register(Scanner input) {
        System.out.println("请填写个人注册信息 ");
        System.out.print("请输入用户名： ");
        String name = input.next();
        
        System.out.print("请输入密码： ");
        String pass = input.next();

        int randomNo = (int) (Math.random() * 9000 + 1000);
        int length = nameArray.length;

        if (totalCount + 1 >= length) {
            //扩容
            nameArray = Arrays.copyOf(nameArray, 2 * totalCount);              //存放用户名的数组扩容
            passArray = Arrays.copyOf(passArray, 2 * totalCount);
            randomNoArray = Arrays.copyOf(randomNoArray, 2 * totalCount);
        }
        nameArray[totalCount] = name;
        passArray[totalCount] = pass;
        randomNoArray[totalCount] = randomNo;

        totalCount++;

        System.out.println("注册成功! 请牢记您的会员号");
        
        System.out.println("用户名\t密码\t会员卡号");
        System.out.println(name + "\t" + pass + "\t" + randomNo);
        return true;
    }
}


6.附加题

public class FuJiaExercise {

    public static void main(String[] args) {
        exercise12();
    }

    private static void exercise12() {

        //定义一个长度为31的整数数组，依次放入的2的若干次方，第一个放1，第二个放2，第三个放4，第四个放8。。。。并输出
        int[] array = new int[31];
        for (int index = 0; index < 31; index++) {
            array[index] = (int) Math.pow(2, index);
        }
        System.out.println(Arrays.toString(array));


    }

    private static void exercise11() {
        //现在有如下一个数组： int[]  oldArr={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; 要求将以上数组中的0项去掉，将不为0的值存入一个新的数组，生成新的数组为
        int[] oldArr = {1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5};
        int[] newArr = new int[oldArr.length];
        //获得原数组中不为0 的数据
        int index = 0;
        for (int i : oldArr) {
            if (i != 0) {
                newArr[index++] = i;
            }
        }
        newArr = Arrays.copyOf(newArr, index);
        System.out.println(Arrays.toString(newArr));

    }

    private static void exercise10() {
        //现有4个数字为6、7、9、5，能组成多少个互不相同且无重复数字的三位数？都是多少？
        //例如有 679，675，697，695，657，659.....等等
        //4*3*2=24
        int[] array = {6, 7, 9, 5};
        int length = array.length;
        int count = 0;
        for (int baiIndex = 0; baiIndex < length; baiIndex++) {
            int bai = array[baiIndex];
            for (int shiIndex = 0; shiIndex < length; shiIndex++) {
                int shi = array[shiIndex];
                for (int geIndex = 0; geIndex < length; geIndex++) {
                    int ge = array[geIndex];
                    if (bai != shi && shi != ge && ge != bai) {
                        count++;
                        System.out.print(bai + "" + shi + "" + ge + "\t");
                    }

                }

            }
        }
        System.out.println();
        System.out.println(count);
    }

    private static void exercise9() {
        //定义一个长度为10的int类型数组，接受10个值后使用冒泡排序算法对数组进行排序
        int[] array = {87, 84, 83, 81};
        for (int i = 1; i < array.length; i++) {
            for (int j = 0; j < array.length - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));

    }

    private static void exercise8() {

        //请用程序接收一个三位数，然后打印出所有0到这个数之间 带3和3的倍数的数
        //例如 有99 , 96 , 93 , 90 , 87 , 84 , 83 , 81 , 78 , 75 , 73 , 72.......等等
        for (int num = 100; num >= 1; num--) {
            if (num % 3 == 0 || num % 10 == 3 || num / 100 == 3 || num / 10 % 10 == 3) {
                System.out.print(num + ", ");
            }
        }
        
    }

    private static void exercise7() {

        //一球从100米高度处自由落下，每次落地后反跳回原高度的一半；再落下再弹回，求它在 第10次落地反弹时，反弹多高？以及共经过多少米？

        double height = 100;
        double sum = 0;
        for (int i = 1; i <= 10; i++) {
            height /= 2;
            sum += 3 * height;
        }


        System.out.println("反弹多高:" + height);
        System.out.println("共经过多少米:" + sum);

    }

    private static void exercise6() {
        //一张纸的厚度大约是0.08mm，对折多少次之后能达到珠穆朗玛峰的高度（8848.13米）

        int count = 0;
        double height = 0.08;
        while (height < 8848130) {
            height *= 2;
            count++;
        }
        System.out.println("对折多少次：" + count);

    }

    private static void exercise5() {
        //计算用户输入的日期离1900年1月1日相距多少天
        
        int year = 1901;
        int month = 1;
        int day = 1;
        
        //算年: 365 366 年是否是闰年
        for (int y = 1900; y < year; y++) {
            if (y % 4 == 0 && y % 100 != 0 || y % 400 == 0) {
                day += 366;
                continue;
            }
            day += 365;
        }

        //算月份: 30 31  29/28
        for (int m = 1; m < month; m++) {
            switch (m) {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                    day += 31;
                    break;
                case 2:
                    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                        day += 29;
                    } else {
                        day += 28;
                    }
                    break;
                default:
                    day += 30;
                    break;
            }
        }
        System.out.println("距离1900-01-01总共:" + day + "天");

    }

    private static void exercise4() {
        int totalRow = 9;
        int little = totalRow / 2;//4
        int many = little + 1;//5


        for (int i = 1; i <= many; i++) {
            for (int j = 1; j <= many - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for (int i = 1; i <= little; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= totalRow - 2 * i; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

    private static void exercise3() {

        //    *
        //   ***
        //  *****
        // *******
        //  *****
        //   ***
        //    *

        int totalRow = 11;
        int little = totalRow / 2;//4
        int many = little + 1;//5

        int j = 1;
        for (int i = many - 1; i >= 0; i--) {
            for (; j <= totalRow; ) {// 5  7  9
                int blank = 0;
                while (blank < i) {
                    System.out.print(" ");
                    blank++;
                }
                int star = 0;
                while (star < j) {
                    System.out.print("*");
                    star++;
                }
                j += 2;
                break;
            }
            System.out.println();
        }

        int j1 = totalRow - 2;
        for (int i = little - 1; i >= 0; i--) {
            for (; j1 > 0; ) {
                int blank = 0;
                while (blank < little - i) {
                    System.out.print(" ");
                    blank++;
                }
                int star = 0;
                while (star < j1) {
                    System.out.print("*");
                    star++;
                }
                j1 -= 2;
                break;
            }
            System.out.println();
        }


    }

    private static void exercise2() {
        
        //计算个税(图片见最后)
        double salary = 15000;
        double supDeE = salary - 3500;
        double taxRate = 0, num = 0;

        if (supDeE <= 1500 && supDeE > 0) {
            taxRate = 0.03;
        } else if (supDeE <= 4500 && supDeE >= 1501) {
            taxRate = 0.1;
            num = 105;
        } else if (supDeE <= 9000 && supDeE >= 4501) {
            taxRate = 0.2;
            num = 555;
        } else if (supDeE <= 35000) {
            taxRate = 0.25;
            num = 1005;
        } else if (supDeE <= 55000 && supDeE >= 35001) {
            taxRate = 0.3;
            num = 2755;
        } else if (supDeE <= 80000 && supDeE >= 55001) {
            taxRate = 0.35;
            num = 5505;
        } else if (supDeE > 80000) {
            taxRate = 0.45;
            num = 13505;
        }

        double tax = 0;
        if (supDeE > 0) {
            tax = (salary - 262 - 3500) * taxRate - num;
        }
        salary = salary - 262 - tax;
        System.out.println("需要缴纳个人所得税:" + tax);
        System.out.println("实际收入:" + salary);
    }

    private static void exercise1() {

//        商场实行新的抽奖规则：会员号的百位数字等于产生的随机数字即为幸运会员。实现如下功能：
//        1、从键盘接收4位数会员号
//        2、生成随机数
//        提示：int random = (int) (Math.random() * 10);
//        3、算出会员号中在百位的数字号码
//        提示：int baiwei = custNo / 100 % 10;

        Scanner input = new Scanner(System.in);
        System.out.println("从键盘接收4位数会员号:");
        int memberNo = input.nextInt();
        if (memberNo < 1000 || memberNo >= 10000) {
            System.out.println("录入的会员号不合法");
            return;
        }
        int random = (int) (Math.random() * 10);
        int baiWei = memberNo / 100 % 10;
        System.out.println("今日的幸运数字:" + random);
        if (random != baiWei) {
            System.out.println(memberNo + "不是今日幸运会员");
            return;
        }
        System.out.println(memberNo + "是今日幸运会员");
        input.close();
    }

}

sunshine195
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础_第二阶段-day18每日作业卷答案1
08-08
每日作业卷Java基础第二阶段第18天BeanUtils工具类、综合案例传智播客.黑马程序员关卡1训练案例1训练描述：【讲义第一章：BeanUtils工具类】请
Java基础_第二阶段-day18每日作业卷1
08-08
每日作业卷Java基础第二阶段第18天BeanUtils工具类、综合案例传智播客.黑马程序员关卡1训练案例1训练描述：【讲义第一章：BeanUtils工具类】请
Day04-Java基础第一阶段_方法
m0_46254546的博客
09-11 84
Day04-Java基础第一阶段_方法@[toc](Day04-Java基础第一阶段_方法)何谓方法方法的定义方法调用方法重载命令行传参可变参数递归测试 何谓方法 System.out.println(),是什么 Java方法是语句的集合，它们在一起执行一个功能 方法是解决一类问题的步骤的有序组合 方法包含于类或对象中 方法在程序中被创建，在其他地方被引用 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利
java第一阶段知识_Java第一阶段总结
weixin_33296185的博客
02-13 237
前言此篇博客主要针对PTA三次作业做一个总结，也是对自己学习了一个多月的Java做一个小结，学习了Java语言的一些基本用法，初步认识了面向过程和面向对象，了解是一个怎样的过渡过程以及两者的不同之处。一、作业过程总结1.总结三次作业之间的知识迭代关系:第一次作业:Main类中只用了一个主方法去写题目所需要的功能，初步使用输入方法和循环方法；第二次作业:在Main类中除了主方法还写了很多种其他方法，...
Java阶段四Day04
今天你学Java了吗
06-14 460
今天是学习Java阶段四的第四天，讲解了关于DAO、Service层的架构进行项目规划，关于@SLF4j日志框架和@Sql注解并运用到了茶之源项目的测试中，又讲解了关于配置全局异常、自定义异常等操作，并使用枚举自定义异常响应码
Java阶段三Day04
今天你学Java了吗
05-24 601
今天是学习Java阶段三的第四天，开始学习Vue的一些知识，了解了Vue框架，学习了常用的指令并进行了相关练习
java第一阶段_学习java第一阶段：java 时间
weixin_35750747的博客
02-25 76
/***获取某月最初一天**/public static Date getMonthAnyStartDay(Date date,int start) throws ParseException{SimpleDateFormat format = new SimpleDateFormat("yyyy/MM/dd");Calendar caleFirst = Calendar.getInstance(...
java第一阶段（day17）终篇
sunshine195的博客
03-20 709
...
Java第一阶段（day07）迷你共享单车
sunshine195的博客
02-23 1592
...
JAVA学习数据库阶段day05
weixin_62527159的博客
01-05 488
JAVA学习数据库阶段day05
java第一阶段（day11）Utill包常用类
sunshine195的博客
02-28 1690
...
Java基础_第二阶段-day16每日作业卷1
08-08
每日作业卷Java基础第二阶段第16天基础加强_注解_类加载器_动态代理传智播客.黑马程序员关卡1训练案例1训练描述：【讲义1.1：JUnit介绍】请使用一句话
Java基础_第二阶段_day17每日作业卷1
08-08
每日作业卷Java基础第二阶段第17天基础加强_XML传智播客.黑马程序员关卡1训练案例1训练描述：【讲义1.1.2：XML的作用】请写出XML的两个重要作用：
Java基础_第二阶段_day17每日作业卷答案1
08-08
Java基础_第二阶段_day17每日作业卷答案1
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 893
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1206
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 493
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java根据2023-04月份 获取第一天和最后一天
05-26
可以使用Java 8中的`LocalDate`类来实现： ```java import java.time.LocalDate; import java.time.YearMonth;...然后使用`atDay(1)`方法获取当月的第一天，使用`atEndOfMonth()`方法获取当月的最后一天。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值