Java课程实验（上）

实验二

（1）把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包 含数字 2 和 4，一共有多少种不同的分解方法？ 注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。

（2）请实现从键盘输入10个数字，然后使用选择排序、冒泡排序、插入排序实现数字排序，并输出。

（3）一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 个。 注意在计算时，只算本质不同的串的个数。 请问，字符串0100110001010001 有多少个不同的非空子串？

package java实验2;
public class First {
    public static void main(String args[]) {
        //计算三数之和为2019
        int ans = 0;
        for(int i = 1;i <= 2019/2;i++) {
            if(juge(i)==0) continue;
            for(int j = i+1;j<=2019;j++) {
                if(juge(j)==0) continue;
                for(int k = j+1;k<=2019;k++) {
                    if(juge(k)==0) continue;
                    if(i+j+k == 2019) {
                        ans++;
                    }
                }
            }
        }
        System.out.println(ans);
    }
    public static int juge(int x) {
        //1表示此数不包含2或者4，0表示包含
        int flag = 1;
        while(x>0) {
            if (x % 10 == 2 || x % 10 == 4) {
                flag = 0;
                break;
            }
            else {
                x /= 10;
            }
        }
        return flag;
    }
}

package java实验2;
import java.util.Scanner;
public class Second {
    public static void main(String args[]) {
        Scanner reader = new Scanner(System.in);
        int [] numbers = new int[10];
        for (int i = 0;i<numbers.length;i++) {
            numbers[i] = reader.nextInt();
        }
        int [] numbers2 = numbers; //复制两个数组
        int [] numbers3 = numbers; 
        //冒泡
        for(int i = 0;i < numbers.length ;i++ ) {
            for (int j=0;j<numbers.length - 1;j++) {
                if(numbers[j]>numbers[j+1]) {
                    int temp;
                    temp = numbers[j+1];
                    numbers[j+1] = numbers[j];
                    numbers[j] = temp;
                }
            }
        }
        //插入
         for (int i = 1; i < numbers2.length; i++) {
                int key = numbers[i];
                int j = i - 1;
                // 将大于key的元素向后移动一位
                while (j >= 0 && numbers[j] > key) {
                    numbers[j + 1] = numbers[j];
                    j = j - 1;
                }
                numbers[j + 1] = key; // 将key插入到正确的位置
            }
        // 选择
            for (int i = 0; i < numbers3.length - 1; i++) {
                // 寻找[i, end]区间内的最小值
                int minIndex = i;
                for (int j = i + 1; j < numbers.length; j++) {
                    if (numbers[j] < numbers[minIndex]) {
                        minIndex = j; // 更新最小值的索引
                    }
                }
                // 将找到的最小值和第i位置所在的值交换
                if (minIndex != i) {
                    int temp = numbers[i];
                    numbers[i] = numbers[minIndex];
                    numbers[minIndex] = temp;
                }
            }
        System.out.println("冒泡排序结果为：");
        for (int number : numbers) {
            System.out.print(number+" ");
        }
        System.out.println();
        System.out.println("插入排序结果为：");
        for (int number : numbers2) {
            System.out.print(number+" ");
        }
        System.out.println();
        System.out.println("选择排序结果为：");
        for (int number : numbers3) {
            System.out.print(number+" ");
        }
    }
}

package java实验2;
import java.util.HashSet;
public class Third {
    public static void main(String[] args) {
        String str = "0100110001010001";
        int count = countDistinctSubstrings(str);
        System.out.println("字符串" + str + "有" + count + "个不同的非空子串");
    }
    public static int countDistinctSubstrings(String str) {
        HashSet<String> set = new HashSet<>();
        int length = str.length();
        // 遍历所有可能的子串
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j <= length; j++) {
                String substring = str.substring(i, j);
                set.add(substring);
            }
        }
        return set.size();
    }
}

实验三

（1）已知复数类Complex：

   float real;代表实部

   float imag;代表虚部

   Complex();空构造方法

   Complex(float,float);带参构造方法

   Complex  Add(float);

   Complex  Add(Complex com);

   Complex  Sub(float);

   Complex  Sub(Complex com);

   Complex  Mul(float);

   Complex Mul(Complex com);

   String  toString();把当前复数，按照a+bi的形式进行打印

要求：

     写测试类test，测试自定义的Complex类各方法的功能正确性，并打印出各自运算结果

（2）在一村庄中有一口井well,每天产水100升，村庄中有n户人家family（n<20），每户人家用水同户序号同，比如第i户人家每天用水i升（i<n），以此类推，每户人家取水顺序为随机，请编写代码实现该村的取水情况。        

