Java小练习(新手十天必须会的小练习)

最新推荐文章于 2024-07-21 12:37:55 发布
最新推荐文章于 2024-07-21 12:37:55 发布
阅读量675 收藏 5
点赞数
分类专栏： Java 文章标签： java 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54412689/article/details/127940184
版权

Java练习小项目

如果你学java一周了，那下面的小练习，必须要能掌握

1，卖飞机票

 需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
 按照如下规则计算机票价格：
 旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。

package xyz.lybigdata.practice;

import java.util.Scanner;

public class Demo01 {
    /*
     卖飞机票
     需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
     按照如下规则计算机票价格：
     旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。
     */
    public static void main(String[] args) {
           /*
           思路：
            1，键盘录入机票原价，月份，是否头等舱
            2，判断是否淡季
            3，计算价格
            */
        System.out.print("请输入机票原价:");
        int price = new Scanner(System.in).nextInt();
        System.out.print("请输入月份:");
        int month = new Scanner(System.in).nextInt();
        System.out.print("请输入舱位 1:头等舱 2:经济舱 :");
        int grade = new Scanner(System.in).nextInt();
        // 旺季
        if (month >= 5 && month <= 10) {
            price = getPrice(grade, price, 0.9, 0.85);
        } else if ((month >= 1 && month <= 4) || (month > 10 && month <= 12)) {
            price = getPrice(grade, price, 0.7, 0.65);
        } else {
            System.out.println("没有这个月份");
        }
            System.out.println("此时机票价格是：" + price);
    }
// 重复代码用方法
    public static int getPrice(int grade, int price, double v, double v1) {
        if (grade == 1) {
            price = (int) (price * v);
        } else if (grade == 2) {
            price = (int) (price * v1);
        } else {
            System.out.println("没有这个选择");
        }
        return price;
    }
}

2,找质数

判断 101 ~ 200 之间有多少个素数，并打印所有素数

package xyz.lybigdata.practice;

public class Demo02 {
    /*
    
    找质数
    判断 101 ~ 200 之间有多少个素数，并打印所有素数
     */
    public static void main(String[] args) {
        int count = 0;
        for (int i = 101; i <= 200; i++) {
            boolean flag = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    flag = false; // 不是质数
                    break;
                }
            }
            if (flag) {
                System.out.println(i + "是质数");
                count++;
            }
        }
        System.out.println("一共" + count + "个质数");
    }
}

3,定义方法实现随机产生一个5位的验证码

定义方法实现随机产生一个5位的验证码
验证码格式：
长度为5
前四位是大写字母或者小写字母
最后一位是数字

package xyz.lybigdata.practice;

import java.util.Random;

public class Demo03 {
    /*
            需求：
            定义方法实现随机产生一个5位的验证码
            验证码格式：
            长度为5
            前四位是大写字母或者小写字母
            最后一位是数字
     */
    public static void main(String[] args) {
        /*
        思路：
        1.大写字母和小写字母都放到数组当中
        2.随机抽取4次
        3.随机抽取一个数字0~9
         */

        // 1.大写字母和小写字母都放到数组当中
        // 在一堆没有什么规律的数据中随机抽取，可以先把这些数据放到数组当中，再随机抽取一个索引
        char[] chs = new char[26+26];
        for (int i = 0; i < chs.length; i++) {
            if (i < 26){
                // ASCII 码表
                // 小写 97
                chs[i] = (char) (97 + i);
            }else {
                // 大写 65
                chs[i] = (char) (65 + i - 26);
            }
        }
        // 2.随机抽取4次
        // 定义一个字符串，来记录最终的结果
        String result = "";
        // 随机抽取数组中的索引
        for (int i = 0; i < 4; i++) {
            int randomIndex = new Random().nextInt(chs.length);
            result = result + chs[randomIndex];
        }
        // 3.随机抽取一个数字0~9
        int num = new Random().nextInt(9);
        // 生成结果
        result = result + num;
        // 打印结果
        System.out.println(result);
    }
}

4,把一个数组中的元素复制到另一个新数组中去。

