JAVA基础练习题

1.计算平均数、最小数、最大数、排序

1.1 题目一(数组遍历)

1.1.1 需求

/* 定义一个表示学生信息的类Student，要求如下：
  （1）类Student的成员变量：
       sNO 表示学号；sName表示姓名；sSex表示性别；sAge表示年龄；sJava：表示Java课程成绩。
  （2）类Student带参数的构造方法：
       在构造方法中通过形参完成对成员变量的赋值操作。
  （3）类Student的方法成员：
       getNo（）：获得学号；
       getName（）：获得姓名；
       getSex（）：获得性别；
       getAge（）获得年龄；
       getJava（）：获得Java 课程成绩
       根据类Student的*/
       /*定义，创建五个该类的对象，输出每个学生的信息，
       计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。*/

思想：将学生信息存入学生数组，再进行遍历

1.1.2 代码

public class Demo01 {
    public static void main(String[] args) {

        // 创建五个学生对象
        Student student1 = new Student("001", "张三", "男", 20, 85.5);
        Student student2 = new Student("002", "李四", "女", 19, 90.0);
        Student student3 = new Student("003", "王五", "男", 21, 78.5);
        Student student4 = new Student("004", "赵六", "女", 22, 88.0);
        Student student5 = new Student("005", "孙七", "男", 20, 92.5);

        // 将学生对象放入数组中
        Student[] students = {student1, student2, student3, student4, student5};

        // 输出每个学生的信息
        for (Student student : students) {
            System.out.println("学号: " + student.getNo() +
                    ", 姓名: " + student.getName() +
                    ", 性别: " + student.getSex() +
                    ", 年龄: " + student.getAge() +
                    ", Java成绩: " + student.getJava());
        }

        // 计算并输出Java成绩的平均值
        double totalJavaScore = 0;
        for (Student student : students) {
            totalJavaScore += student.getJava();
        }
        double averageJavaScore = totalJavaScore / students.length;
        System.out.println("Java成绩的平均值: " + averageJavaScore);

        // 计算并输出Java成绩的最大值和最小值
        double maxJavaScore = students[0].getJava();
        double minJavaScore = students[0].getJava();
        for (Student student : students) {
            if (student.getJava() > maxJavaScore) {
                maxJavaScore = student.getJava();
            }
            if (student.getJava() < minJavaScore) {
                minJavaScore = student.getJava();
            }
        }
        System.out.println("Java成绩的最大值: " + maxJavaScore);
        System.out.println("Java成绩的最小值: " + minJavaScore);
    }
}

package com.lhx.demo1;

/**
 * @author 林汉鑫
 * @version: 1.0
 * @Date: 2024/10/30 13:31
 */
public class Student {
    // 成员变量
    private String sNO;    // 学号
    private String sName;  // 姓名
    private String sSex;   // 性别
    private int sAge;      // 年龄
    private double sJava;  // Java 课程成绩

    // 带参数的构造方法
    public Student(String sNO, String sName, String sSex, int sAge, double sJava) {
        this.sNO = sNO;
        this.sName = sName;
        this.sSex = sSex;
        this.sAge = sAge;
        this.sJava = sJava;
    }

    // 方法成员
    public String getNo() {
        return sNO;
    }

    public String getName() {
        return sName;
    }

    public String getSex() {
        return sSex;
    }

    public int getAge() {
        return sAge;
    }

    public double getJava() {
        return sJava;
    }
}

1.2 题目二(冒泡排序，三元表达)

1.2.1 需求

/*定义一个数组，并对数组进行初始化 int[] a={45,76,33,78,46,49,34,80,63,52}，
求数组中的最大值，最小值，平均值，从大到小排序，并输出*/

技术：用到冒泡排序，三元表达式

1.2.2 代码

public class Demo01 {
    public static void main(String[] args) {
        
        int[] a = {11,78,46,49,34,80,63,52};
        int sum = 0;
        int item = 0;

        /*最大值和最小值*/
        int max = a[0];
        int min = a[0];
        for (int i = 1; i < a.length; i++) {
//            if(a[i] > max){
//                max = a[i];
//            }
            max = a[i] > max ? a[i] : max;
            min = a[i] < min ? a[i] : min;
        }

        System.out.println("最大值:" + max);
        System.out.println("最小值:" + min);

        /*平均值*/
        for (int i = 0; i < a.length; i++) {
            sum += a[0];
        }
        System.out.println("平均值:" + sum/a.length);

        /*从大到小排序(冒泡排序)*/
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if(a[j] < a[j + 1]){
                    item = a[j];
                    a[j] = a[j+1];
                    a[j + 1] = item;
                }
            }
        }
        System.out.println("从大到小的排序:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

1.3 题目三(计算阶乘)

1.3.1 需求

/*计算 1! + 2! + 3! + 4! + 5!*/

1.3.2 代码

利用循环遍历

public class Demo02 {
    public static void main(String[] args) {
        int sum = 0;

//      3! = 1*2*3
        for (int i = 1; i <= 5; i++) {
            int factorial = 1;
            for (int j = 1; j <= i; j++) {
                factorial *= j;
            }
            sum += factorial;
        }

        // 输出结果
        System.out.println("1! + 2! + 3! + 4! + 5! 的值为: " + sum);
    }
}

利用方法计算阶乘

/*利用方法计算阶乘*/
public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += demo03.factorial(i);
        }
        // 输出结果
        System.out.println("1! + 2! + 3! + 4! + 5! 的值为: " + sum);
    }

    public int factorial(int num){
        if (num < 0){
            throw new RuntimeException("计算阶乘的数不能小于0");
        }

        if(num == 0 || num == 1){
            return 1;
        }else{
            return num * factorial(num - 1);
        }
    }
}

