JAVA练习合集_java训练-CSDN博客

本文链接：https://blog.csdn.net/weixin_42482333/article/details/128837776

2. 春节假期作业

1.1 找最大值

练习题: 接收用户输入的3个整数,并将它们的最大值作为结果输出

package spring_festival_homework;

import java.util.Scanner;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-03-19:46
 * @Description:
 *  接收用户输入的3个整数,并将它们的最大值作为结果输出
 */
public class Find_Max {
    public static void main(String[] args) {
        //1.定义工具类
        Scanner scan = new Scanner(System.in);
        //2.假设第一个输入的数是最大数
        System.out.print("请输入第一个整数:");
        int max = scan.nextInt();
        System.out.print("请输入第二个整数:");
        int num = scan.nextInt();
        System.out.print("请输入第三个整数:");
        int num2 = scan.nextInt();
        //3.利用三目运算符比较三个数的大小
        max = max>num? max>num2?max:num2 : num>num2?num:num2;
        System.out.println("3个整数的最大值为:"+max);
    }
}

1.2 BMI等级判断

接收用户输入的身高和体重,将判断结果输出
过轻：低于18.5
正常：18.5 ~ 22.9
偏胖：23 ~ 24.9
肥胖：25 ~ 29.9
重度肥胖：高于30
极度肥胖：高于40

BMI 指数测试 BMI = 体重 (kg) / 身高² (m)

package spring_festival_homework;

import java.util.Scanner;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-03-19:59
 * @Description:
 * 接收用户输入的身高和体重, 将判断结果输出
 * 过轻：低于18.5
 * 正常：18.5 ~ 22.9
 * 偏胖：23 ~ 24.9
 * 肥胖：25 ~ 29.9
 * 重度肥胖：高于30
 * 极度肥胖：高于40
 * BMI 指数测试 BMI = 体重 (kg) / 身高² (m)
 */
public class If_BMI {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //1.接收用户输入
        System.out.print("请输入身高(m):");
        double height = scan.nextDouble();
        System.out.print("请输入体重(kg):");
        double weight = scan.nextDouble();
        //2.计算BMI
        double BMI = weight / Math.pow(height,2);
        //3.定义级别
        String level = "";
        //3.分类讨论
        if (BMI < 18.5)
            level = "过轻";
        else if (BMI <= 22.9)
            level = "正常";
        else if (BMI >= 23 && BMI <= 24.9)
            level = "偏胖";
        else if (BMI >= 25 && BMI <= 29.9)
            level = "肥胖";
        else if (BMI > 30)
            level = "重度肥胖";
        else if (BMI > 40)
            level = "极度肥胖";
        System.out.println("您的身高为:"+height+",体重为:"+weight+",BMI等级为:"+level);
    }
}

1.3 公约数和公倍数

接收用户输入两个整数，求两个数的最大公约数和最小公倍数

package spring_festival_homework;

import java.util.Scanner;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-03-20:33
 * @Description:
 * 求最大公约数、最小公倍数
 * 提示：
 * 最大公约数：辗转相除法
 * 最小公倍数：两数乘积/最大公约数
 */
public class Common_Divisor_And_Multiple {
    public static int max(int num1,int num2){
        //1.假设最大公约数为1
        int res = 1;
        while (res != 0) { //2. 余数不为0，说明还未找到最大公约数，辗转相除
            res = num1 % num2;
            num1 = num2;
            num2 = res;
        }
        return num1;
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入数1:");
        int num1 = scan.nextInt();
        System.out.print("请输入数2:");
        int num2 = scan.nextInt();

        int max = max(num1,num2);
        System.out.println("最大公约数:"+max);
        //2.最小公倍数：两数乘积/最大公约数
        System.out.println("最小公倍数:"+num1*num2/max);
    }
}

1.4 税后工资问题

2019年1月1日起，国家推出新的个人所得税政策，起征点上调值5000元。也就是说税前工资扣除三险一金（三险一金数额假设是税前工资的10%）后如果不足5000元，则不交税。如果大于5000元，那么大于5000元的部分按梯度交税，具体梯度比例如下：
0 ~ 3000元的部分，交税3%
3000 ~ 12000元的部分，交税10%
12000 ~ 25000的部分，交税20%
25000 ~ 35000的部分，交税25%
35000 ~ 55000的部分，交税30%
55000 ~ 80000的部分，交税35%
超过80000的部分，交税45%
比如：小蓝入职一家企业后，税前工资是18000，则他每月该交个税的部分是18000-1800-5000=11200元，个税缴纳数额是3000×3%+8200×10%=910元。税后工资15290元。
请完成一个个税计算程序，在用户输入税前工资后，计算出他对应的纳税数额，以及税后工资为多少？