已知有Well类, Family类及测试test类，将各类完善，并打印出取水顺序。

package java实验3;
public class First {
    public static void main(String args[]){
        Complex A = new Complex(3,4); //复数1
        Complex B = new Complex(5,6); //复数2
        float c = 7; //浮点数
        test t1 = new test(A,c);
        test t2 = new test(A,B);
    }
}
class test{
    private Complex A,B;
    private float a;
    test (Complex a,float b){ //实际上在构造函数里面做计算不建议
        //给一个复数和一个浮点数
        this.A = a;
        this.a = b;
        System.out.println("原始数据：");
        System.out.println("复数：" + this.A + "  " + "浮点数：" + this.a);
        System.out.println("相加：" + this.A.Add(this.a));
        System.out.println("相减：" + this.A.Sub(this.a));
        System.out.println("相乘：" + this.A.Mul(this.a));
    }
    test (Complex a, Complex b){
        this.A = a;
        this.B = b;
        System.out.println("原始数据：");
        System.out.println("复数1：" + this.A + "  " + "复数2：" + this.B);
        System.out.println("相加：" + this.A.Add(this.B));
        System.out.println("相减：" + this.A.Sub(this.B));
        System.out.println("相乘：" + this.A.Mul(this.B));
    }
}
class Complex {
    private float real; //实部
    private float imag; //虚部
    Complex(){};
    Complex(float a, float b){
        this.real = a;
        this.imag = b;
    }
    public Complex Add(float a){
        float new_real = this.real + a;
        return new Complex(new_real,this.imag);
    }
    public Complex Add(Complex com) {
        float a = com.real;
        float b = com.imag;
        float new_real = this.real + a;
        float new_imag = this.imag + b;
        return new Complex(new_real,new_imag);
    }
    public Complex Sub(float a) {
        float new_real = this.real - a;
        return new Complex(new_real,this.imag);
    }
    public Complex Sub(Complex com) {
        float a = com.real;
        float b = com.imag;
        float new_real = this.real - a;
        float new_imag = this.imag - b;
        return new Complex(new_real,new_imag);
    }
    public Complex Mul(float a) {
        float new_real = this.real * a;
        float new_imag = this.imag * a;
        return new Complex(new_real,new_imag);
    }
    public Complex Mul(Complex com) {
        float a = com.real;
        float b = com.imag;
        float new_real = this.real * a - this.imag * b;
        float new_imag = this.real * b + this.imag * a;
        return new Complex(new_real,new_imag);
    }
    @Override
    public String toString() {
        return this.real + " + " + this.imag + "i";
    }
}

package java实验3;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class Well {
    private int waterAmount;
    public Well(int waterAmount) {
        this.waterAmount = waterAmount;
    }
    public void takeWater(int amount) {
        if (waterAmount >= amount) {
            waterAmount -= amount;
            System.out.println("取水 " + amount + " 升，剩余水量: " + waterAmount + " 升");
        } else {
            System.out.println("水量不足，取水失败");
        }
    }
}
class Family {
    public int id;
    private int waterUsage;
    public Family(int id, int waterUsage) {
        this.id = id;
        this.waterUsage = waterUsage;
    }
    public void takeWater(Well well) {
        System.out.println("家庭 " + id + " 开始取水 " + waterUsage + " 升");
        well.takeWater(waterUsage);
    }
}
public class Second {
    public static void main(String[] args) {
        int n = 18; // 村庄中的家庭数量
        int wellWater = 100; // 井的水量
        Well well = new Well(wellWater);
        List<Family> families = new ArrayList<>();
        // 创建家庭并添加到列表中
        for (int i = 1; i <= n; i++) {
            families.add(new Family(i, i));
        }
        // 随机打乱取水顺序
        Collections.shuffle(families);
        // 打印取水顺序并按顺序进行取水操作
        System.out.println("取水顺序:");
        for (Family family : families) {
            System.out.println("家庭"+family.id);
        }
        for (Family family : families) {
            family.takeWater(well);
        }
    }
}

 实验四

（1)：

交通工具有多种多样，比如：汽车、火车、飞机等，一般的交通工具类的属性有：厂商，发动机型号，制作型号，时间；方法有：运行（输出速度），停止。

1）请使用抽象方法实现交通工具类和方法：实现汽车、火车、飞机类，继承于交通工具类，实现他们不同的运行方法。

2）Tom在出门去，不知道会乘坐什么交通工具，利用用户的输入值进行随机派遣（mod 3 ,根据余数随机决定交通工具），要求程序利用上转型对象完成编程。

