JAVA练习500题2帖超详细带答案持续更新中~

2年前 (2022) 程序员胖胖胖虎阿

215 0 0

JAVA小白编程题练习2

可能有很多刚入门的小白不知道自己如何能快速提升编程技巧与熟练度
其实大佬进阶之路只有一个~ 那就是疯狂码代码!!!实践出真知!!!
所以为了大家能够想练习的时候有素材,泡泡给大家整理了一些练习题
本帖是2帖，如果觉得难，可以先从1帖开始练习哦~

练习帖1 点我点我

由于平时比较忙,所以我在不定时努力更新中,欢迎监督~

文章目录

JAVA小白编程题练习2
- - [练习帖1 点我点我](https://chengxiaoyu-paopao.blog.csdn.net/article/details/116569562)
  - 练习题 : 类型之间的转换与字面值规则
  - 练习题 : ==比较的练习
  - 练习题 : 嵌套分支的练习
  - 练习题 : 根据颜色推荐菜品switch
  - 练习题：面向对象练习：设计小狗类
  - 练习题 : 面向对象练习：设计宠物商店案例
  - 练习题 : while循环练习
  - 练习题 : 方法调用的顺序
  - 练习题 : 数组练习1
  - 练习题 : 数组练习2
  - 练习题 : 进制的前缀
  - 练习题 : 创建一个长度随机，内容随机的整形数组,并对这个数组进行升序排序
  - 练习题 : 创建一个长度随机，内容随机的整形数组,并对这个数组进行降序排序
  - 练习题 : 完成减肥计划案例1
  - 练习题 : 完成减肥计划案例2
  - 练习题 : 实现一个简易的计算器
  - 练习题 : 方法的重载练习
  - 练习题 : 面向对象练习：设计小狗类
  - 练习题 : 面向对象练习：设计小猫类
  - 练习题 : 面向对象练习：实现学生类
  - 练习题 : 面向对象练习：设计学校开学招待设计案例
  - 练习题 : 面向对象练习：设置小动物类，包含会飞的动物鸟类昆虫
  - 练习题 : 实现二分法查找/折半查找
  - 练习题 : 二分法实现数据动态插入
  - 练习题 : 求数字阶乘(递归解法版)
  - 练习题 : 递归求目录总大小
  - 练习题 : 递归删除文件夹
  - 练习题 : 复制文件(字节流批量读取)
  - 练习题 : 逆序遍历List集合
  - 练习题 : 回文问题
  - 练习题 : 手写数组列表
  - 练习题 : 文件复制案例
  - 练习题 : 面向对象:学生专业与成绩管理
  - - - ==1. 创建学生类==
      - ==2. 创建专业类==
      - ==3. 创建计算机专业类==
      - ==4. 创建文学专业类==
      - ==5. 创建数学专业类==
      - ==6. 创建测试类==

练习题 : 类型之间的转换与字面值规则

package cn.tedu.basic;
/*本类用来测试类型转换
* 1.byte1--short char2--int4--long8--float4--double8
* 2.小到大 直接转:隐式转换,可以直接转换
*   大到小 强制转:显式转换,需要强转,注意发生数据溢出的问题
*   浮变整 小数没:小数部分直接被舍弃
* 3.强制类型转换的格式:目标类型 变量名 = (目标类型)要转换类型的数据;
* */
public class TestTypeChage {
    public static void main(String[] args) {
        byte a = 10;
        short b = a;//不会报错,小转大

        int c = 1;
        long d = c;//不会报错,小转大

        float f = 3.1415f;
        double e = f;//不会报错,小转大

        long g = 8274624867L;
        float h = g;//不会报错,小转大
        System.out.println(h);

        char i = 'a';
        int j = i;//不会报错,小转大
        System.out.println(j);//97

        int a1 = 1;
        byte b1 = 2;
        //byte c1 = a1+b1;会报错,大转小
        byte c1 = (byte) (a1+b1);//需要强制类型转换

        byte d1 = (byte) 128;
        System.out.println(d1);//-128,需要强转,注意发生数据溢出的问题

        short e1 = 'a';
        char f1 = 120;
        System.out.println(e1);//97,打印的是编码值
        System.out.println(f1);//'x',打印是根据编码找到的字符

        float h1 = 32874.435F;
        int i1 = (int) h1;//大转小 强制转
        System.out.println(i1);//32874 浮变整 小数没
    }
}

练习题 : ==比较的练习

    package cn.tedu.basic;

public class TestOperator {
    public static void main(String[] args) {
        //引用类型Cat类型的变量c1 c2 保存的是对象的地址值
        Cat c1 = new Cat();
        Cat c2 = new Cat();

        int[] a1 = {1, 2, 3};
        int[] a2 = {1, 2, 3};

        int b1 = 4;
        int b2 = 4;

        boolean f1 = true;
        boolean f2 = true;
        /* == 如果比较的是基本类型,比较的是值,字面值,具体存的那个数*/
        System.out.println(b1 == b2);//true
        System.out.println(f1 == f2);//true

        /* == 如果比较的是引用类型,比较的也是值,地址值*/
        System.out.println(c1 == c2);//false
        System.out.println(a1 == a2);//false
    }
}

class Cat {
    String name;
    int age;

    public void bark() {
        System.out.println("小猫喜欢喵喵叫");
    }
}

练习题 : 嵌套分支的练习

需求:提示并接收用户输入的月份,判断并输出属于哪个季节
1-12月是合法数据 3~5春天 6~8夏天 9~11秋天其他情况冬天

 package cn.tedu.basic;

import java.util.Scanner;

/*本类用于复习分支结构*/
public class TestIf {
    public static void main(String[] args) {
        //1.提示并接收用户输入的月份
        System.out.println("请输入您要查看的月份:");
        int month = new Scanner(System.in).nextInt();

        //2.对用户输入的数据进行合法性检测
        /*如果if后的语句只有一句,大括号可以省略不写*/
        /*return关键字除了可以帮我们返回方法的返回值以外
        * 还可以直接结束当前的方法,如果遇到了return,本方法会直接结束*/
//        if(month <0 || month >12) return;
//        System.out.println("今天天气真不错");//这句话是用来检测main()有没有结束
        if(month <= 0 || month >12){
            System.out.println("您输入的月份不正确!应该是1-12月以内");
        }else{
            //3.判断接收到的合法数据属于哪个季节,并将结果输出
            if(month >=3 && month <=5){
                System.out.println(month+"月是春天");
            }else if(month >=6 && month <=8){
                System.out.println(month+"月是夏天~");
            }else if(month >=9 && month <=11){
                System.out.println(month+"月是秋天");
            }else{
                System.out.println("冬天就要来啦,春天还会远吗?");
            }
        }
    }
}

练习题 : 根据颜色推荐菜品switch

package cn.tedu.basic;

import java.util.Scanner;

/*本类用于复习switch*/
public class TestSwitch {
    public static void main(String[] args) {
        //需求:接收用户今天输入的颜色,推荐菜品
        //1.提示并接收用户输入的颜色
        System.out.println("请输入您今天心情的颜色:");
        String color = new Scanner(System.in).nextLine();
        //2.完成选择结构
        switch (color) {
            case "红":
                System.out.println("红烧鱼");
                break;//为了避免穿透
            case "黄":
                System.out.println("菠萝炒饭");
                break;
            case "橙":
                System.out.println("水煮肉片");
                break;
            default:
                System.out.println("哎呀,没有识别到这个功能呢,正在开发中...");
        }
    }
}

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

需求：

抽象形成一个小狗类Dog
属性：名字name 年龄age 品种kind 主人host 价格price
功能：
1)跑run：无参，打印：小狗Dog跑的老快了~
2)吃eat：参数int n，打印：小狗今晚要吃n根肉骨头
3)睡觉sleep：参数double num，打印：小狗睡了num个小时
4)玩play：参数String host，返回值 String “飞盘”，打印：小狗与主人host玩的很开心
5)叫bark：打印：小狗喜欢汪汪叫，封装此方法，玩play()的时候才bark()
创建本类的2个对象，并给两个对象的所有属性并查看
名字name 年龄age 品种kind 主人host 价格price
哮天犬 999 猎狗二郎神 10000
罗小黑 5 神奇犬大自然 999.99