在这里插入图片描述

package spring_festival_homework;

import java.util.Scanner;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-8:49
 * @Description:
 * 2019年1月1日起，国家推出新的个人所得税政策，起征点上调值5000元。也就是说税前工资扣除三险一金（三险一金数额假设是税前工资的10%）后如果不足5000元，则不交税。如果大于5000元，那么大于5000元的部分按梯度交税，具体梯度比例如下：
 *  0 ~ 3000元的部分，交税3%
 *  3000 ~ 12000元的部分，交税10%
 *  12000 ~ 25000的部分 ， 交税20%
 *  25000 ~ 35000的部分，交税25%
 *  35000 ~ 55000的部分，交税30%
 *  55000 ~ 80000的部分，交税35%
 *  超过80000的部分，交税45%
 * 比如：小蓝入职一家企业后，税前工资是18000，则他每月该交个税的部分是18000-1800-5000=11200元，个税缴纳数额是3000×3%+8200×10%=910元。税后工资15290元。
 * 请完成一个个税计算程序，在用户输入税前工资后，计算出他对应的纳税数额，以及税后工资为多少？
 */
public class Tax {
    static double give_tax = 0;
    //递归 利用分段函数思想 对需要交税的部分进行分级
    //该方法用于获取需要支付的税费
    public static double giveTax(double money){
        //可以想象成数轴一段一段求
        if (money <= 3000)                 // 0 ~ 3000元的部分，交税3% 结束点
            return money * 0.03;
        else if (money <= 12000)          // 3000 ~ 12000元的部分，交税10%
            give_tax = give_tax +
                    ((money-3000) * 0.1) +
                    giveTax(money-(money - 3000));
        else if (money <= 25000)        //  12000 ~ 25000的部分 ， 交税20%
            give_tax = give_tax +
                    ((money - 12000) * 0.2) +
                    giveTax(money-(money - 12000));
        else if ( money <=35000 )       //  25000 ~ 35000的部分，交税25%
            give_tax = give_tax +
                    ((money - 25000)*0.25) +
                    giveTax(money-(money-25000));
        else if ( money <= 55000)      // 35000 ~ 55000的部分，交税30%
            give_tax = give_tax +
                    ((money - 35000)*0.3) +
                    giveTax(money-(money-35000));
        else if (money <= 80000)     //  55000 ~ 80000的部分，交税35%
            give_tax = give_tax +
                    ((money-55000)*0.35) +
                    giveTax(money-(money-55000));
        else  //  超过80000的部分，交税45%
            give_tax = give_tax +
                    ((money - 80000) * 0.45) +
                    giveTax(money - (money - 80000));

        return give_tax;
    }
    public static void main(String[] args) {
        System.out.print("请输入税前工资:");
        double salary = new Scanner(System.in).nextDouble();
        //2.五险一金后的金额
        double settle_accounts=salary - salary * 0.1;
        double tax=0;

        //3.需要交税的部分
        if (settle_accounts < 5000)
            System.out.println("不需要交税");
        else {
            //System.out.println("每月该交个税的部分:"+(settle_accounts - 5000));
            tax = giveTax(settle_accounts -5000);
            //4.需要交税
            System.out.println("税前工资是:"+salary+",需纳税:"+tax);
        }

        System.out.println("税后工资:"+(settle_accounts - tax));

    }
}

1.5 死循环

分别通过for循环/While循环/do-While循环写一个死循环

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-14:08
 * @Description:
 * 分别通过for循环/While循环/do-While循环写一个死循环
 */
public class LoopDemo {
    public static void main(String[] args) {
        //for循环死循环
        for (int i = 0;i>=0;i++)
            System.out.println("这是for的死循环");

        //while循环死循环
        /*while (true){
            System.out.println("这是while的死循环");
        }*/

        //do While循环死循环
        do{
            System.out.println("这是do...while的死循环");
        }while (true);

    }
}

1.6 质因数

求质数:接收用户输入的数字,判断是否为质数
质数的概念:一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数,也称为素数
规定:1既不是质数,也不是合数

package spring_festival_homework;

import java.util.Scanner;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-14:21
 * @Description:
 * 求质数:接收用户输入的数字,判断是否为质数
 * 质数的概念:一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数,也称为素数
 * 规定:1既不是质数,也不是合数
 */