package xyz.lybigdata.practice;

import java.util.Arrays;

public class Demo04 {
     /*
        需求：
        把一个数组中的元素复制到另一个新数组中去。
     */
     public static void main(String[] args) {
         /*
         思路：
         1.定义一个数组并存储一些元素
         2.定义一个新数组的长度跟老数组一致
         3.遍历老数组，得到老数组中的每一个元素，依次存入到新数组当中
          */
         // 1.定义一个数组并存储一些元素
         int[] Arr = {1,2,3,4,5};
         //2.定义一个新数组的长度跟老数组一致
         int[] newArr = new int[Arr.length];
         // 3.遍历老数组，得到老数组中的每一个元素，依次存入到新数组当中
         for (int i = 0; i < Arr.length; i++) {
             newArr[i] = Arr[i];
         }
         // 输出结果
         System.out.println(Arrays.toString(newArr));
     }
}

5,在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。

在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。
选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。

package xyz.lybigdata.practice;

import java.util.Scanner;

public class Demo05 {
    /*
    需求：
    在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。
    选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。
     */
    public static void main(String[] args) {
        /*
        思路：
        1.定义一个数组，用来存储6名评委的打分（0~100）
        2.求出数组中的最大值
        3.求出数组中的最小值
        4.求出数组中6个分数的总和
        5.（总和 - 最大值 - 最小值 ）/4
         */

        // 1.定义一个数组，用来存储6名评委的打分（0~100）
        int[] score = new Demo05().getScore();
        // 2.求出数组中的最大值
        int max = new Demo05().getmax(score);
        // 3.求出数组中的最小值
        int min = new Demo05().getmin(score);
        // 4.求出数组中6个分数的总和
        int sum = new Demo05().getSum(score);
        // 5.（总和 - 最大值 - 最小值 ）/4
        int result = (sum - max -min) / (score.length - 2);
        // 打印结果
        System.out.println("选手的最高分是:" + max);
        System.out.println("选手的最低分是:" + min);
        System.out.println("选手的最后得分是:" + result);


    }
    /**
     * 1.定义一个数组，用来存储6名评委的打分（0~100）
     * @return arr
     */
    int[] getScore(){
        int[] arr = new int[6];
        for (int i = 0; i < arr.length;) {
            System.out.print("请打分（0~100）:");
            int num = new Scanner(System.in).nextInt();
            if (num < 0 || num >100){
                System.out.println("分数不合规，重新输入");
            }else{
                arr[i] = num;
                i++;
            }
        }
        return arr;
    }

    /**
     * 2.求出数组中的最大值
     * @param score
     * @return max
     */
    int getmax(int[] score){
        int max = score[0];
        for (int i = 1; i < score.length; i++) {
            if (max < score[i]){
                max = score[i];
            }
        }
        return max;
    }

    /**
     * 3.求出数组中的最小值
     * @param score
     * @return min
     */
    int getmin(int[] score){
        int min = score[0];
        for (int i = 1; i < score.length; i++) {
            if (min > score[i]){
                min = score[i];
            }
        }
        return min;
    }

    /**
     * 4.求出数组中6个分数的总和
     * @param score
     * @return sum
     */
    int getSum(int[] score){
        int sum = 0;
        for (int i = 0; i < score.length; i++) {
            sum = score[i] + sum;
        }
        return sum;
    }

}

6,密码加密

某系统的数字密码（大于0）。
比如1983，采用加密方式进行传输，
规则如下：
    每位数加上5
    再对10求余，
    最后将所有数字反转，
    得到一串新数。

package xyz.lybigdata.practice;

import java.util.Scanner;