package cn.cxy.exec;
public class TestDog {
    public static void main(String[] args) {
        //5.1创建Dog类的第1个对象
        Dog d1 = new Dog();
        //5.2修改d1对象的属性值
        d1.setName("哮天犬");
        d1.setAge(999);
        d1.setKind("猎狗");
        d1.setHost("二郎神");
        d1.setPrice(10000);
        //5.3打印查看d1对象的属性值
        System.out.println(d1.getName());
        System.out.println(d1.getAge());
        System.out.println(d1.getKind());
        System.out.println(d1.getHost());
        System.out.println(d1.getPrice());

        //6.1创建Dog类的第2个对象
        Dog d2 = new Dog();
        //6.2修改d2对象的属性值
        d2.setName("罗小黑");
        d2.setAge(5);
        d2.setKind("神奇犬");
        d2.setHost("大自然");
        d2.setPrice(999.99);
        //6.3打印查看d2对象的属性值
        System.out.println(d2.getName());
        System.out.println(d2.getAge());
        System.out.println(d2.getKind());
        System.out.println(d2.getHost());
        System.out.println(d2.getPrice());

        //7.调用dog类的5个方法
        d1.run();
        d1.eat(5);
        d1.sleep(8.8);
        //方式一：只调用play()的功能
        d1.play(d1.getHost());
        //方式二：不仅调用play()的功能还接收了返回值飞盘交给r保存
        String r = d1.play(d1.getHost());
        System.out.println(r);
        //方式三：调用play()的功能，并直接打印了play()的返回值飞盘
        System.out.println(d1.play(d1.getHost()));
    }
}
//1.定义小狗类
class Dog{
    //2.定义5个属性
    //3.1使用private修饰所有的属性
    private String name;//姓名
    private int age;//年龄
    private String kind;//品种
    private String host;//主人
    private double price;//价格
    //4.1添加小狗类功能1
    public void run(){
        System.out.println("小狗Dog跑的老快了~");
    }
    //4.2添加小狗类功能2
    public void eat(int n){
        System.out.println("小狗今晚要吃"+n+"根肉骨头");
    }
    //4.3添加小狗类的功能3
    public void sleep(double num){
        System.out.println("小狗今晚睡了"+num+"个小时");
    }
    //4.4添加小狗类的功能4
    public String play(String host){
        System.out.println("小狗与主人"+host+"玩的很开心");
        bark();//在本类的公共方法中调用被封装的方法的功能
        return "飞盘";
        //bark();//遇到return时已经结束本方法了，return后不可以直接写代码
    }
    //4.5添加小狗类的功能5
    private void bark(){
        System.out.println("小狗喜欢汪汪叫");
    }

    //3.2添加被封装属性的公共的get与set方法
    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;
    }
}

练习题 : 面向对象练习：设计宠物商店案例

package cn.tedu.oopexec;

import java.util.Arrays;

/*本类用于实现宠物商店设计案例*/
public class TestAnimalShop {
    public static void main(String[] args) {
        //开始测试
        //1.创建宠物商店对象
        AnimalShop shop = new AnimalShop();
        //2.给宠物店起名字
        shop.shopName = "爱宠宠物店";
        //3.查看宠物店现在所有的宠物
        System.out.println(Arrays.toString(shop.animals));//[null, null, null, null, null]

        //4.1创建动物对象--叫小白的3岁的小猫
        Cat cat = new Cat();
        cat.name = "小白";
        cat.age = 3;
        //4.2将第一只创建好的小动物放到数组里
        shop.animals[0] = cat;

        //5.1创建一只叫罗小黑的5岁的猫
        Cat cat1 = new Cat();
        cat1.name = "罗小黑";
        cat1.age = 5;
        //5.2将第二只创建好的小动物放到数组里
        shop.animals[1] = cat1;

        //6.1创建一只叫旺财的4岁的狗
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.age = 4;
        //6.2将第三只创建好的小动物放到数组里
        shop.animals[2] = dog;

        //7.1创建一只叫银子的100岁的鸟
        Bird bird = new Bird();
        bird.name = "银子";
        bird.age = 100;
        //7.2将第四只创建好的小动物放到数组里
        shop.animals[3] = bird;

        //8.1创建一只叫大米的7岁的狗
        Dog dog1 = new Dog();
        dog1.name = "大米";
        dog1.age = 7;
        //8.2将第五只创建好的小动物放到数组里
        shop.animals[4] = dog1;

        //9.通过遍历数组，查看所有的动物的名字与年龄
        for(int i = 0;i < 5; i++){
            System.out.println(shop.animals[i].name + shop.animals[i].age);
        }

        //10.调用动物们各自的功能
        shop.animals[0].eat();//小猫爱吃小鱼干~重写后的功能
        shop.animals[4].eat();//小动物Animal吃啥都行~继承自父类的功能

        //11.调用查询动物的方法
        Animal animal = shop.query(2);
        System.out.println(animal.name+animal.age);

        //12.调用购买动物的方法
        shop.buy(cat1);
        shop.buy(bird);
    }
}

//1.创建动物类的父类Animal
class Animal{
    //2.定义动物类的属性
    public String name;
    public int age;

    //3.定义动物类的方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }
}
//4.创建子类小猫类
class Cat extends Animal{
    //5.重写继承自父类的方法 两同 两小 一大
    @Override //添加注解，标记当前是一个重写的方法
    public void eat(){
        System.out.println("小猫爱吃小鱼干~");
    }
    //6.添加子类的特有方法
    public void miaoMiao(){
        System.out.println("小猫开始喵喵叫啦...");
    }
}

//7.创建子类小鸟类
class Bird extends Animal{}
//8.创建子类小狗类
class Dog extends Animal{}

//9.创建宠物商店类
class AnimalShop{
    //10.定义宠物商店的属性
    public String shopName;//商店名
    //准备一个Animal类型的数组，用来存放小动物对象，长度为5
    public Animal[] animals = new Animal[5];

    //11.1定义宠物商店的方法1--查询小动物
    public Animal query(int i){
        //传入编号，也就是数组下标，返回数组中对应的小动物对象
        return animals[i];
    }
    //11.2定义宠物商店的方法2--购买小动物
    /*此处方法的参数是多态的体现，不管传入的是具体的什么小动物，都看作Animal类型*/
    public void buy(Animal animal){
        System.out.println("恭喜你要带："+animal.name+"回家啦~，它"+animal.age+"岁啦，要好好照顾它哦~");
    }

}

练习题 : while循环练习

package cn.tedu.basic;

/*本类用作while复习*/
public class TestWhile {
    public static void main(String[] args) {
        //需求1:通过while循环打印10次"小可爱们中午好~"
        f1();
        //需求2:通过while循环打印1 2 3 ... 10
        f2();
        //需求3:通过while循环打印1 3 5 7 9 ... 99
        f3();
        //需求4:通过while计算:1+2+3+4+...+10
        f4();
        //需求5:通过while计算:2+4+6+8...+100
        f5();
    }

    private static void f1() {
        //需求1:通过while循环打印10次"小可爱们中午好~"
        //1.定义一个变量用来控制次数
        int count = 1;
        //2.定义一个循环,结束条件是count>10
        while (count <= 10) {
            System.out.println("小可爱们中午好~");
            count++;//注意count的值需要自增,不然就是一个死循环
        }
        System.out.println(count);//11
    }

    private static void f2() {
        //需求2:通过while循环打印1 2 3 ... 10
        int i = 1;
        while (i <= 10) {
            System.out.println(i);
            i++;
        }
    }

    private static void f3() {
        //需求3:通过while循环打印1 3 5 7 9 ... 99
        int num = 1;
        while (num < 100) {
            System.out.println(num);
            //num++;//12345...
            //num += 2;
            num = num + 2;//13579...
        }
    }

    private static void f4() {
        //需求4:通过while计算:1+2+3+4+...+10
        int i = 1;//用于控制循环,相当于循环变量
        int sum = 0;//用来保存求和的结果
        while(i <= 10){
            sum += i;
            //sum = sum + i;
            i++;
        }
        System.out.println("1到10累加的结果为:"+sum);
    }

    private static void f5() {
        //需求5:通过while计算:2+4+6+8...+100
        int i = 2;//循环变量控制循环
        int sum = 0;//用来保存求和的结果
        while(i <= 100){
            sum += i;//累加
            i += 2;//循环变量递增
        }
        System.out.println("2到100累加的结果为:"+sum);
    }
}

练习题 : 方法调用的顺序

package cn.tedu.basic;
/*本类用于练习方法的调用*/
public class MethodDemo {
    //1.创建入口函数
    public static void main(String[] args) {
        System.out.println("main() is start...");
        m1();
        System.out.println("main() is stop...");
    }

    //2.创建m1()
    private static void m1() {
        System.out.println("m1() is start...");
        m2();
        System.out.println("m1() is stop...");
    }
    //3.创建m2()
    private static void m2() {
        System.out.println("m2() is start...");
    }

}

练习题 : 数组练习1

需求1: 求数组中所有元素之和
需求2: 求数组中所有元素的最大值

package cn.tedu.basic;

/*本类用于复习数组的操作*/
public class TestArray1 {
    public static void main(String[] args) {
        //需求1:求出数组中所有的元素之和
        f1();
        //需求2:求出数组中所有元素的最大值
        f2();
    }

    private static void f2() {
        //需求2:求出数组中所有元素的最大值
        //1.定义一个数组
        int[] a = {45, 8, 90, 34, 65, -9};
        //2.定义一个变量,用来存储结果,也就是数组中所有元素的最大值
        int max = a[0];//这个位置不能写0,应该是数组中第一个元素的值
        //3.遍历数组,比较出最大值
        for (int i = 0; i <= a.length - 1; i++) {
            //4.判断max与a[i]的大小
            if(a[i] > max){
                max = a[i];//让max保存的一直都是目前遍历到的最大值
            }
        }
        //4.循环结束,输出数组中的最大值
        System.out.println("最大值为:"+max);
    }