public class Prime_Number {
    public static void main(String[] args) {
        System.out.print("请输入一个整数:");
        int num = new Scanner(System.in).nextInt();
        if (num == 1){
            System.out.println("1不是质数");
            return;
        }
        //定义一个标记，0表示是质数，1表示不是质数
        int flag = 0;
        //与判断数一半内的每个数相除，如果出现能被整除的则不是质数
        for (int j = 2;j < num/2;j++)
            if (num % j == 0){
                flag = 1;
                break;
            }
        if (flag == 1)
            System.out.println(num+"不是质数");
        else
            System.out.println(num+"是质数");
    }
}

1.7 随机数数组 ※

生成一个顺序数组,将这个数组的元素打乱顺序后输出

package cn.cxy.exec;

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

public class ShuffleArray {
    public static void main(String[] args) {
        //调用f()方法，从方法获取一个int[]数组
        int[] a = f();
        //遍历打印数组数据
        for(int i=0; i<a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("\n\n----------------");

        //把a数组，传递到 shuffle() 方法打乱顺序
        shuffle(a);
        //打印乱序后的数组
        System.out.println(Arrays.toString(a));
    }

    public static int[] f() {
        //新建int[]数组，长度5
        //再把它的内存地址存到变量 a
        int[] a = new int[5];
        //遍历访问5个位置，填入1,2,3,4,5
        for(int i=0; i<a.length; i++) {
            a[i] = i+1;
        }
        //返回数组，把数组返回到调用位置
        //本质是把数组地址返回去
        return a;
    }

    public static void shuffle(int[] a) {
        /*
         *        j
         * [4, 2, 3, 1, 5]
         *     i
         *
         * *) i循环遍历数组
         * *) 随机定位下标j与i交换
         */
        for (int i = 0; i < a.length; i++) {
            //随机下标j，范围：[0, a.length)
            int j = new Random().nextInt(a.length);
            int t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
}

1.8 双色球生成案例

体彩中有一项是双色球，要求在1-33号共33个红色球里选出6个，1-16号共16个蓝色球中选出一个作为中奖号码，
请实现这个需求

package spring_festival_homework;

import java.util.Random;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-14:42
 * @Description:
 * 体彩中有一项是双色球，要求在1-33号共33个红色球里选出6个，1-16号共16个蓝色球中选出一个作为中奖号码，
 * 请实现这个需求
 */
public class Ball {
    public static void main(String[] args) {
        //数组的方式
        //存34个红球，有一个没用的
        int[] red = new int[34];
        //存17个篮球，有一个没用的
        int[] blue = new int[17];

        int ball1 = 0;
        int ball2 = 0;

        //随机抓 -----随机数
        Random rand = new Random();
        while (ball1 != 6 || ball2 != 1){
            int num = rand.nextInt(33)+1; //随机生成红球
            int num2 = rand.nextInt(16)+1;//随机生成蓝球
            if (ball1 != 6 && red[num] == 0){
                red[num]++;
                ball1++;
            }
            if (ball2 != 1 && blue[num2] == 0) {
                blue[num2]++;
                ball2++;
            }
        }

        //输出结果为1的
        System.out.print("红球的结果:");
        for (int i = 1;i < red.length;i++){
            if (red[i] == 1){
                System.out.print(i+",");
            }
        }
        System.out.print("蓝球:");
        for (int j = 1;j < blue.length;j++){
            if (blue[j] == 1){
                System.out.print(j);
            }
        }
        //排列组合的思想
        /*
        System.out.println("所有可能的组合如下:");
        for (int i = 1;i<34;i++){
            for (int i2 = i+1;i2 < 34;i2++){
                for (int i3 = i2+1;i3<34;i3++){
                    for (int i4 = i3+1;i4 < 34;i4++){
                        for (int i5 = i4+1;i5 < 34; i5++){
                            for (int i6 = i5+1;i6<34;i6++){
                                for (int blue = 1;blue<=16;blue++){
                                    System.out.println("红球:"+i+","+
                                            i2+","+i3+","+i4+","+i5+
                                            ","+i6+"\t蓝球:"+blue);
                                }
                            }
                        }
                    }
                }
            }
        }
        */

    }
}

拓展：
需要随机数可以使用Random类提供的nextXXX方法，
1.例如：nextInt():默认生成Int类型范围内的整数
2.nextInt(int num):生成0到num-1范围内的整数（含头不含尾）

1.9 随机数组的归并问题

生成两个任意的随机数组，并将这两个数组按照数字大小按顺序归并到一个新数组中

package spring_festival_homework;

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

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-17:22
 * @Description:
 * 生成两个任意的随机数组，并将这两个数组按照数字大小按顺序归并到一个新数组中
 */
public class Merge_Arr {
    public static void main(String[] args) {
        Random rand = new Random();
        int[] arr1 = new int[rand.nextInt(10)+1];
        int[] arr2 = new int[rand.nextInt(10)+1];

        for (int i = 0;i < arr1.length;i++){
            arr1[i] = rand.nextInt(100);
        }

        for (int j = 0;j < arr2.length;j++){
            arr2[j] = rand.nextInt(100);
        }

        int[] sort_Arr = new int[arr1.length+ arr2.length];

        Arrays.sort(arr1);
        Arrays.sort(arr2);

        //定义三个指针变量
        int p1 = 0;
        int p2 = 0;
        int p3 = 0;

        while (p1 <= arr1.length-1 || p2 <= arr2.length-1){
            if ( p1 == arr1.length && p2 != arr2.length ) //数组1遍历完了，数组2还有剩余元素
                sort_Arr[p3++] = arr2[p2++];
            else if (p2 == arr2.length && p1 != arr1.length)    //数组2遍历完了，数组1还有剩余元素
                sort_Arr[p3++] = arr1[p1++];
            else        //数组1和2都未完成遍历
                if (arr1[p1] > arr2[p2])
                    sort_Arr[p3++] = arr2[p2++];
                else
                    sort_Arr[p3++] = arr1[p1++];
        }

        System.out.println("数组1:"+Arrays.toString(arr1));
        System.out.println("数组2:"+Arrays.toString(arr2));
        System.out.println("归并后的新数组:"+Arrays.toString(sort_Arr));
    }
}

1.10 计算器 ※

实现一个简易的计算器，具有功能：+ - * /
并且按1退出，按2继续计算

package cn.cxy.exec;

import java.util.Scanner;

public class TestMethod {
	public static void main(String[] args) {
		f0();//调用一个实现计算器的方法
	}
	private static void f0() {
		while(true) {
			//完成实现一个计算器的功能
			//1.提示并接收用户要计算的两个数
			System.out.println("请您输入要计算的第一个数：");
			int a = new Scanner(System.in).nextInt();
			System.out.println("请您输入要计算的第二个数：");
			int b = new Scanner(System.in).nextInt();
			
			//2.提示并接收用户输入的运算符
			System.out.println("请输入您要计算的运算符：支持 + - * / ");
			String s = new Scanner(System.in).nextLine();
			
			//3.根据运算符调用不同的方法给出结果
			switch(s) {
				case "+" : f1(a,b);break; 
				case "-" : f2(a,b);break; 
				case "*" : f3(a,b);break; 
				case "/" : f4(a,b);break; 
				default :System.out.println("输入的运算符不正确！");
			}
			//4.询问用户是否想继续运算
			System.out.println("如果想退出，请输入1，继续请输入2");
			int flag = new Scanner(System.in).nextInt();
			if(flag==1) break;//如果if后只有一句话，大括号可以省略，break退出死循环
			
		}
		
	}
	private static void f4(int a,int b) {//进行除法运算
		System.out.println(a+"与"+b+"的除法运算结果为："+(a/b));
	}
	private static void f3(int a,int b) {//进行乘法运算
		System.out.println(a+"与"+b+"的乘法运算结果为："+(a*b));
	}
	private static void f2(int a,int b) {//进行减法运算
		System.out.println(a+"与"+b+"的减法运算结果为："+(a-b));
	}
	private static void f1(int a,int b) {//做加法运算的方法
		System.out.println(a+"与"+b+"的加法运算结果为："+(a+b));
	}

}

1.11 面向对象练习：设计小狗类

定义一个小狗类Dog
属性：姓名name 年龄age 品种kind 主人host 价格price
功能：跑run 吃eat 睡觉sleep 玩play
要求：
1.创建所有的属性，并进行封装
2.创建本类的无参构造、含参构造(int n)、全参构造
3.利用3种不同构造方法创建三个对象d1 d2 d3
4.通过创建好的每一个对象，查看所有的属性，并调用所有的方法

Dog类

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-18:52
 * @Description:
 * 定义一个小狗类Dog
 * 属性：姓名name 年龄age 品种kind 主人host 价格price
 * 功能：跑run 吃eat 睡觉sleep 玩play
 * 要求：
 * 1.创建所有的属性，并进行封装
 * 2.创建本类的无参构造、含参构造(int n)、全参构造
 * 3.利用3种不同构造方法创建三个对象d1 d2 d3
 * 4.通过创建好的每一个对象，查看所有的属性，并调用所有的方法
 */
public class Dog {
    public Dog() {
    }

    public Dog(String name, int age, String kind, String host, double price) {
        this.name = name;
        this.age = age;
        this.kind = kind;
        this.host = host;
        this.price = price;
    }

    public Dog(int n){
        this.age = n;
    }
    private String name;
    private int age;
    private String kind;
    private String host;
    private double price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getKind() {
        return kind;
    }

    public void setKind(String kind) {
        this.kind = kind;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public void run(){
        System.out.println(kind+"在奔跑");
    }
    public void eat(){
        System.out.println(kind+"在吃饭");
    }
    public void sleep(){
        System.out.println(kind + "在睡觉");
    }
    public void play(){
        System.out.println(kind+"在玩耍");
    }
}

测试类

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-19:03
 * @Description:
 * 测试类
 * 1.利用3种不同构造方法创建三个对象d1 d2 d3
 * 2.通过创建好的每一个对象，查看所有的属性，并调用所有的方法
 */
public class OopDemo {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        Dog d2 = new Dog(7);
        Dog d3 = new Dog("花花",6,"柯基","老王",1920.5);

        d1.setName("毛毛");
        d1.setAge(8);
        d1.setHost("马超");
        d1.setKind("柴犬");
        d1.setPrice(2999.9);
        d1.eat();
        d1.play();
        d1.run();
        d1.sleep();
        System.out.println("姓名:"+d1.getName()+",品种:"+d1.getKind()+",年龄:"+
                +d1.getAge()+",价格:"+d1.getPrice()+",主人:"+
                d1.getHost());

        d2.setName("大白");
        d2.setHost("悟空");
        d2.setKind("泰迪");
        d2.setPrice(6888.9);
        d2.eat();
        d2.play();
        d2.run();
        d2.sleep();
        System.out.println("姓名:"+d2.getName()+",品种:"+d2.getKind()+",年龄:"+
                +d2.getAge()+",价格:"+d2.getPrice()+",主人:"+
                d2.getHost());

        d3.eat();
        d3.play();
        d3.run();
        d3.sleep();
        System.out.println("姓名:"+d3.getName()+",品种:"+d3.getKind()+",年龄:"+
                +d3.getAge()+",价格:"+d3.getPrice()+",主人:"+
                d3.getHost());
    }
}

1.12 方法的重载练习

方法的重载练习
方法一：传入两个int类型的参数，并返回这两个数的和，方法名为sum
方法二：传入两个double类型的参数，并返回这两个数的和，方法名为sum
方法三：传入一个double类型的参数，一个int类型的参数，并返回这两个数的和，方法名为sum
方法四：传入一个int类型的参数，一个double类型的参数，并返回这两个数的和，方法名为sum

package spring_festival_homework;

import java.util.Scanner;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-19:31
 * @Description:
 * 方法的重载练习
 * 方法一：传入两个int类型的参数，并返回这两个数的和，方法名为sum
 * 方法二：传入两个double类型的参数，并返回这两个数的和，方法名为sum
 * 方法三：传入一个double类型的参数，一个int类型的参数，并返回这两个数的和，方法名为sum
 * 方法四：传入一个int类型的参数，一个double类型的参数，并返回这两个数的和，方法名为sum
 */
public class OverrideDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入第1个数:");
        int num1 = scan.nextInt();
        System.out.print("请输入第2个数:");
        int num2 = scan.nextInt();
        System.out.println("两个数的和为:"+sum(num1,num2));

        System.out.print("请输入第1个数:");
        double num3 = scan.nextDouble();
        System.out.print("请输入第2个数:");
        double num4 = scan.nextDouble();
        System.out.println("两个数的和为:"+sum(num3,num4));

        System.out.print("请输入第1个数:");
        double num5 = scan.nextDouble();
        System.out.print("请输入第2个数:");
        int num6 = scan.nextInt();
        System.out.println("两个数的和为:"+sum(num5,num6));

        System.out.print("请输入第1个数:");
        int num7 = scan.nextInt();
        System.out.print("请输入第2个数:");
        double num8 = scan.nextDouble();
        System.out.println("两个数的和为:"+sum(num7,num8));
    }
    public static int sum(int num1,int num2){
        return num1+num2;
    }

    public static double sum(double num1,double num2){
        return num1+num2;
    }

    public static double sum(double num1,int num2){
        return num1+num2;
    }

    public static double sum(int num1,double num2){
        return num1+num2;
    }
}

1.13 回文问题

如果一个用户输入的数据,从前到后或者从后到前读到的内容都是一样的,
我们就称这种数据为"回文",比如123321 或者 12321 或者上海自来水来自海上等等

package spring_festival_homework;

import java.util.Scanner;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-04-19:47
 * @Description:
 * 需求, 如果一个用户输入的数据, 从前到后或者从后到前读到的内容都是一样的,
 * 我们就称这种数据为"回文",比如123321 或者 12321 或者上海自来水来自海上等等
 */
public class Palindrome {
    public static void main(String[] args) {
        String s = new Scanner(System.in).nextLine();
        char[] arr = s.toCharArray();//转化为字符数组
        //定义头尾指针
        int start = 0;
        int end = arr.length - 1;
        int flag = 1;//定义变量，记录是否为回文串，1是，0不是

        while (start < end)
            if (arr[start++] != arr[end--])
                flag = 0;

        if (flag == 1)
            System.out.println(s+"是回文串");
        else
            System.out.println(s+"不是回文串");
    }
}

1.14 面向对象练习：设计小猫类

测试类TestCat

(1)定义一个小猫类Cat
(2)定义属性: 名字name 年龄age 品种kind 主人host 价格price
(3)封装所有的属性,提供所有属性对应的get与set方法
(4)提供Cat无参构造与全参构造

(5)提供功能:
<1>吃eat:参数int n,无返回值,打印:小猫Cat今晚要吃n根肉骨头
<2>跳jump:参数String
name,无返回值,打印:小猫name跳的老高啦~
<3>睡觉sleep:参数String name,double
num无返回值,打印:小猫name今天一共睡了num个小时
<4>玩play: 参数String
host,返回值String"逗猫棒",打印:小猫与主人host玩的很开心
<5>叫bark:打印:小猫喜欢喵喵叫,此方法要封装,玩的时候才叫

(6)完成业务:每当创建小猫类的对象,就在控制台打印:又有一只可爱的小猫咪粗来啦~
(7)完成测试:
<1>创建小猫类的对象c1,使用无参构造创建并调用set()给c1赋值:叮当 300 机器猫大雄 10000
赋值后使用get()查看是否赋值成功
<2>使用全参构造创建小猫类对象c2,赋值:罗小黑 7 变异猫未知 800
赋值后使用get()查看是否赋值成功
<3>创建小猫类的对象c3,通过c3对象调用小猫类的功能*5

Cat类：

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-05-16:31
 * @Description:
 * > (1)定义一个小猫类Cat
 * > (2)定义属性: 名字name 年龄age 品种kind 主人host 价格price
 * > (3)封装所有的属性,提供所有属性对应的get与set方法
 * > (4)提供Cat无参构造与全参构造
 * >
 * > (5)提供功能:
 * > <1>吃eat:参数int n,无返回值,打印:小猫Cat今晚要吃n根肉骨头
 * > <2>跳jump:参数String
 * > name,无返回值,打印:小猫name跳的老高啦~
 * > <3>睡觉sleep:参数String name,double
 * > num无返回值,打印:小猫name今天一共睡了num个小时
 * > <4>玩play: 参数String
 * > host,返回值String"逗猫棒",打印:小猫与主人host玩的很开心
 * > <5>叫bark:打印:小猫喜欢喵喵叫,此方法要封装,玩的时候才叫
 * >
 * > (6)完成业务:每当创建小猫类的对象,就在控制台打印:又有一只可爱的小猫咪粗来啦~
 */
public class Cat {
    String name;
    int age;
    String kind;
    String host;
    double price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getKind() {
        return kind;
    }