public class Demo06 {
    /*
    某系统的数字密码（大于0）。
    比如1983，采用加密方式进行传输，
    规则如下：
        每位数加上5
        再对10求余，
        最后将所有数字反转，
        得到一串新数。
    */
    public static void main(String[] args) {
            /*
            思路：
            1，把整数放到数组里面
            2，加密：
                每位数加上5
                再对10求余
                数组反转
            3，把数组里面的每一个数字进行拼接，变成加密之后的结果
             */

        // 1，把整数放到数组里面
        System.out.print("请输入需要加密的密码：");
        int pwd = new Scanner(System.in).nextInt();
        // 定义一个临时变量存储密码
        int temp = pwd;
        // 定义一个计数器
        int count = 0;
        while (pwd != 0) {
            pwd = pwd / 10; // 每次循环去掉右边一个数字
            count++; // 每去掉一位就自增一次
        }
        // 动态初始化数组
        int[] arr = new int[count];
        // 创建一个数组的索引
        int index = 0;
//             int index = count - 1;       这样的话就需要加一步数组反转
        // 把整数的每一位放到数组
        while (temp != 0) {
            int ge = temp % 10; // 获取temp里面的每一位的值
            temp = temp / 10; // 去掉右边的值
            // 把当前获取的个位添加到数组
            arr[index] = ge;
            index++;
//                index__;  对应第43行
        }
        //       System.out.println(Arrays.toString(arr));
        // 2，加密：
        //          每位数加上5
        //          再对10求余
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 5;
            arr[i] = arr[i] % 10;
        }
        //System.out.println(Arrays.toString(arr));
        //          数组反转（上面已经反转过了，如果使用第43行，那么需要这步数组反转）
//            for (int i = 0,j = arr.length - 1; i < j; i++,j--) {
//                int tep = arr[i];
//                arr[i] = arr[j];
//                arr[j] = tep;
//            }
        // 3，把数组里面的每一个数字进行拼接，变成加密之后的结果
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            num = num * 10 + arr[i];
        }
        System.out.println("加密之后的结果:" + num);
    }
}

7,密码解密

某系统的数字密码（大于0）。比如1983，采用加密方式进行传输，
规则如下：
    每位数加上5
    再对10求余，
    最后将所有数字反转，
    得到一串新数。
    按照以上规则进行解密：
    比如1983加密之后变成8346，解密之后变成1983

package xyz.lybigdata.practice;

import java.util.Scanner;

public class Demo07 {
    /*
    某系统的数字密码（大于0）。比如1983，采用加密方式进行传输，
    规则如下：
        每位数加上5
        再对10求余，
        最后将所有数字反转，
        得到一串新数。
        按照以上规则进行解密：
        比如1983加密之后变成8346，解密之后变成1983
    */
    public static void main(String[] args) {
            /*
            思路:
            1，将整数放到数组
            2，解密：
                每位数加上5
                再对10求余，
                最后将所有数字反转
            3，打印结果
             */

        // 1，将整数放到数组
        System.out.print("请输入需要解密的密码：");
        int pwd = new Scanner(System.in).nextInt();
        int temp = pwd;
        int count = 0;
        while (pwd != 0) {
            pwd = pwd / 10;
            count++;
        }
        int[] arr = new int[count];
        int index = 0;
        // 变为数组并且反转
        while (temp != 0) {
            int ge = temp % 10;
            temp = temp / 10;
            arr[index] = ge;
            index++;
        }
        // 2，解密：
        //         每位数加上5
        //         再对10求余，
        //         最后将所有数字反转（上一步反转了）
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 5;
            arr[i] = arr[i] % 10;
        }
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            num = num * 10 + arr[i];
        }
        System.out.println("解密之后的结果:" + num);
    }
}

8,抽奖

需求：
一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
请设计抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
打印效果如下：（随机顺序）
    888元的奖金被抽出
    588元的奖金被抽出
    10000元的奖金被抽出
    1000元的奖金被抽出
    2元的奖金被抽出

package xyz.lybigdata.practice;

import java.util.Random;