（2）：

已知公司company有员工30人，分三类：WeekWorker每周580￥,MonthWorker月薪每月2500，YearWorker年薪每年12000。、

已知有Employee抽象类，有抽象方法earning()用于计算Employee一年的收入。有conmpany类，Employee[]存放公司员工，salariesPay方法计算并打印公司的所有一年薪水之处。

     编写test类，company，employee, WeekWorker,MonthWorker,YearWorker，假定公司三类员工各自的数量用随机数来模拟，打印某公司一年的薪水支出。

package java实验4;
import java.util.Scanner;
// 抽象交通工具类
abstract class Vehicle {
    protected String manufacturer; //生产商
    protected String engineModel;  //发动机型号
    protected String modelNumber;  //制作型号
    protected String productionDate;  //生产日期
    public Vehicle(String manufacturer, String engineModel, String modelNumber, String productionDate) {
        this.manufacturer = manufacturer;
        this.engineModel = engineModel;
        this.modelNumber = modelNumber;
        this.productionDate = productionDate;
    }
    // 抽象运行方法
    public abstract void run();
    // 停止方法
    public void stop() {
        System.out.println("交通工具已停止。");
    }
}
// 汽车类
class Car extends Vehicle {
    public Car(String manufacturer, String engineModel, String modelNumber, String productionDate) {
        super(manufacturer, engineModel, modelNumber, productionDate);
    }
    @Override
    public void run() {
        System.out.println("汽车正在以60km/h的速度行驶。");
    }
}
// 火车类
class Train extends Vehicle {
    public Train(String manufacturer, String engineModel, String modelNumber, String productionDate) {
        super(manufacturer, engineModel, modelNumber, productionDate);
    }
    @Override
    public void run() {
        System.out.println("火车正在以120km/h的速度行驶。");
    }
}
// 飞机类
class Airplane extends Vehicle {
    public Airplane(String manufacturer, String engineModel, String modelNumber, String productionDate) {
        super(manufacturer, engineModel, modelNumber, productionDate);
    }
    @Override
    public void run() {
        System.out.println("飞机正在以800km/h的速度飞行。");
    }
}
public class First {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数（0汽车，1火车，2飞机）: ");
        int input = scanner.nextInt();
        scanner.close();
        Vehicle vehicle;
        int randomNumber = input % 3;
        switch (randomNumber) {
            case 0:
                vehicle = new Car("生产商：Honda", "发动机型号：V6", "生产商：Accord", "型号：2022-01-01");
                break;
            case 1:
                vehicle = new Train("生产商：Siemens", "发动机型号：Electric", "生产商：ICE", "型号：2021-05-15");
                break;
            case 2:
                vehicle = new Airplane("生产商：Boeing", "发动机型号：Jet", "生产商：747", "型号：2020-10-20");
                break;
            default:
                System.out.println("无效的输入!");
                return;
        }
        vehicle.run();
        vehicle.stop();
    }
}

package java实验4;
import java.util.Random;
abstract class Employee {
    abstract double earning();
}
class WeekWorker extends Employee {
    @Override
    double earning() {
        return 580 * 52; // 每周580元,一年52周
    }
}
class MonthWorker extends Employee {
    @Override
    double earning() {
        return 2500 * 12; // 每月2500元,一年12个月
    }
}
class YearWorker extends Employee {
    @Override
    double earning() {
        return 12000; // 年薪12000元
    }
}
class Company {
    Employee[] employees = new Employee[30];
    Random random = new Random();
    Company() {
        long seed = 0; // 设置随机种子为0
        random.setSeed(seed);
        int weekWorkerCount = random.nextInt(30); // 周薪员工人数随机
        int monthWorkerCount = random.nextInt(30 - weekWorkerCount); // 月薪员工人数随机
        int yearWorkerCount = 30 - weekWorkerCount - monthWorkerCount; // 年薪员工人数
        for (int i = 0; i < weekWorkerCount; i++) {
            employees[i] = new WeekWorker();
        }
        for (int i = weekWorkerCount; i < weekWorkerCount + monthWorkerCount; i++) {
            employees[i] = new MonthWorker();
        }
        for (int i = weekWorkerCount + monthWorkerCount; i < 30; i++) {
            employees[i] = new YearWorker();
        }
    }
    double salariesPay() {
        double totalSalary = 0;
        for (Employee employee : employees) {
            totalSalary += employee.earning();
        }
        return totalSalary;
    }
}
public class Second {
    public static void main(String[] args) {
        Company company = new Company();
        double totalSalary = company.salariesPay();
        System.out.println("公司一年的薪水支出为: " + totalSalary + " 元");
    }
}