    public void setKind(String kind) {
        this.kind = kind;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Cat() {
        System.out.println("又有一只可爱的小猫咪粗来啦~");
    }

    public Cat(String name, int age, String kind, String host, double price) {
        this.name = name;
        this.age = age;
        this.kind = kind;
        this.host = host;
        this.price = price;

        System.out.println("又有一只可爱的小猫咪粗来啦~");
    }

    public void eat(int n){
        System.out.println("小猫Cat今晚要吃n根肉骨头");
    }

    public void jump(String name){
        System.out.println("小猫name跳的老高啦~");
    }
    
    public void sleep(String name,double num){
        System.out.println("小猫"+name+"今天一共睡了"+num+"个小时");
    }
    
    public String play(String host){
        System.out.println("小猫与主人host玩的很开心");
        bark();
        return "逗猫棒";
    }
    
    private void bark(){
        System.out.println("小猫喜欢喵喵叫");
    }
    
}

TestCat类：

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-05-16:31
 * @Description:
 * 完成测试:
 * > <1>创建小猫类的对象c1,使用无参构造创建 并调用set()给c1赋值:叮当 300 机器猫 大雄 10000
 * > 赋值后使用get()查看是否赋值成功
 * > <2>使用全参构造创建小猫类对象c2,赋值:罗小黑 7 变异猫 未知 800
 * > 赋值后使用get()查看是否赋值成功
 * > <3>创建小猫类的对象c3,通过c3对象调用小猫类的功能*5
 */
public class TestCat {
    public static void main(String[] args) {
        Cat c1 = new Cat();
        c1.setAge(300);
        c1.setHost("大雄");
        c1.setKind("机器猫");
        c1.setName("叮当");
        c1.setPrice(10000);

        System.out.println(c1.getName()+","+c1.getKind()+","+
                c1.getAge()+","+c1.getPrice()+","+c1.getHost());
        
    }
}

1.15 面向对象:学生专业与成绩管理

(1)编写学生类Student
包含属性:sno学号 name姓名 gender性别 major专业 totalScore总成绩

(2)编写专业类Major
包含属性:totalScore总成绩 englishScore英文成绩 midScore期中成绩 finalScore期末成绩

(3)编写三个不同的子专业类继承专业类Major,
以下为各个专业与它们独有的专业课:
1)计算机系:ComputerMajor 编程课成绩(专业课):programmingScore 2)中文系:ChineseMajor 写作课成绩(专业课):writingScore
3)数学系:MathematicsMajor 数学理论成绩(专业课):mathScore
4)提供计算最终成绩的getScore():
成绩计算逻辑:总成绩=专业课成绩40%+英文课成绩10%+期中成绩15%+期末成绩35%