    private static void f1() {
        //需求1:求出数组中所有的元素之和
        //1.定义一个数组
        int[] a = {1, 2, 3, 4, 5};
        //2.定义一个变量用来保存最终的结果
        int sum = 0;
        //3.用数组的遍历来进行数据的累加
        //i:下标 0 a.length-1 ++
        for (int i = 0; i <= a.length - 1; i++) {
            sum += a[i];
        }
        System.out.println("数组元素累计的和为:" + sum);
    }
}

练习题 : 数组练习2

需求: 将数组中的所有元素逆序输出(3种)
package cn.tedu.basic;

import java.util.Arrays;

/*需求: 将数组中的所有元素逆序输出(3种)*/
public class TestArray2 {
    public static void main(String[] args) {
        //f1();//实现思路1
        //f2();//实现思路2
        f3();//实现思路3
    }

    private static void f3() {
        //1.准备原数组
        int[] a = {100, 200, 300, 400, 500, 600};
        //2.遍历数组,将数组中对应位置上的元素交换位置
        for (int i = 0; i < a.length / 2; i++) {
            //3.准备一个第三方变量协助数组中的两个元素互换值
            //a[0] <-> a[a.length-1-0]
            //a[1] <-> a[a.length-1-1]
            //a[2] <-> a[a.length-1-2]
            //a[i] <-> a[a.length-1-i]
            int temp = a[i];
            a[i] = a[a.length-1-i];
            a[a.length-1-i] = temp;
        }
        System.out.println(Arrays.toString(a));
    }

    private static void f2() {
        //1.准备原数组
        int[] a = {10, 20, 30, 40, 50};
        //2.准备一个新数组,数组的长度与原数组长度相同
        int[] b = new int[a.length];
        //3.准备循环,遍历原数组,并将遍历到的元素复制到新数组中
        //i=0,a[0]->b[4]
        //i=1,a[1]->b[3]
        //i=2,a[2]->b[2]
        //i=3,a[3]->b[1]
        //i=4,a[4]->b[0]
        for (int i = 0; i < a.length; i++) {
            b[b.length - 1 - i] = a[i];
        }
        System.out.println(Arrays.toString(b));
        a = b;//把b保存的地址值交给a,这样a b两个引用类型变量保存的是同一个数组的地址值
        System.out.println(Arrays.toString(a));
    }

    private static void f1() {
        //1.准备数组
        int[] a = {1, 2, 3, 4, 5};
        //2.倒着输出
        //i:下标 从哪开始a.length-1  到哪结束0  如何变化--
        for (int i = a.length - 1; i >= 0; i--) {
            //3.把当前遍历到的元素输出
            System.out.println(a[i]);
        }
    }
}

练习题 : 进制的前缀

package cn.tedu.basic;
/*本类用于测试类型的前缀*/
public class TestTypePre {
    public static void main(String[] args) {
        //10-2 10-1  10-0
        System.out.println(100);//100-10的平方
        //操作二进制-0b
        //2-2 2-1 2-0
        System.out.println(0b100);//4-2的平方
        //操作八进制
        //8-2 8-1 8-0
        System.out.println(0100);//64-8的平方
        //操作十六进制
        //16-2 16-1 16-0
        System.out.println(0x100);//256-16的平方
    }
}

练习题 : 创建一个长度随机，内容随机的整形数组,并对这个数组进行升序排序

package cn.cxy.exec;

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

public class TestMethod {
    public static void main(String[] args) {
        //传入一个随机数组，进行排序，然后将排好序的数组返回
        //1.用来生成一个随机数组
        int[] a = createArray();
        System.out.println(Arrays.toString(a));
        //2.传入刚刚生成的随机数组，排序，将排序后的数组返回
        int[] b = sortArray(a);
        System.out.println(Arrays.toString(b));
    }
    public static int[] sortArray(int[] a){
        //需要对传入的数组进行排序
        Arrays.sort(a);
        return a;
    }
    //修饰符 返回值类型 方法名(参数列表){方法体}
    public static int[] createArray(){
        //生成一个随机数组，并将结果返回
        //1.动态创建一个长度随机的数组
        //int length = new Random().nextInt(10);//[0,10)
        int length = new Random().nextInt(5)+5;//[0,5)->[0+5,5+5)->[5,10)
        int[] a = new int[length];//数组的长度是生成的随机长度length
        /**数组长度可以为0*/
        //2.遍历数组，依次向数组中的每个位置存入随机值
        for(int i = 0;i<=a.length-1;i++) {
            a[i] = new Random().nextInt(100);
        }
        return a;
    }
}

练习题 : 创建一个长度随机，内容随机的整形数组,并对这个数组进行降序排序

package cn.cxy.exec;

import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
public class TestMethod {
    public static void main(String[] args) {
        //传入一个随机数组，进行排序，然后将排好序的数组返回
        //1.用来生成一个随机数组
        Integer[] a = createArray();
        System.out.println(Arrays.toString(a));
        //2.传入刚刚生成的随机数组，排序，将排序后的数组返回
        Integer[] b = sortArray(a);
        System.out.println(Arrays.toString(b));
    }
    public static Integer[] sortArray(Integer[] a){
        //需要对传入的数组进行排序
        //Arrays.sort(a);
        Arrays.sort(a,Collections.reverseOrder());
        return a;
    }
    //修饰符 返回值类型 方法名(参数列表){方法体}
    public static Integer[] createArray(){
        //生成一个随机数组，并将结果返回
        //1.动态创建一个长度随机的数组
        //int length = new Random().nextInt(10);//[0,10)
        int length = new Random().nextInt(5)+5;//[0,5)->[0+5,5+5)->[5,10)
        Integer[] a = new Integer[length];//数组的长度是生成的随机长度length
        /**数组长度可以为0*/
        //2.遍历数组，依次向数组中的每个位置存入随机值
        for(int i = 0;i<=a.length-1;i++) {
            a[i] = new Random().nextInt(100);
        }
        return a;
    }
}

练习题 : 完成减肥计划案例1

使用嵌套分支完成练习
接收用户输入的星期数，提示用户今天的减肥安排
星期一：跳绳
星期二：跑步
星期三：瑜伽
星期四: 普拉提
星期五：打网球
星期六：游泳
星期日：休息日不运动

package cn.cxy.exec;

import java.util.Scanner;

/*本类用于完成减肥计划，使用嵌套分支完成练习
接收用户输入的星期数，提示用户今天的减肥安排
 * 星期一：跳绳
 * 星期二：跑步
 * 星期三：瑜伽
 * 星期四: 普拉提
 * 星期五：打网球
 * 星期六：游泳
 * 星期日：休息日不运动 */
public class ReduceWeight {
    public static void main(String[] args) {
        //1.提示并接收用户输入的星期数
        System.out.println("请输入今天的星期数：(1~7)");
        int day = new Scanner(System.in).nextInt();
        //2.对用户输入的数据进行合理性判断
        if (day < 1 || day > 7) {
            System.out.println("您输入的天数有误哦~请重新输入~");
        }else{//输入正确的数据才会进一步判断
            if(day == 1){
                System.out.println("今天周一，该去跳绳啦！");
            }else if(day == 2){
                System.out.println("今天周二，该去跑步啦！");
            }else if(day == 3){
                System.out.println("今天周三，该去做瑜伽啦！");
            }else if(day == 4){
                System.out.println("今天周四，该去做普拉提啦！");
            }else if(day == 5){
                System.out.println("今天周五，该去打网球啦！");
            }else if(day == 6){
                System.out.println("今天周六，该去游泳啦！");
            }else if(day == 7){
                System.out.println("今天周日，休息日，休息一天吧！");
            }
        }
    }

}

练习题 : 完成减肥计划案例2

使用选择结构完成练习
接收用户输入的星期数，提示用户今天的减肥安排
星期一：跳绳
星期二：跑步
星期三：瑜伽
星期四: 普拉提
星期五：打网球
星期六：游泳
星期日：休息日不运动

package cn.cxy.exec;

import java.util.Scanner;

/*本类用于完成减肥计划，使用选择结构完成练习
接收用户输入的星期数，提示用户今天的减肥安排
 * 星期一：跳绳
 * 星期二：跑步
 * 星期三：瑜伽
 * 星期四: 普拉提
 * 星期五：打网球
 * 星期六：游泳
 * 星期日：休息日不运动 */
public class ReduceWeight2 {
    public static void main(String[] args) {
        //1.提示并接收用户输入的星期数
        System.out.println("请输入今天的星期数：(1~7)");
        int day = new Scanner(System.in).nextInt();
        //2.对用户输入的星期数做判断
        switch (day){
            case 1 : System.out.println("今天周一，该去跳绳啦！");break;
            case 2 : System.out.println("今天周二，该去跑步啦！");break;
            case 3 : System.out.println("今天周三，该去做瑜伽啦！");break;
            case 4 : System.out.println("今天周四，该去做普拉提啦！");break;
            case 5 : System.out.println("今天周五，该去打网球啦！");break;
            case 6 : System.out.println("今天周六，该去游泳啦！");break;
            case 7 : System.out.println("今天周日，休息日，休息一天吧！");break;
            //如果都没有匹配到，说明用户输入的数据不合理
            default: System.out.println("您输入的天数有误哦~请重新输入~");
        }
    }
}