public class Demo08 {
    /*
    需求：
    一个大V直播抽奖，奖品是现金红包，分别有{2, 588 , 888, 1000, 10000}五个奖金。
    请设计抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
    打印效果如下：（随机顺序）
        888元的奖金被抽出
        588元的奖金被抽出
        10000元的奖金被抽出
        1000元的奖金被抽出
        2元的奖金被抽出
    */
    public static void main(String[] args) {
            /*
            思路：
            1，新建一个数组存放这些奖金
            2，定义新数组用于存储抽奖的结果
            3，抽奖
                判断prize在数组当中是否存在
                存在：true
                不存在：false
            4，遍历新数组
             */

        // 1，新建一个数组存放这些奖金
        int[] arr = {2, 588, 888, 1000, 10000};
        // 2，定义新数组用于存储抽奖的结果
        int[] newArr = new int[arr.length];
        // 3，抽奖
        for (int i = 0; i < 5; ) {
            int randomIndex = new Random().nextInt(arr.length);
            int prize = arr[randomIndex];
            if (!contains(newArr, prize)) {
                newArr[i] = prize;
                i++;
            }
        }
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i] + "元的奖金被抽出");
        }

    }

    /**
     * 判断抽取的奖项在数组当中是否存在
     *
     * @param arr
     * @param prize
     * @return boolean
     */
    static boolean contains(int[] arr, int prize) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == prize) {
                return true;
            }
        }
        return false;
    }
}

9,优化抽奖

package xyz.lybigdata.practice;

import java.util.Random;

public class Demo08_v2 {
    /*
    优化抽奖
     */
    public static void main(String[] args) {
        // 1，打乱奖池的顺序
        int[] arr = {2, 588, 888, 1000, 10000};
        for (int i = 0; i < arr.length; i++) {
            int randomIndex = new Random().nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        // 遍历抽取
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + "元的奖金被抽出");
        }
    }
}

10, 彩票中奖系统：

投注号码由6个红色球号码和1个蓝色球号码组成。
红色球号码从1-33中选择;蓝色球号码从1-16中选择。
双色球中奖条件和奖金表

package xyz.lybigdata.practice;

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

public class Demo09 {
    /*
    彩票中奖系统：
    投注号码由6个红色球号码和1个蓝色球号码组成。
    红色球号码从1-33中选择;蓝色球号码从1-16中选择。
    双色球中奖条件和奖金表
    等级        说明             奖金
    一等奖      红6蓝1           1000万
    二等奖      红6蓝0           500万
    三等奖      红5蓝1           3000元
    四等奖      红5蓝0           200元
    四等奖      红4蓝1           200元
    四等奖      红4蓝0           200元
    五等奖      红3蓝1           10元
    五等奖      红2蓝1           10元
    六等奖      红1蓝1           5元
    六等奖      红0蓝1           5元
     */
    public static void main(String[] args) {
        // 1,生成中奖号码
        int[] arr = createNumber();
        System.out.println(Arrays.toString(arr));
        // 2,让用户输入号码
        int[] user = userInputNum();
        // 3,验证中奖情况
        int redCount = 0;
        int blueCount = 0;
        // 判断红球
        for (int i = 0; i < user.length - 1; i++) {
            int red = user[i];
            for (int j = 0; j < arr.length - 1; j++) {
                if (red == arr[j]) {
                    redCount++;
                    break;
                }
            }
        }
        // 判断蓝球
        int blue = user[user.length - 1];
        if (blue == arr[arr.length - 1]) {
            blueCount++;
        }
        if (redCount == 6 && blueCount == 1) {
            System.out.println("恭喜中奖一千万!");
        } else if (redCount == 6) {
            System.out.println("恭喜中奖五百万!");
        } else if (redCount == 5 && blueCount == 1) {
            System.out.println("恭喜中奖 三千元!");
        } else if ((redCount == 5) || (redCount == 4 && blueCount == 1) || (redCount == 4 && blueCount == 0)) {
            System.out.println("恭喜中奖 二百元!");
        } else if ((redCount == 3 && blueCount == 1) || (redCount == 2 && blueCount == 1)) {
            System.out.println("恭喜中奖 十元!");
        } else if ((redCount == 1 && blueCount == 1) || (redCount == 0 && blueCount == 1)) {
            System.out.println("恭喜中奖 五元!");
        } else {
            System.out.println("很遗憾，没有中奖，感谢对公益活动的捐款!");
        }
    }