(4)在测试类中定义一个可以容纳5个学生的学生数组输入学生的各项信息,学号按输入顺序,第1个学生学号为1 使用随机数给学生随机分配专业
输入学生的各项分数,计算得出学生的总成绩利用将以上所有信息创建对应的学生对象,存入数组中输出学生的信息,格式: 学号:1,
姓名:‘李四’, 性别:女, 专业:数学专业{数学理论课成绩:98.0,英文课成绩:88.0,期中成绩:79.0,期末成绩:90.0},
总成绩:91.35

中文系

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-05-17:11
 * @Description:
 * 中文系:ChineseMajor
 * 写作课成绩(专业课):writingScore
 * 提供计算最终成绩的getScore():
 * 成绩计算逻辑:总成绩=专业课成绩40%+英文课成绩10%+期中成绩15%+期末成绩35%
 */
public class ChineseMajor extends Major{
    double writingScore;

    public double getScore(){
        totalScore = writingScore*0.4 + englishScore * 0.1
                + midScore * 0.15 + finalScore * 0.35;
        return totalScore;
    }
}

计算机系

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-05-17:10
 * @Description:
 * 计算机系:ComputerMajor
 * 编程课成绩(专业课):programmingScore
 * 提供计算最终成绩的getScore():
 * 成绩计算逻辑:总成绩=专业课成绩40%+英文课成绩10%+期中成绩15%+期末成绩35%
 */