练习题 : 实现一个简易的计算器

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));
	}

}

练习题 : 方法的重载练习

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

package cn.tedu.method;
/*本类用于测试方法的重载
* 如果在同一个类中，存在多个同名方法，但参数列表不同的现象
* 作用：重载使我们的代码更灵活，传入不同的参数，都可以有对应的方法被调用
* 方法是否构成重载，与方法参数的类型有关，与方法参数的名字无关
* 前提：同一个类中，同名的方法
* 1.方法的参数个数不同：一定构成重载
* 2.方法的参数个数相同：就需要查看对应位置上参数的类型*/
public class TestMethod1 {
    public static void main(String[] args) {
       //f1();
       int result = sum(1,2);
       System.out.println(result);
       double result2 = sum(5.5,1.1);
       System.out.println(result2);
       double result3 = sum(8.8,1);
       System.out.println(result3);
       double result4 = sum(7,2.2);
       System.out.println(result4);
    }
    //1.方法一：传入两个int类型的参数，并返回这两个数的和，方法名为sum
    public static int sum(int a,int b){
        //return a+b;
        int c = a+b;
        return c;
    }
    //2.方法二：传入两个double类型的参数，并返回这两个数的和，方法名为sum
    public static double sum(double aa,double bb){
//        double cc = aa + bb;
//        return cc;
        return aa+bb;
    }
    //3.方法三：传入一个double类型的参数，一个int类型的参数，并返回这两个数的和，方法名为sum
    public static double sum(double a,int b){
        return a+b;
    }
    //4.方法四：传入一个int类型的参数，一个double类型的参数，并返回这两个数的和，方法名为sum
    public static double sum(int a,double b){
        return a+b;
    }

    private static void f1() {
        //演示重载的现象
        System.out.println("HelloWorld");
        System.out.println(1);
        System.out.println(4.5);
        System.out.println('a');
        System.out.println(true);
    }
}

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

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

package cn.cxy.exec;

public class TestDog {
    public static void main(String[] args) {
        //6.1创建Dog类的第1个对象并进行测试,触发的是无参构造
        Dog d1 = new Dog();//我是Dog类的无参构造
        //d1.age = 7;//不能用这种方式，因为age被封装了，会报错 
        d1.run();
        d1.eat();
        //6.2创建Dog类的第2个对象并进行测试,触发的是含参构造
        Dog d2 = new Dog(100);//我是Dog类的含参构造100
        System.out.println(d2.getName());//null
        d2.sleep();
        d2.play();
        //6.3创建Dog类的第3个对象并进行测试，触发的是全参构造
        Dog d3 = new Dog("旺财",6,"柴犬","黄飞鸿",388.8);//我是Dog类的全参构造
        /*打印的都是我们通过全参构造给对象属性设置的值*/
        System.out.println(d3.getName());//旺财
        System.out.println(d3.getAge());//6
        System.out.println(d3.getHost());//黄飞鸿
        System.out.println(d3.getKind());//柴犬
        System.out.println(d3.getPrice());//旺财
        d3.eat();
        d3.sleep();
    }
}
//1.定义Dog类
class Dog{
    //2.定义Dog类的属性
    //3.1封装所有属性
    private String name;//姓名
    private int age;//年龄
    private String kind;//品种
    private String host;//主人
    private double price;//价格

    //4.1提供本类的无参构造
    public Dog(){
        System.out.println("我是Dog类的无参构造");
    }
    //4.2提供本类的含参构造
    public Dog(int n){
        System.out.println("我是Dog类的含参构造"+n);
    }
    //4.3提供本类的全参构造
    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;
        System.out.println("我是Dog类的全参构造");
    }

    //5.1提供Dog自己的跑的功能
    public void run(){
        System.out.println("小狗狗跑的老快了~");
    }
    //5.2提供Dog自己的吃的功能
    public void eat(){
        System.out.println("小狗爱吃肉骨头");
    }
    //5.3提供Dog自己的睡觉的功能
    public void sleep(){
        System.out.println("小狗一天睡几个小时来着？");
    }
    //5.4提供Dog自己的玩的功能
    public void play(){
        System.out.println("小狗爱玩飞盘~");
    }

    //3.2提供所有的get与set方法
    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;
    }
}

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

测试类TestCat

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

吃eat:参数int n,无返回值,打印:小猫Cat今晚要吃n根肉骨头

跳jump:参数String name,无返回值,打印:小猫name跳的老高啦~

睡觉sleep:参数String name,double num无返回值,打印:小猫name今天一共睡了num个小时

玩play: 参数String host,返回值String"逗猫棒",打印:小猫与主人host玩的很开心

叫bark:打印:小猫喜欢喵喵叫,此方法要封装,玩的时候才叫

完成业务:每当创建小猫类的对象,就在控制台打印:又有一只可爱的小猫咪粗来啦~
完成测试:

1)创建小猫类的对象c1,使用无参构造创建
并调用set()给c1赋值:叮当 300 机器猫大雄 10000
赋值后使用get()查看是否赋值成功
2)使用全参构造创建小猫类对象c2,赋值:罗小黑 7 变异猫未知 800
赋值后使用get()查看是否赋值成功
3)创建小猫类的对象c3,通过c3对象调用小猫类的功能*5

package cn.tedu.oop;

public class TestCat {
    public static void main(String[] args) {
        //6.1使用无参构造创建对象
        Cat c1 = new Cat();
        //6.2通过set()给对象的属性赋值
        c1.setName("叮当");
        c1.setAge(300);
        c1.setHost("大雄");
        c1.setKind("机器猫");
        c1.setPrice(10000);
        //6.3通过get()查看对象的属性值
        System.out.println(c1.getName());
        System.out.println(c1.getHost());
        System.out.println(c1.getAge());
        System.out.println(c1.getPrice());
        System.out.println(c1.getKind());

        //7.1使用全参构造创建对象,并同时给对象的所有属性赋值
        Cat c2 = new Cat("罗小黑",7,"变异猫","未知",800);
        //7.2查看对象的赋值是否成功
        System.out.println(c2.getName());
        System.out.println(c2.getHost());
        System.out.println(c2.getAge());
        System.out.println(c2.getPrice());
        System.out.println(c2.getKind());

        //8.1创建小猫类的对象
        Cat c3 = new Cat();
        //8.2通过创建好的小猫对象调用小猫类的功能
        c3.eat(8);
        c3.sleep("罗小白",9.9);
        c3.jump("花花");
        c3.play("苏大强");//只调用玩的功能,不接收返回值
        String n = c3.play("哈哈哈");//再次调用play(),选择接收返回值
        System.out.println(n);//把接到的玩具"逗猫棒"打印出来
    }
}
//1.定义小猫类
class Cat{
    //2.1提供所有属性并进行封装
    private String name;//名字
    private int age;//年龄
    private String kind;//品种
    private String host;//主人
    private double price;//价格

    //5.创建构造代码块,提取所有构造方法的共性功能
    {
        System.out.println("又有一只可爱的小猫咪粗来啦~");
    }

    //3.提供本类的无参与全参构造
    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("全参构造");
    }

    //4.提供小猫类的功能
    //4.1睡觉sleep:参数String name,double num,无返回值,打印:小猫name今天一共睡了num个小时
    public void sleep(String name,double num){
        System.out.println("小猫"+name+"今天一共睡了"+num+"个小时");
    }
    //4.2玩play: 参数String host,返回值String"逗猫棒",打印:小猫与主人host玩的很开心
    public String play(String host){
        System.out.println("小猫与主人"+host+"玩的很开心");
        bark();//此处调用被封装的方法
        return "逗猫棒";
    }
    //4.3叫bark:打印:小猫喜欢喵喵叫,此方法要封装,玩的时候才叫
    private void bark(){
        System.out.println("小猫喜欢喵喵叫");
    }

    //4.4吃eat:参数int n,无返回值,打印:小猫Cat今晚要吃n根肉骨头
    public void eat(int n){
        System.out.println("小猫Cat今晚要吃"+n+"根肉骨头");
    }
    //4.5跳jump:参数String name,无返回值,打印:小猫name跳的老高啦~
    public void jump(String name){
        System.out.println("小猫"+name+"跳的老高啦~");
    }

    //2.2给被封装的属性提供get与set方法
    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;
    }
}

练习题 : 面向对象练习：实现学生类

需求：创建学生类，按照上述步骤进行测试
学生的属性：学号姓名性别住址科目
学生的功能：学习吃饭睡觉查看本类类型与所有属性和属性值

创建学生类Student

package cn.tedu.oop;
/*本类用于描述学生这一类事物*/
public class Student {
    //1.1定义学生的属性
    //1.2 封装学生的属性
    private int id;//学号
    private String name;//姓名
    private char gender;//性别
    private String address;//住址
    private String subject;//科目