实验五

（1)：

已知游戏中常见人物状态State，包括站立（Idle），行走（Run），攻击(Attack)，死亡(Dead)。在游戏中有角色hero类，拥有人物状态同时还拥有血量，攻击力，防御力等属性,有怪物类Monster,怪物有血量，攻击力，防御力，怪物类型等属性。

      已知角色可以变身为怪物，现在test类中，模拟某个角色在正常情况下以及在变身状态下的各种状态操作。

     要求，使用接口及接口变量的引用实现。

（2)

利用java实现二维数组的查找

       已知：一个二维数组m*n，每一行按照从左到右递增的顺序排序，每列按照从上到下递增排序，完成test类输入一个数组及一个数，Martix类构造出该二维数组，实现boolean  Find（double）方法判定该二维数组是否含有该数，要求使用的时间复杂度最小。

package java实验5;
// 定义人物状态接口
interface State {
    void action();
}
// 实现不同状态
class IdleState implements State {
    @Override
    public void action() {
        System.out.println("站立状态");
    }
}
class RunState implements State {
    @Override
    public void action() {
        System.out.println("行走状态");
    }
}
class AttackState implements State {
    @Override
    public void action() {
        System.out.println("攻击状态");
    }
}
class DeadState implements State {
    @Override
    public void action() {
        System.out.println("死亡状态");
    }
}
// 英雄类
class Hero {
    private State state;
    private int hp, attack, defense;
    public Hero(int hp, int attack, int defense) {
        this.hp = hp;
        this.attack = attack;
        this.defense = defense;
        this.state = new IdleState(); // 初始状态为站立
    }
    public void changeState(State newState) {
        this.state = newState;
    }
    public void performAction() {
        state.action();
    }
    // 变身为怪物
    public Monster transformToMonster() {
        return new Monster(this.hp, this.attack, this.defense, "变身怪物");
    }
}
// 怪物类
class Monster {
    private State state;
    private int hp, attack, defense;
    private String type;
    public Monster(int hp, int attack, int defense, String type) {
        this.hp = hp;
        this.attack = attack;
        this.defense = defense;
        this.type = type;
        this.state = new IdleState(); // 初始状态为站立
    }
    public void changeState(State newState) {
        this.state = newState;
    }
    public void performAction() {
        state.action();
    }
}
public class First {
    public static void main(String[] args) {
        Hero hero = new Hero(100, 20, 10); //100血，20攻击力，10防御力
        System.out.println("英雄初始状态:");
        hero.performAction();
        // 切换英雄状态
        hero.changeState(new RunState());
        System.out.println("英雄行走状态:");
        hero.performAction();
        hero.changeState(new AttackState());
        System.out.println("英雄攻击状态:");
        hero.performAction();
        hero.changeState(new DeadState());
        System.out.println("英雄死亡状态:");
        hero.performAction();
        // 变身为怪物
        Monster monster = hero.transformToMonster();
        System.out.println("变身后的怪物状态:");
        monster.performAction();
        monster.changeState(new RunState());
        System.out.println("怪物行走状态:");
        monster.performAction();
        monster.changeState(new AttackState());
        System.out.println("怪物攻击状态:");
        monster.performAction();
        monster.changeState(new DeadState());
        System.out.println("怪物死亡状态:");
        monster.performAction();
    }
}

package java实验5;
import java.util.Scanner;
public class Second {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("输入二维数组的行数: ");
        int m = scanner.nextInt();
        System.out.print("输入二维数组的列数: ");
        int n = scanner.nextInt();
        double[][] array = new double[m][n];
        System.out.println("输入二维数组的元素:");
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                array[i][j] = scanner.nextDouble();
            }
        }
        System.out.print("输入要查找的数: ");
        double target = scanner.nextDouble();
        scanner.close();
        Matrix matrix = new Matrix(array);
        boolean found = matrix.Find(target);
        System.out.println(found ? "找到该数" : "未找到该数");
    }
}
class Matrix {
    private double[][] array;
    public Matrix(double[][] array) {
        this.array = array;
    }
    public boolean Find(double target) {
        int m = array.length;
        int n = array[0].length;
        int row = 0;
        int col = n - 1;
        while (row < m && col >= 0) {
            if (array[row][col] == target) {
                return true;
            } else if (array[row][col] > target) {
                col--;
            } else {
                row++;
            }
        }
        return false;
    }
}

点个赞，继续更新😉