public class ComputerMajor extends Major{
    double programmingScore;

    public double getScore(){
        totalScore = programmingScore*0.4 + englishScore * 0.1
                + midScore * 0.15 + finalScore * 0.35;
        return totalScore;
    }
}

数学系

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-05-17:12
 * @Description:
 * 数学系:MathematicsMajor
 * 数学理论成绩(专业课):mathScore
 * 提供计算最终成绩的getScore():
 * 成绩计算逻辑:总成绩=专业课成绩40%+英文课成绩10%+期中成绩15%+期末成绩35%
 */
public class MathematicsMajor extends Major{
    double mathScore;

    public double getScore(){
        totalScore = mathScore*0.4 + englishScore * 0.1
                + midScore * 0.15 + finalScore * 0.35;
        return totalScore;
    }
}

专业类

package spring_festival_homework;

/**
 * @Author 吴嘉旭
 * @Date 2023-02-05-17:04
 * @Description:
 * 编写专业类Major
 * 包含属性:totalScore总成绩
 * englishScore英文成绩
 * midScore期中成绩
 * finalScore期末成绩
 */
public class Major {
      double totalScore;
      double englishScore;
      double midScore;
      double finalScore;
}

测试类

package spring_festival_homework;

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

/**
 * @Author 吴嘉旭
 * @Date 2023-02-05-17:22
 * @Description:
 * 在测试类中定义一个可以容纳5个学生的学生数组
 * 输入学生的各项信息,学号按输入顺序,第1个学生学号为1 使用随机数给学生随机分配专业
 * 输入学生的各项分数,计算得出学生的总成绩
 * 利用将以上所有信息创建对应的学生对象,
 * 存入数组中 输出学生的信息,格式: 学号:1,姓名:‘李四’, 性别:女, 专业:数学专业{数学理论课成绩:98.0,英文课成绩:88.0,期中成绩:79.0,期末成绩:90.0},总成绩:91.35
 */