    //2.1提供本类的无参构造
    public Student(){
        System.out.println("我是Student的无参构造");
    }
    //2.2提供本类的全参构造
    //右键->Generate->Contructor->Shift全选所有属性->OK
    public Student(int id, String name, char gender, String address, String subject) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.address = address;
        this.subject = subject;
        System.out.println("我是Student的全参构造");
    }
    //3.1提供本类的普通方法1
    public void study(){
        System.out.println("学习使我快乐~");
    }
    //3.2提供本类的普通方法2
    public void eat(int n){
        System.out.println("今天我要干它"+n+"碗大米饭");
    }
    //3.3提供本类的普通方法3
    public String sleep(){
        return "今天又睡了美美的一觉";
    }
    //4.提供本类的一个展示类型与所有属性和属性值的方法
    public void show(){
        System.out.println("Student:[id="+id+",name="+name+",gender="+gender+",address="+address+",subject="+subject+"]");
    }

    //1.3提供属性对应的get与set方法
    //右键->Generate->Getter and setter->Shift全选所有属性->OK
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }
}

创建学生类的测试类TestStudent

package cn.tedu.oop;
/*本类用作学生类的测试类*/
public class TestStudnet {
    public static void main(String[] args) {
        //1.1使用无参构造创建对象
        Student s = new Student();
        //1.2通过setXxx()给对象的所有属性赋值
        s.setId(1);
        s.setName("林冲");
        s.setGender('男');
        s.setSubject("CGB");
        s.setAddress("庙里");
        //1.3通过对象调用方法测试
        s.study();
        s.eat(3);
        System.out.println(s.sleep());
        s.show();//Student:[id=1,name=林冲,gender=男,address=庙里,subject=CGB]

        //2.1使用全参构造创建对象
        Student s2 = new Student(2,"李逵",'男',"猪肉铺","ACT");
        s2.study();
        s2.eat(10);
        System.out.println(s2.sleep());
        s2.show();
    }
}

练习题 : 面向对象练习：设计学校开学招待设计案例

需求：
身份：老师学生学生家长
吃饭：教师食堂食堂招待所
住宿：学校公寓宿舍招待所

1.创建父接口，描述人这一类事物

package cn.tedu.review;

//1.定义一个接口，描述人这一类事物
public interface Person {
    //面向接口编程，设计出老师 学生 学生家长的共同行为
    //好处：方便接口的实现类实现时统一标准，而且更加灵活

    //2.设计出共同的功能
    void eat();
    void sleep();
}

2.创建老师类

package cn.tedu.review;

//3.定义一个老师类实现Person接口
public class Teacher implements Person{
    //4.添加Person接口中未实现的方法，并按照老师的功能来实现
    @Override
    public void eat() {
        System.out.println("老师在教师食堂吃饭");
    }
    @Override
    public void sleep() {
        System.out.println("老师在学校公寓住宿");
    }
}

3.创建学生类

package cn.tedu.review;
//5.定义一个学生类实现Person接口
public class Student implements Person{
    //4.添加Person接口中未实现的方法，并按照学生的功能来实现
    @Override
    public void eat() {
        System.out.println("学生在学校食堂吃饭");
    }
    @Override
    public void sleep() {
        System.out.println("学生回学校宿舍睡觉");
    }
}

4.创建家长类

package cn.tedu.review;
//7.定义一个家长类实现Person接口
public class Parents implements Person{
    //8.添加Person接口中未实现的方法，并按照家长学生的功能来实现
    @Override
    public void eat() {
        System.out.println("家长在招待所的饭馆吃饭~");
    }

    @Override
    public void sleep() {
        System.out.println("家长会招待所休息~");
    }
}

5.创建测试类

package cn.tedu.review;
/*本类用来测试学校开学招待案例*/
//9.创建测试类
public class TestPerson {
    public static void main(String[] args) {
        //10.在main()中创建3个类的对象
        Teacher t = new Teacher();
        Student s = new Student();
        Parents p = new Parents();
        //11.通过对象使用功能
        t.eat();
        t.sleep();
        s.eat();
        s.sleep();
        p.eat();
        p.sleep();
    }
}

练习题 : 面向对象练习：设置小动物类，包含会飞的动物鸟类昆虫

前提：如果有两个及两个以上的类拥有相同的方法，但是实现的功能不同
就可以向上形成一个接口，这样每次实现类就可以直接添加接口中未实现的方法
需求：

鸟与昆虫具有飞行的共同功能，就可以定义一个父接口FlyAnimal，描述飞行
定义父类小鸟类Bird : 腿的数量为2 ，下蛋数量可以自定义，还有下蛋的功能
定义父类昆虫类Insect : 腿的数量为6，产卵的数量可以自定义，还有产卵的功能
定义子级鸽子类Pigeon：它既会飞，也会下蛋
定义子级燕子类Swallow：它既会飞，也会下蛋,还有自己的特有功能筑巢
定义子级蚂蚁类Ant：它既会飞，也会产卵
定义子级蜜蜂类Bee：它既会飞，也会产卵,还有自己的特有功能制作蜂蜜

1. 创建父级接口FlyAnimal

/*定义一个接口，描述动物会飞这一功能*/
//1.定义父接口，并定义接口中飞行的功能
public interface FlyAnimal {
    void fly();
}

2.创建父级抽象类Bird小鸟类

package cn.cxy.exec;

//5.定义抽象父类-小鸟类
abstract public class Bird {
    //6.1 定义小鸟类中腿的数量为：2
    int legNumbers = 2;
    //6.2 定义小鸟类中产卵的成员变量，没有默认值
    int eggNumber;

    //7.定义小鸟类中下蛋的功能
    public abstract void layEggs();
}

3.创建父级抽象类Insect昆虫类

package cn.cxy.exec;

//2.定义抽象父类-定义昆虫类
abstract public class Insect {
    //3.1 定义昆虫类中腿的数量为：6
    int legNumbers = 6;
    //3.2 定义昆虫类中产卵的成员变量，没有默认值
    int eggNumber;

    //4.定义昆虫类中产卵的功能
    public abstract void spawn();
}

4.创建子级鸽子类Pigeon：它既会飞，也会下蛋

package cn.cxy.exec;
//10.定义鸽子类-子实现类
public class Pigeon extends Bird implements FlyAnimal{
    @Override//这是父抽象类中的抽象方法
    public void layEggs() {
        System.out.println("鸽子的下蛋数为："+eggNumber);
    }

    @Override//这是父接口中的抽象方法
    public void fly() {
        System.out.println("鸽子要飞啦");
    }
}

5.创建子级燕子类Swallow：它既会飞，也会下蛋,还有自己的特有功能筑巢

package cn.cxy.exec;
//11.定义燕子类-子实现类
public class Swallow extends Bird implements FlyAnimal{
    @Override//这是父抽象类中的抽象方法
    public void layEggs() {
        System.out.println("燕子的下蛋数为："+eggNumber);
    }

    @Override//这是父接口中的抽象方法
    public void fly() {
        System.out.println("燕子归巢~");
    }

    public void makeNest(){//这是子类的特有功能
        System.out.println("燕子在筑巢~");
    }
}

6.定义子级蚂蚁类Ant：它既会飞，也会产卵

package cn.cxy.exec;
//8.定义蚂蚁类-子实现类
public class Ant extends Insect implements FlyAnimal{
    //9.添加父级中未实现的方法
    @Override
    public void fly() {//这是父接口中的抽象方法
        System.out.println("蚂蚁飞啦~");
    }
    @Override
    public void spawn() {//这是父抽象类中的抽象方法
        System.out.println("蚂蚁的产卵数为："+eggNumber);
    }
}

7. 定义子级蜜蜂类Bee：它既会飞，也会产卵,还有自己的特有功能制作蜂蜜

package cn.cxy.exec;
//12.定义蚂蚁类-子实现类
public class Bee extends Insect implements FlyAnimal{
    //添加父级中未实现的方法
    @Override
    public void fly() {//这是父接口中的抽象方法
        System.out.println("蜜蜂飞啦~");
    }
    @Override
    public void spawn() {//这是父抽象类中的抽象方法
        System.out.println("蜜蜂的产卵数为："+eggNumber);
    }
    public void makeHoney(){//这是子类的特有功能
        System.out.println("蜜蜂在产蜂蜜~");
    }
}

8.创建测试类TestAnimals测试所有的子类