    /**
     * 用来生成中奖号码
     *
     * @return arr
     */
    static int[] createNumber() {
        // 6红1蓝 数组长度 7
        int[] arr = new int[7];
        Random r = new Random();
        // 随机6个生成红球
        for (int i = 0; i < 6; ) {
            int redNum = r.nextInt(33) + 1;
            boolean flay = contains(arr, redNum);
            if (!flay) {
                arr[i] = redNum;
                i++;
            }
        }
        // 生成一个蓝球
        int blueNum = r.nextInt(5) + 1;
        arr[arr.length - 1] = blueNum;

        return arr;
    }

    /**
     * 用来判断数组是否包含某个数
     *
     * @param arr
     * @param num
     * @return boolean
     */
    static boolean contains(int[] arr, int num) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                return true;
            }
        }
        return false;
    }

    /**
     * 用来让用户输入号码
     *
     * @return arr
     */
    static int[] userInputNum() {
        int[] arr = new int[6 + 1];
        Scanner sc = new Scanner(System.in);
        // 红球
        for (int i = 0; i < 6; ) {
            System.out.print("请输入第" + (i + 1) + "个红球:");
            int redNum = sc.nextInt();
            if (redNum >= 1 && redNum <= 33) {
                boolean flag = contains(arr, redNum);
                if (!flag) {
                    arr[i] = redNum;
                    i++;
                } else {
                    System.out.println("输入的数字重复了");
                }
            } else {
                System.out.println("输入的数字不在范围内");
            }
        }
        // 蓝球
        while (true) {
            System.out.print("请输入蓝球号码:");
            int blueNum = sc.nextInt();
            if (blueNum >= 1 && blueNum <= 16) {
                arr[arr.length - 1] = blueNum;
                break;
            } else {
                System.out.println("输入的数字不在范围内");
            }
        }
        return arr;
    }
}
-starshine丨
关注
专栏目录
Java小白入门200例60之SimpleDateFormat时间格式化详解
编程界明世隐的博客
09-23 301
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 引言 很多Java初学者问我，新手明明很用心、很努力学习的Java知识，转头又忘记了，很让人犯愁，小白如何能够快速成长、成为大牛呢？ 其实要成为大神的技巧只有一个：“多学多练”，于是明哥就整理了比较典型的练习实例，通过练习能够快速提升编码技巧和熟练度，让你在成为大
一些简单的JAVA小练习
03-19
一些简单的JAVA小练习，适合新手联系用。。。。。。。。。。。。。。。。。。。。。
java练习_Java练习
weixin_32340083的博客
02-19 255
package exec;/*2.根据圆柱体的半径和高，使用下面的公式，计算圆柱的体积面积=半径*半径*π体积=面积*高 */public class work01 {public static void main(String[] args) {// TODO Auto-generated method stub//定义圆柱的高和半径，面积，体积double r,h,s,v;r=3.4;h=8....
Java基础编程500题——阶段练习1
最新发布
安晴晚风的博客
07-21 1081
Java基础编程500题——阶段练习1
Java 小练习（简单）—合集
zhy0821的博客
01-29 2310
字符串练习：金额转换 针对发票的金额转换，转换的金额为7位，不足7位的金额前面需补0
Java小练习（实战）
MTbaby的博客
01-06 572
任务 一、 存储35周学习内容（已提供部分完成的功能） 提示： 1、 创建String数组，并为每一个元素赋值，内容为【第X周】XXX 2、 利用int型的变量接收输入的数字 二、 计算今天处于第几周 提示： 1、根据输入的数字，计算今天是第几个月 （例如：4对应第一月第四周，5代表第二月第一周） 2、换算一下，输入的周是这个月的第几周 三、 遍历并输出本月的学习内容，并标记本周内容 提示： 1、利用for循环，找到数组中对应这个月的内容输出 2、根据当前月第几周，在输出此行时，前面添加“√” packag
java小练习
qq_47044642的博客
04-06 353
为某音像店开发一个迷你DVD管理器，实现DVD碟片的管理， 包括如下功能：新增DVD、查看DVD、删除DVD、借出DVD、归还DVD。（后台使用ArrayList来存放DVD对象。） 设计: 1） DVD类(属性:id ,name ,lendCount ,lendDate ,status) (默认每张DVD都是唯一的) lendCount字段每借一次加1 2） DVDDB类(提供一个动态数组来保存多张DVD) 3） DVDManager类(提供操纵功能)， 添加DVD、查看DVD、删除DVD、借出DVD、归
Java入门练习50题
qq_40245464的博客
11-02 932
参考文章:https://wenku.baidu.com/view/7ba13d7fe87101f69f319558.html?qq-pf-to=pcqq.group 部分内容做了改动,题目还是很好的.适合练手. /* 1.古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子 小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问 到了第n个月兔子为多少对?(键盘录入n) 提...
java 万年历小程序 代码
12-28
在编程领域，尤其是Java开发中，编写一个万年历小程序是一项常见的练习，旨在帮助开发者熟悉日期处理、循环逻辑以及界面展示等基础知识。这个"java 万年历小程序"项目是作者在大学二年级时完成的，它可能包含了从...
java练习经典题型 和答案
08-08
总的来说，"Java练习经典题型和答案"是一份非常实用的学习资源，它涵盖了Java编程中的多个重要方面，无论是对新手还是老手都有很高的参考价值。通过深入研究这些题目和答案，我们可以更好地掌握Java编程的核心技术和...
JAVA 基础编程练习500题
码农研习社
05-12 1634
【程序 1】 题目： 古典问题： 有一对兔子， 从出生后第 3 个月 起每个月 都生一对兔子， 小兔子长到第三个月 后每个月又生一对兔子， 假如兔子都不死， 问每个月 的兔子对数为多少？ 程序分析： 兔子的规律为数列1,1,2,3,5,8, 13, 21....做这种题目， 最好的做法就是找出规律， 跟高中的数列一样 本题有： a[n]=a[n-1]+a[n-1],而第一第二项都知道了， 后面的值也可以求得 public class Programme1 { public st...
简单java程序的小练习
02-01
一些入门的有趣java程序，满天五彩星，打字母游戏，控制小球移动以及文件复制加密等等。
java小练习，Java练习小程序，Java必用
03-29
50java小练习 java小练习，Java练习小程序，Java必用
Java 小练习题
qq_40307529的博客
05-05 604
题目要求：一个数如果恰好等于它的因子之和，这个数就称为完数。编写应用程序求1000之内的所有完数。这个题目可以用一个循环就可以解决了代码如下：import java.math.*; public class WanShu { /** * @param args */ public static void main(String[] a...
java练习
鲁家志的专栏
05-09 1007
class A { float a; static float b; void setA(float a) { this.a=a; } void setB(float b) { this.b=b; } float getA() { return a; } float getB() { return b; } vo
java 练习
虾米大王的学习历程
11-17 310
package Test04; import java.awt.Container; import java.awt.GridBagConstraints; import java.awt.GridBagLayout; import java.awt.Insets; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.WindowConstants; public class GridBag2 exten.
Java基础小练习
weixin_48793295的博客
11-08 654
1.输入你的姓名，性别，及年龄，放入三个不同类型的变量中 2.输入一个整数，输出这个整数与1到5相乘的结果 3.输入一个四位数的整数，要求编程将这个四位数中的个位，十位，百位，千位分别输出 4.输入一个整数，代表有n个小时，计算n个小时等于多少天零多少个小时。比如输入：25，那么输出“1天零1个小时” 5.输入电视机的价格（double型）及数量(int型)，计算这些电视机总价值是多少 6.收银系统
JAVA打字练习小程序源码解析
"打字练习小程序是一个为了帮助初学者巩固编程基础、提升编程技能而设计的小程序。在老师的指导下，学生们通过实现这个程序来实践编码，主要使用Java语言编写。程序包含时间管理、键盘事件监听以及分数计算等功能，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值