public class Test_Student {
    public static void main(String[] args) {
        Student[] stuArr = new Student[5];  //  创建学生数组
        /*Major[] majors = {new ChineseMajor(),new ComputerMajor(),
        new MathematicsMajor()};//创建专业数组*/

        Scanner scan = new Scanner(System.in);
        Random rand = new Random();

        //定义数组用来分类是什么类别的成绩 0表示中文，1表示计算机，2表示数学
        int[] majorCode = new int[5];

        for (int i = 0;i < 5;i++){

            Student stu = new Student();
            stu.sno = i+1; //学生的学号从1开始，依次递增
            System.out.print("请输入学生姓名:");
            stu.name = scan.nextLine();
            System.out.print("请输入学生性别:");
            stu.gender = scan.nextLine();
            //随机分配专业
            int randNum = rand.nextInt(3);

            //根据不同专业做不同的处理
            if (randNum == 0){
                ChineseMajor chinese = new ChineseMajor();
                System.out.print("请输入英语成绩:");
                chinese.englishScore = scan.nextDouble();
                System.out.print("请输入写作课(专业课)成绩:");
                chinese.writingScore = scan.nextDouble();
                System.out.print("请输入期中成绩:");
                chinese.midScore = scan.nextDouble();
                System.out.print("请输入期末成绩:");
                chinese.finalScore = scan.nextDouble();
                stu.major = chinese;
                stu.totalScore = chinese.getScore();
            }else if (randNum == 1){
                ComputerMajor computer = new ComputerMajor();
                System.out.print("请输入英语成绩:");
                computer.englishScore = scan.nextDouble();
                System.out.print("请输入编程课(专业课)成绩:");
                computer.programmingScore = scan.nextDouble();
                System.out.print("请输入期中成绩:");
                computer.midScore = scan.nextDouble();
                System.out.print("请输入期末成绩:");
                computer.finalScore = scan.nextDouble();
                stu.major = computer;
                stu.totalScore = computer.getScore();
            }else {
                MathematicsMajor math = new MathematicsMajor();
                System.out.print("请输入英语成绩:");
                math.englishScore = scan.nextDouble();
                System.out.print("请输入数学理论(专业课)成绩:");
                math.mathScore = scan.nextDouble();
                System.out.print("请输入期中成绩:");
                math.midScore = scan.nextDouble();
                System.out.print("请输入期末成绩:");
                math.finalScore = scan.nextDouble();
                stu.major = math;
                stu.totalScore = math.getScore();
            }
            majorCode[i] = randNum;
            stuArr[i] = stu;
            scan.nextLine(); // 读取回车符
            System.out.println("录入成功！");
        }

        //输出学生信息
        for (int j = 0;j < 5;j++){
            if (majorCode[j] == 2){
                MathematicsMajor m = (MathematicsMajor) stuArr[j].major;
                System.out.println("学号:"+stuArr[j].sno+", 姓名:'"+
                        stuArr[j].name+"’, 性别:"+stuArr[j].gender+
                        ", 专业:数学专业{数学理论课成绩:"+m.mathScore+",英文课成绩:"+m.englishScore+
                        ",期中成绩:"+m.midScore+",期末成绩:"+m.finalScore+"},总成绩:"+stuArr[j].totalScore+")");
            }else if (majorCode[j] == 1){
                ComputerMajor c = (ComputerMajor) stuArr[j].major;
                System.out.println("学号:"+stuArr[j].sno+", 姓名:'"+
                        stuArr[j].name+"’, 性别:"+stuArr[j].gender+
                        ", 专业:计算机专业{编程课成绩:"+c.programmingScore+",英文课成绩:"+c.englishScore+
                        ",期中成绩:"+c.midScore+",期末成绩:"+c.finalScore+"},总成绩:"+stuArr[j].totalScore+")");
            }else {
                ChineseMajor cm = (ChineseMajor) stuArr[j].major;
                System.out.println("学号:"+stuArr[j].sno+", 姓名:'"+
                        stuArr[j].name+"’, 性别:"+stuArr[j].gender+
                        ", 专业:中文专业{写作课成绩:"+cm.writingScore+",英文课成绩:"+cm.englishScore+
                        ",期中成绩:"+cm.midScore+",期末成绩:"+cm.finalScore+"},总成绩:"+stuArr[j].totalScore+")");
            }

        }
    }
}

1.next()和nextLine()的区别：注意输入缓存区的回车、空格问题
2.Major[] majors = {new ChineseMajor(),new ComputerMajor(), new MathematicsMajor()};这种静态创建数组的方式实质上只会new 一次对象，以后调用majors[0]等代码只会用同一个对象