package cn.cxy.exec;
/*本类用作动物设计案例的测试类*/
public class TestAnimals {
    public static void main(String[] args) {
        System.out.println("*********我在测试蚂蚁类**********");
        //1.1创建蚂蚁类对象
        Ant a = new Ant();
        //1.2设置产卵的数量
        a.eggNumber = 300;
        //1.3查看腿的条数--父类中的默认值，没有修改，直接获取
        System.out.println("蚂蚁的腿有"+a.legNumbers+"条");
        //1.4 调用实现后的功能 飞行 产卵
        a.fly();
        a.spawn();
        System.out.println("*********我在测试鸽子类**********");
        //2.1创建鸽子类对象
        Pigeon p = new Pigeon();
        //2.2设置下蛋的数量
        p.eggNumber = 3;
        //2.3查看腿的条数--父类中的默认值，没有修改，直接获取
        System.out.println("鸽子的腿有"+p.legNumbers+"条");
        //2.4 调用实现后的功能 飞行 下蛋
        p.fly();
        p.layEggs();
        System.out.println("*********我在测试燕子类**********");
        //3.1创建燕子类对象
        Swallow s = new Swallow();
        //3.2设置下蛋的数量
        s.eggNumber = 6;
        //3.3查看腿的条数--父类中的默认值，没有修改，直接获取
        System.out.println("燕子的腿有"+s.legNumbers+"条");
        //3.4 调用实现后的功能 飞行 下蛋
        s.fly();
        s.layEggs();
        //3.5调用子类的特有功能--筑巢
        s.makeNest();
        System.out.println("*********我在测试蜜蜂类**********");
        //4.1创建蜜蜂类对象
        Bee b = new Bee();
        //4.2设置产卵的数量
        b.eggNumber = 600;
        //4.3查看腿的条数--父类中的默认值，没有修改，直接获取
        System.out.println("蜜蜂的腿有"+b.legNumbers+"条");
        //4.4 调用实现后的功能 飞行 产卵
        b.fly();
        b.spawn();
        //4.5调用子类的特有功能--产蜂蜜
        b.makeHoney();
    }
}

最终的执行效果：
JAVA练习500题2帖超详细带答案持续更新中~

练习题 : 实现二分法查找/折半查找

注意：折半查找的前提：数据必须是有序的

package cn.cxy.exec;

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

public class BinarySearch {
   public static void main(String[] args) {
      //从方法，获取一个乱序数组
      int[] a = suiJi();
      //对a数组排序
      Arrays.sort(a);//优化的快速排序
      System.out.println(Arrays.toString(a));
      while(true) {
         System.out.print("查找的目标值：");
         int t = new Scanner(System.in).nextInt();
         //二分法查找，
         //从a数组中，查找t的位置
         int index = binarySearch(a, t);
         System.out.println(index);
      }
   }

   private static int[] suiJi() {
      //随机产生5+ [0,6)范围整数n
      int n = 5+ new Random().nextInt(6);
      //新建int[]数组，长度n
      //再存到变量a
      int[] a = new int[n];
      //遍历数组，填入100内随机整数
      for (int i = 0; i < a.length; i++) {
         a[i] = new Random().nextInt(100);
      }
      //返回数组a
      return a;
   }

   private static int binarySearch(int[] a, int t) {
      /*
       * t = 36
       *              mid
       * [16, 21, 30, 36, 39, 70, 70, 92]
       *  lo
       *                              hi
       * *) lo和hi关系 lo<=hi
       * *) 交叉就是找不到数据
       * *) lo位置是插入点位置
       *
       * *)定义三个下标值
       *   lo=0, hi=a.length-1
       *   mid 只定义先不赋值
       * *)循环，当lo<=hi
       *     *)计算中间下表存到 mid
       *     *)如果a[mid]<t，lo定位到mid+1
       *     *)否则如果a[mid]>t，hi定义到mid-1
       *     *)否则，返回mid的值
       * *)lo、hi交叉结束
       *   返回 -(lo+1)，表示-(插入点+1)
       */
      int lo = 0;
      int hi = a.length-1;
      int mid;
      while(lo <= hi) {
         mid = (lo+hi) / 2;
         if(a[mid] < t) {
            lo = mid+1;
         } else if(a[mid] > t) {
            hi = mid-1;
         } else {
            return mid;
         }
      }
      //避免lo是0，加1后，再加负号
      return -(lo+1); // -(插入点+1)
   }
}

练习题 : 二分法实现数据动态插入

注意：折半查找的前提：数据必须是有序的

package cn.cxy.exec;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
import java.util.Scanner;

public class BinaryInsert {
	public static void main(String[] args) {
		/*
		 * 集合、泛型，都不支持基本类型
		 * 用基本类型的包装类
		 */
		ArrayList<Integer> list = new ArrayList<>();
		System.out.println("回车继续");
		while(true) {
			new Scanner(System.in).nextLine();
			int n = new Random().nextInt(100);
			//二分法查找，在list中找n所在的位置
			//找不到，返回 -(插入点+1)
			int index = Collections.binarySearch(list, n);  
			if(index < 0) {
				index = (-index)-1;
			}
			list.add(index, n);
			System.out.println(list.toString());
		}
	}
}

练习题 : 求数字阶乘(递归解法版)

需求:接收用户输入的数字,计算该数字的阶乘结果
已知:负数不可以有阶乘,0的阶乘结果是1,
5 ! = 5 x 4 x 3 x 2 x 1

package cn.cxy.design;
//需求:求用户输入数字的阶乘结果
//f(int n)--用来求阶乘
//规律：
//f(n)= n*f(n-1)
//f(5)= 5*4*3*2*1 = 5*f(4) 
//f(4)= 4*3*2*1 = 4*f(3)
//f(3)= 3*2*1 = 3*f(2)
//f(2)= 2*1 = 2*f(1)
//f(1)= 1
//
//5!=5*4*3*2*1=120
//4!=4*3*2*1
//3!=3*2*1
//2!=2*1
//1!=1

public class TestRecursion {
	public static void main(String[] args) {
		int result = f(15);//调用f()用来求阶乘
		System.out.println(result);
	}
	/**递归的两要素 1.总结规律 2.最简问题*/
	public static int f(int n) {
		if(n == 1) {//最简问题
			return 1;
		}else {//其他情况 n*f(n-1)
			//递归:再方法内部自己调用自己
			return n*f(n-1);
		}
	}
}

JAVA练习500题2帖超详细带答案持续更新中~

练习题 : 递归求目录总大小

需求:递归求目录的总大小 D:\ready,步骤分析如下:
1.列出文件夹中的所有资源–listFiles()–>File[]
2.判断,当前资源是文件还是文件夹–文件夹大小为0,文件大小需要累加
–是文件,求文件的字节量大小length(),累加就行
–是文件夹,继续列出文件夹下的所有资源–listFiles()–>File[]
–判断,是文件,求文件的字节量大小length(),累加就行
–判断,是文件夹,再一次列出文件夹下的所有资源
–…重复操作
也就是说,规律就是:只要是文件夹,就需要重复步骤1 2

package cn.cxy.file;

import java.io.File;

/**本类用来递归求目录总大小*/
public class FileSumRecursion {
	public static void main(String[] args) {
		//1.指定要求哪个目录的总大小
		/**注意:此处指定的目录必须是真实存在的
		 * 如果传一个不存在的文件夹会报错,如果是传了一个空文件夹,大小为0*/
		File file = new File("D:\\ready");
		//2.调用size()求目录大小
		long total = size(file);
		//3.接收结果并打印
		System.out.println("文件夹的总大小为:"+total);
	}

	private static long size(File file) {
		//1.列出文件夹中的所有资源--listFiles()-->File[]
		File[] fs = file.listFiles();
		
		//2.遍历数组,获取每file对象
		//2.1定义变量,记录总和
		long sum = 0;
		for(int i = 0;i < fs.length ; i++) {
			//2.2通过下标操作当前遍历到的资源
			File f = fs[i];
			//2.3判断,当前资源是文件还是文件夹--文件夹大小为0,文件大小需要累加
			if(f.isFile()) {
				//--是文件,求文件的字节量大小length(),累加就行
				sum += f.length();//相当于:sum = sum + f.length();
			}else if(f.isDirectory()) {
				//--是文件夹,继续列出文件夹下的所有资源,1 2步骤--listFiles()-->File[]
				/**方法的递归,递归现象,就是在方法的内部调用方法自身*/
				sum += size(f);
			}
		}
		return sum;//把sum记录的值返回调用位置
	}
}

练习题 : 递归删除文件夹

需求:递归删除文件夹 D:\ready\a
1.列出文件夹下的所有资源listFiles()
2.判断,当前资源是文件还是文件夹
–判断,是文件,直接删除delete()
–判断,是文件夹,继续重复操作1 2
具体思路可以分为这么几步:
1.首先,我们需要指定一个根目录作为要删除的对象
2.列出文件夹下的所有资源listFiles(),并进行遍历
3.判断当前的资源,如果是文件,直接删除;如果是文件夹,则执行步骤2
4.将文件夹中的内容删除完毕后,删除文件夹本身

package cn.tedu.file;

import java.io.File;

/**本类用于递归删除目录*/
public class TestFileDeleteRecursion {
	public static void main(String[] args) {
		//1.指定要删除的目录
		/**为了更好的测试,注意指定的目录是已存在的目录,但是,千万不要删盘符!!!!*/
		/*我们也有一些没有权限的文件夹,那个是无法访问且不能删除的哦*/
		File file = new File("D:\\ready\\a");
		//2.调用删除目录的方法
		boolean result = del(file);
		//3.打印删除的结果
		System.out.println("删除的结果为:"+result);
	}