1.4 题目四(Switch、Scanner)

1.4.1 需求

/* 2、设计一个应用程序，实现从键盘输入出一个0－100的整数。用switch语句结构实现以下功能：若这个数属于：
 0－60（不含60）输出：不及格
 60－70（不含70）输出：及格
 70－80（不含80）输出：一般
 80－90（不含90）输出：良好
 90－100 输出：优秀*/

1.4.2 代码

public class Demo04 {
    public static void main(String[] args) {
       /* 2、设计一个应用程序，实现从键盘输入出一个0－100的整数。用switch语句结构实现以下功能：若这个数属于：
        0－60（不含60）输出：不及格
        60－70（不含70）输出：及格
        70－80（不含80）输出：一般
        80－90（不含90）输出：良好
        90－100 输出：优秀*/
       while (true){
           System.out.println("请输入1-100的整数:");
           Scanner scanner = new Scanner(System.in);
           int grade = scanner.nextInt();
           int sum = grade / 10;
           switch (sum){
               case 1:
               case 2:
               case 3:
               case 4:
               case 5:
                   System.out.println("成绩不及格");
                   break;
               case 6:
                   System.out.println("成绩及格");
                   break;
               case 7:
                   System.out.println("成绩一般");
                   break;
               case 8:
                   System.out.println("成绩良好");
                   break;
               case 9:
               case 10:
                   System.out.println("成绩优秀");
                   break;
               default:
                   System.out.println("你输入的数不合法");
                   break;
           }
       }

    }
}

2.打印直角三角形、等腰三角形、菱形等

3.计算几何图形的周长和面积

3.1 题目一(多态、接口式编程)

3.1.1 需求

/*题目：长方形和圆形都属于几何图形，都有周长和面积，并且它们都有自己的周长和面积计算公式。
使用抽象类的知识设计一个程序，可以计算不同图形的面积和周长：
（1）定义父类Shape作为抽象类，并在类中定义抽象方法求周长和面积。
（2）定义Shape子类圆形(circle)，具有半径属性和常量PI，同时必须实现父类中的抽象方法。
（3）定义Shape子类长方形(rectangle)，具有长和宽的属性，同时必须实现父类的抽象方法。
（4）创建图形面积周长计算器(ShapeCalculate)，具有计算不同图形面积和周长的方法。
（5）创建测试类TestShape类，在其main()方法中对ShapeCalculate计算面积和周长方法进行测试。*/

3.1.2 代码

shape抽象类

abstract class Shape {
    // 抽象方法，用于计算周长
    public abstract double girth();

    // 抽象方法，用于计算面积
    public abstract double area();
}

circle子类

public class Circle extends Shape {
//    （2）定义Shape子类圆形(circle)，具有半径属性和常量PI，同时必须实现父类中的抽象方法。
//    半径
    private double radius;
//    常量 PI
    private final static double PI = 3.14159;

//    构造函数
    public Circle(double radius) {
        this.radius = radius;
    }


    public double girth() {
        return 2 * PI * radius;
    }

    @Override
    public double area() {
        return PI * radius * radius;
    }
}

rectangle子类

public class Rectangle extends Shape{
//    （3）定义Shape子类长方形(rectangle)，具有长和宽的属性，同时必须实现父类的抽象方法。
//    长
    private double length;
//    宽
    private double wide;

//    构造函数
    public Rectangle(double length, double wide) {
        this.length = length;
        this.wide = wide;
    }

    @Override
    public double girth() {
        return 2 * (length + wide);
    }

    @Override
    public double area() {
        return length * wide;
    }
}

ShapeCalculate类

public class ShapeCalculate {
    /*创建图形面积周长计算器*/

    // 计算不同图形的面积
    public static void calculateArea(Shape shape) {
        System.out.println("面积: " + shape.area());
    }

    // 计算不同图形的周长
    public static void calculateGirth(Shape shape) {
        System.out.println("周长: " + shape.girth());
    }
}

TestShape类

public class TestShape {
    public static void main(String[] args) {
        // 创建一个圆形对象，半径为5
        Circle circle = new Circle(5);

        // 创建一个长方形对象，长为4，宽为6
        Rectangle rectangle = new Rectangle(4, 6);

        // 测试圆形的面积和周长
        System.out.println("计算圆形的面积和周长：");
//        circle就是new Circle(5);涉及多态
        ShapeCalculate.calculateArea(circle);
        ShapeCalculate.calculateGirth(circle);

        // 测试长方形的面积和周长
//        rectangle就是new Rectangle(4, 6);涉及多态
        System.out.println("\n计算长方形的面积和周长：");
        ShapeCalculate.calculateArea(rectangle);
        ShapeCalculate.calculateGirth(rectangle);

    }
}