	public static boolean del(File file) {//完成的同学不是很多,抓紧时间写,写完截图发群里哈,这首歌结束我们继续
		//1.列出文件夹下的所有资源
		File[] fs = file.listFiles();
		//2.循环遍历拿到的所有资源
		for (int i = 0; i < fs.length; i++) {
			//2.1获取本次循环遍历到的file对象
			File f = fs[i];
			//3.判断,当前资源是文件还是文件夹
			if(f.isFile()) {
				f.delete();//是文件,直接删除
				System.out.println(file.getName()+"文件删除成功!");
			}else if(f.isDirectory()) {
				//是文件夹,需要继续进行步骤1 2 ,出现了重复调用的情况
				//递归,在方法的内部调用自己
				del(f);
			}
		}
		//位置:在for循环执行之外删除文件夹
		file.delete();//空文件夹直接删除
		System.out.println(file.getName()+"文件夹删除成功!");
		return true;
	}
}

练习题 : 复制文件(字节流批量读取)

需求:接收用户目标文件的路径,复制目标文件到指定路径

import java.io.*;
import java.util.Scanner;

public class TestCopyFiles {
    public static void main(String[] args) {
        //1.提示并接收用户输入的要复制的源文件路径--复制啥
        System.out.println("请输入源文件路径:");
        String f = new Scanner(System.in).nextLine();

        //2.提示并接收用户输入的目标文件所在的位置--复制到哪
        System.out.println("请输入目标文件的路径:");
        String t = new Scanner(System.in).nextLine();

        //3.1根据源文件路径封装from文件对象
        File from = new File(f);
        //3.2根据目标文件路径封装to文件对象
        File to = new File(t);
        //3.3根据用户提供的路径完成文件的复制操作
        copy(from,to);
    }

    public static void copy(File from, File to) {
        InputStream in = null;//定义在整个方法中都生效的字节输入流对象,注意是局部变量,需要初始化,对象的默认值是null
        OutputStream out = null;//定义在整个方法中都生效的字节输出流对象,注意是局部变量,需要初始化,对象的默认值是null
        try {
            //1.读取from文件--操作文件的是字节输入流
            in = new BufferedInputStream(new FileInputStream(from));
            //2.写出到to文件--操作文件的是字节输出流
            out = new BufferedOutputStream(new FileOutputStream(to));

            //3.边读边写
            int b = 0;//定义变量b,记录读取到的数据
            /**需求:想要实现批量读取,使用的是read(byte[] b)重载的形式,可以按照数组的方式来读 */
            /**可以自定义数组,长度建议与源码保持一致,8*1024 = 8192*/
            byte[] bs = new byte[8*1024];
            while( (b=in.read(bs)) != -1 ) {//只有没有数据时,才返回-1,跳出循环,读写结束
                out.write(bs);//将读到的数据写出到文件
            }
            System.out.println("恭喜您!文件复制成功!");
        } catch (IOException e) {
            System.out.println("很抱歉!文件复制失败!");
            e.printStackTrace();//打印错误信息
        }finally {
            //释放资源
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

练习题 : 逆序遍历List集合

手写一个程序，完成List集合对象的逆序遍历

package cn.cxy.exec;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**本类用于进一步测试List接口*/
public class TestList {
    public static void main(String[] args) {
        //1.创建List接口的多态对象
        List<String> list = new ArrayList<>();
        //2.向创建好list集合添加元素
        list.add("喜羊羊");
        list.add("美羊羊");
        list.add("懒羊羊");
        list.add("沸羊羊");
        list.add("小肥羊");
        list.add("肥羊卷");
        System.out.println(list);
        System.out.println("listIterator的逆序遍历：");
        ListIterator<String> it3 = list.listIterator();
        while(it3.hasNext()){//判断是否有下一个元素可迭代
            System.out.println(it3.next());//打印当前迭代到的元素
            if(!it3.hasNext()){//直到迭代器没有下一个元素可迭代--到最后了
                System.out.println("开始逆序迭代：");
                while (it3.hasPrevious()){//判断是否有上一个元素可迭代
                    System.out.println(it3.previous());//打印获取到的上一个元素
                }
               break;//终止循环，不然会一直从头到尾，再从尾到头迭代
            }
        }
    }

}

练习题 : 回文问题

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

import java.util.Scanner;

public class TestNumber {
    public static void main(String[] args) {
        System.out.println("请输入一个字符串:");
        String s = new Scanner(System.in).nextLine();

        if(!stringJudge(s)){
            System.out.println(s + "不是回文字符串");
        }else{
            System.out.println(s + "是回文字符串");
        }
        //调用第二个方法解决
        stringJudge2(s);
    }

    //判断字符串是否回文
    private static boolean stringJudge(String str) {
        for (int i = 0; i < str.length() - i - 1; i++){
            if(str.charAt(i) == str.charAt(str.length() - i - 1)){
                continue;
            }else{
                return false;
            }
        }

        return true;
    }
    //判断字符串是否回文2
    private static void stringJudge2(String s) {
        //方法2:将字符串反转比较
        String s2 = new StringBuffer(s).reverse().toString();
        if(s.compareTo(s2) == 0){
            System.out.println(s + "是回文字符串");
        }else{
            System.out.println(s + "不是回文字符串");
        }
    }
}

练习题 : 手写数组列表

手写一个数组列表，实现基本的数据操作功能
数组列表类：

package cn.cxy.exec;

import java.util.Arrays;

public class ShuZuLieBiao<T> {
	T[] a;
	int index;
	public ShuZuLieBiao() {
		this(10);
	}
	public ShuZuLieBiao(int length) {
		a = (T[]) new Object[length];
	}
	public void add(T t) {
		//确认容量
		queRenRongLiang();
		a[index] = t;
		index++;
	}
	private void queRenRongLiang() {
		//还有位置
		if(index<a.length) {
			return;
		}
		//容量增长1.5倍
		//防止初始长度是0，再加两个位置
		int n = a.length + a.length/2 + 2;
		a = Arrays.copyOf(a, n);
	}
	public T get(int i) {
		jianChaFanWei(i);
		return a[i];
	}
	private void jianChaFanWei(int i) {
		//检查下标范围
		if(i<0 || i>=index) {
			//抛出一个异常，表示这里出错
			throw new IndexOutOfBoundsException(
					"下标："+i);
		}
	}
	public int size() {
		return index;
	}
	public T remove(int i) {
		jianChaFanWei(i);//检查范围
		T t = a[i];//取出i位置的值
		/* [i+1, index) 范围的值，向前复制1位
		 *      i
		 * [1,2,4,5,6,-,-,-,-,-,-]
		 *            |
		 *            index
		 */
		System.arraycopy(a, i+1, a, i, index-i-1); 
		a[index-1] = null;
		index--;
		return t; //返回被移除的值
	}
}

测试类：

package cn.cxy.exec;
public class TestSZLB {
	public static void main(String[] args) {
		//泛型，不支持基本类型
		ShuZuLieBiao<String> lb = new ShuZuLieBiao<>();
		lb.add("aaa");
		lb.add("vvv");
		lb.add("ggg");
		lb.add("rrr");
		lb.add("qqq");
		lb.add("uuu");
		lb.add("aaa");
		System.out.println(lb.size());
		System.out.println(lb.get(0));
		System.out.println(lb.get(lb.size()-1));
		System.out.println(lb.remove(4));
		for(int i=0;i<lb.size();i++) {
			System.out.println(lb.get(i));
		}
	}
}

练习题 : 文件复制案例

需求：接收用户输入的两个路径，将这两个路径代表的两个文件的内容同时复制到第3个文件中
如：将1.txt与2.txt里的内容按顺序同时复制到3.txt中
JAVA练习500题2帖超详细带答案持续更新中~

package cn.cxy.exec;

import java.io.*;
import java.util.Scanner;

/*本类用于练习IO流文件复制综合案例*/
public class Demo {
    public static void main(String[] args) {
        //1.提示并接收用户输入的两个路径
        System.out.println("请输入源文件的路径1:");
        String f1 = new Scanner(System.in).nextLine();//被复制的那个文件
        System.out.println("请输入源文件的路径2:");
        String f2 = new Scanner(System.in).nextLine();//被复制的那个文件
        System.out.println("请输入新文件的路径:");
        String t = new Scanner(System.in).nextLine();//复制好的新文件
        //2.调用创建好的自定义方法,完成文件的复制
        ZJCopy(f1,f2,t);//使用字节流完成复制的操作
    }

    //使用字节流完成文件复制的操作
    private static void ZJCopy(String f1,String f2, String t) {
        //1.定义两个在本方法中都生效的字节流局部变量,注意初始化值为null
        BufferedInputStream in1 = null;//高效字节输入流,用于读取
        BufferedInputStream in2 = null;//高效字节输入流,用于读取
        BufferedOutputStream out = null;//高效字节输出流,用于写出
        //2.由于IO操作可能会发生异常,所以需要完成try-catch-finally结构
        try{
            //3.1创建一个高效字节输入流对象,用于读取源文件
            in1 = new BufferedInputStream(new FileInputStream(f1));
            in2 = new BufferedInputStream(new FileInputStream(f2));
            //3.2创建一个高效字节输出流对象,用于向新文件输出数据
            out = new BufferedOutputStream(new FileOutputStream(t,true));


            //4.使用两个流对象完成复制操作
            int b;
            while((b=in1.read())!=-1){
                out.write(b);
            }
            int b2;
            while((b2=in2.read())!=-1){
                out.write(b2);
            }
            System.out.println("恭喜!复制成功!");
        }catch (IOException e){
            System.out.println("复制失败!");
            e.printStackTrace();
        }finally {
            //5.关流
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in2.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

练习题 : 面向对象:学生专业与成绩管理

编写学生类Student

包含属性:sno学号 name姓名 gender性别 major专业 totalScore总成绩

编写专业类Major

包含属性:totalScore总成绩 englishScore英文成绩 midScore期中成绩 finalScore期末成绩

编写三个不同的子专业类继承专业类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

1. 创建学生类

package cn.tedu.oop;
//1.定义学生类
public class Student{
    //2.定义学生类的属性
    int sno;//学号
    String name;//姓名
    char gender;//性别
    Major major;//专业
    double totalScore;//总成绩

    //3.提供本类的全参构造,注意分数需要调用Major类的getScore()获取
    public Student(int sno, String name, char gender, Major major, double totalScore) {
        this.sno = sno;
        this.name = name;
        this.gender = gender;
        this.major = major;
        this.totalScore = major.getScore();
    }

    //4.重写toString()方法,方便直接查看学生类的所有属性值
    @Override
    public String toString() {
        return "学号:" + sno +
                ", 姓名:'" + name + '\'' +
                ", 性别:" + gender +
                ", 专业:" + major +
                ", 总成绩:" + totalScore;
    }
}

2. 创建专业类

package cn.tedu.oop;
//5.创建专业类,注意这个是一个父类,下属还有3个子类代表3个不同的具体专业
public class Major {
    //6.定义专业类的属性
    double totalScore;//总成绩
    double englishScore;//英文成绩
    double midScore;//期中成绩
    double finalScore;//期末成绩

    //7.提供本类的全参构造,注意总成绩需要计算得出,不在本构造方法里
    public Major(double englishScore, double midScore, double finalScore) {
        this.englishScore = englishScore;
        this.midScore = midScore;
        this.finalScore = finalScore;
    }

    //8.创建一个计算获取成绩的方法
    //由于这个方法一定会被子类重写,所以方法里没有具体计算成绩的业务
    public double getScore(){
        return totalScore;
    }
}

3. 创建计算机专业类

package cn.tedu.oop;
//9.创建计算机专业类,继承专业类
public class ComputerMajor extends Major {
    //10.添加子类独有的属性:编程课成绩
    double programmingScore;

    //11.生成子类自己的全参构造
    public ComputerMajor(double programmingScore,double englishScore, double midScore, double finalScore) {
        //这里是在调用父类的构造方法,因为英文 期中 期末 成绩都是在父类那里赋值的
        super(englishScore, midScore, finalScore);
        //在子类的构造方法中只需要给子类的特有属性专业课成绩赋值即可
        this.programmingScore = programmingScore;
    }

    //12.子类重写父类的getScore(),具体实现总分数的计算
    @Override
    public double getScore(){
        //计算逻辑:总成绩=专业课成绩40%+英文课成绩10%+期中成绩15%+期末成绩35%
        totalScore = programmingScore*0.4+englishScore*0.1+midScore*0.15+finalScore*0.35;
        //返回计算好的成绩
        return totalScore;
    }

    //13.重写toString()方法,方便直接查看专业类的所有属性值
    @Override
    public String toString() {
        return "计算机专业{" +
                "编程课成绩:" + programmingScore +
                ",英文课成绩:" + englishScore +
                ",期中成绩:" + midScore +
                ",期末成绩:" + finalScore +
                '}';
    }
}

4. 创建文学专业类

package cn.tedu.oop;
//14.创建计算机专业类,继承专业类
public class ChineseMajor extends Major {
    //15.添加子类独有的属性:写作课成绩
    double writingScore;

    //16.生成子类自己的全参构造
    public ChineseMajor(double writingScore,double englishScore, double midScore, double finalScore) {
        //这里是在调用父类的构造方法,因为英文 期中 期末 成绩都是在父类那里赋值的
        super(englishScore, midScore, finalScore);
        //在子类的构造方法中只需要给子类的特有属性专业课成绩赋值即可
        this.writingScore = writingScore;
    }

    //17.子类重写父类的getScore(),具体实现总分数的计算
    @Override
    public double getScore(){
        //计算逻辑:总成绩=专业课成绩40%+英文课成绩10%+期中成绩15%+期末成绩35%
        totalScore = writingScore*0.4+englishScore*0.1+midScore*0.15+finalScore*0.35;
        //返回计算好的成绩
        return totalScore;
    }

    //18.重写toString()方法,方便直接查看专业类的所有属性值
    @Override
    public String toString() {
        return "文学专业{" +
                "写作课成绩:" + writingScore +
                ",英文课成绩:" + englishScore +
                ",期中成绩:" + midScore +
                ",期末成绩:" + finalScore +
                '}';
    }
}

5. 创建数学专业类

package cn.tedu.oop;
//19.创建数学专业类,继承专业类
public class MathematicsMajor extends Major {
    //20.添加子类独有的属性:数学理论课成绩
    double mathScore;

    //21.生成子类自己的全参构造
    public MathematicsMajor(double mathScore, double englishScore, double midScore, double finalScore) {
        //这里是在调用父类的构造方法,因为英文 期中 期末 成绩都是在父类那里赋值的
        super(englishScore, midScore, finalScore);
        //在子类的构造方法中只需要给子类的特有属性专业课成绩赋值即可
        this.mathScore = mathScore;
    }

    //22.子类重写父类的getScore(),具体实现总分数的计算
    @Override
    public double getScore(){
        //计算逻辑:总成绩=专业课成绩40%+英文课成绩10%+期中成绩15%+期末成绩35%
        totalScore = mathScore*0.4+englishScore*0.1+midScore*0.15+finalScore*0.35;
        //返回计算好的成绩
        return totalScore;
    }

    //23.重写toString()方法,方便直接查看专业类的所有属性值
    @Override
    public String toString() {
        return "数学专业{" +
                "数学理论课成绩:" + mathScore +
                ",英文课成绩:" + englishScore +
                ",期中成绩:" + midScore +
                ",期末成绩:" + finalScore +
                '}';
    }
}

6. 创建测试类

package cn.tedu.oop;

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

//24.创建测试类
//业务:输入学生的个人信息与各项成绩,随机生成学生的专业,并将输入的5个学生信息输出到控制台
public class TestStudent {
    public static void main(String[] args) {
        //25.创建一个长度为5的学生数组,用于存放学生对象
        Student[] stu = new Student[5];
        //26.循环5次,接收并打印学生的数据
        for (int i = 0; i < 5; i++) {
            //27.提示并接收学生的个人信息:姓名 性别
            System.out.println("请输入第"+(i+1)+"个学生的个人信息:");
            System.out.println("姓名:");
            String name  = new Scanner(System.in).nextLine();
            System.out.println("性别");
            char gender = new Scanner(System.in).nextLine().charAt(0);
            //28.提示并接收学生的成绩:
            System.out.println("请输入第"+(i+1)+"个学生的成绩:");
            //29.成绩与专业是chooseMajor()执行的
            Major major = chooseMajor();
            //30.调用getScore()方法获取不同专业的学生的总成绩
            double score = major.getScore();
            //31.通过收集到的信息,利用学生类的全参构造创建学生对象,并将学生对象存入student数组中
            stu[i] = new Student(i+1,name,gender,major,score);
            //32.打印当前存入的学生对象与学生对象的各项信息
            System.out.println(stu[i]);
        }
        //System.out.println(Arrays.toString(stu));//也可以循环结束整体打印数组中的所有元素
    }

    //本方法用于接收学生的各项成绩,并随机选择该学生的专业
    private static Major chooseMajor() {
        //1.提示并接收学生的各项成绩:
        System.out.println("请输入专业课成绩:");
        double ProfessionalScore = new Scanner(System.in).nextDouble();
        System.out.println("请输入英文课成绩:");
        double englishScore = new Scanner(System.in).nextDouble();
        System.out.println("请输入期中成绩:");
        double midScore = new Scanner(System.in).nextDouble();
        System.out.println("请输入期末成绩:");
        double finalScore = new Scanner(System.in).nextDouble();
        //2.创建引用类型变量major代表变量,局部变量手动赋予默认值null
        Major major = null;
        //3.生成随机数,随机数的取值:[0,3)->0,1,2
        int r = new Random().nextInt(3);
        //4.利用选择结构,根据生成的随机数不同,创建不同的专业对象
        switch (r){
            case 0: major = new ComputerMajor(ProfessionalScore,englishScore,midScore,finalScore);break;
            case 1: major = new ChineseMajor(ProfessionalScore,englishScore,midScore,finalScore);break;
            case 2: major = new MathematicsMajor(ProfessionalScore,englishScore,midScore,finalScore);break;
        }
        //5.将创建好的专业对象返回
        return major;
    }
}