NEFU-2023-Java实验二

烟雨平生9527

已于 2023-04-01 00:14:00 修改

阅读量1.1k

点赞数 2

分类专栏： JAVA入坑文章标签： java 开发语言 jvm

于 2023-03-18 15:54:14 首次发布

本文链接：https://blog.csdn.net/qq_62377885/article/details/129637518

版权

JAVA入坑专栏收录该内容

44 篇文章 8 订阅

订阅专栏

作者的话

作业一

作业二

作者的话

大底包含了JAVA硬性规定的作业代码，并非最优解，仅供参考并会持续更新。勿要无脑copy，对自己负责。如果代码有误或者优化建议，直接相应博客下方评论或者qq找我如果对代码有理解不了的或者疑惑可以询问我，但是请确保你已经自己思考过或者查过搜索引擎（如果我原模原样搜到了资料的话我会锤你的hh）。一些语法和库的资料查询网站受个人风格影响，部分题目解题方式可能没按照教学要求，如有必要请自己按教学要求做一遍。如果可以的话，麻烦借鉴完以后给我博客来个三连啥的，这可能对我以后找工作或者其他博客的推广什么的有些帮助，感谢

作业一

1. (程序题)

定义一个表示学生信息的类Student，要求如下：

　（1）类Student的成员变量：

sNO：表示学号（String）；sName：表示姓名（String）；sJava：表示Java课程成绩（int）。

　（2）类Student带参数的构造方法：

在构造方法中通过形参完成对成员变量的赋值操作。

（3）类Student的方法成员：

getSNo（）：获得学号； setSNo（....）：设置学号；

getSName（）：获得姓名； setSName（....）：设置姓名；

getSJava（）：获得Java 课程成绩；setSJava（....）：设置java课程的成绩；

实现下面方法，从传入的学生数组中返回java成绩最高分
public static int getHigh(Student[] students) { }

（4）在mian方法中，根据类Student的定义，创建学生对象数组，并进行对象成员变量的赋值，计算并输出学生对象数组java成绩的最高分。

首先输入学生的个数，然后依次输入每个学生的学号、姓名、成绩

输出：这些学生的最高分。

例如：

4
101 zs 90
102 ls 80
103 ww 98
104 lk 92

输出：

98

	import java.util.Scanner;
 
public class Main {
    public static class Student {
        private String sNO;
        private String sName;
        private int sJava;
 
        public Student(String sNO, String sName,int sJava) {
            this.sNO = sNO;
            this.sName = sName;
            this.sJava = sJava;
        }
 
        public String getsNO() {
            return sNO;
        }
 
        public void setsNO(String sNO) {
            this.sNO = sNO;
        }
 
        public String getsName() {
            return sName;
        }
 
        public void setsName(String sName) {
            this.sName = sName;
        }
 
        public int getsJava() {
            return sJava;
        }
 
        public void setsJava(int sJava) {
            this.sJava = sJava;
        }
 
    }
    public static int getHigh(Student[] students) {
        int maxScore = 0;
        for (int i = 0; i < students.length; i++) {
            if (students[i].getsJava() > maxScore) {
                maxScore = students[i].getsJava();
            }
        }
        return maxScore;
    }
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        Student []students = new Student[n];
        for (int i = 0; i < n; i++) {
            String sNO = input.next();
            String sName = input.next();
            int sJava = input.nextInt();
            students[i] = new Student(sNO, sName, sJava);
        }
        int maxScore = getHigh(students);
        System.out.println(maxScore);
    }
}

基于C++的代码

#include <iostream>
#include <string>
using namespace std;

class Student {
private:
    string sNO;
    string sName;
    int sJava;

public:
    Student(string sNO, string sName, int sJava) {
        this->sNO = sNO;
        this->sName = sName;
        this->sJava = sJava;
    }

    Student() {
        sNO = "";
        sName = "";
        sJava = 0;
    }

    string getsNO() {
        return sNO;
    }

    void setsNO(string sNO) {
        this->sNO = sNO;
    }

    string getsName() {
        return sName;
    }

    void setsName(string sName) {
        this->sName = sName;
    }

    int getsJava() {
        return sJava;
    }

    void setsJava(int sJava) {
        this->sJava = sJava;
    }
};

int getHigh(Student students[], int n) {
    int maxScore = 0;
    for (int i = 0; i < n; i++) {
        if (students[i].getsJava() > maxScore) {
            maxScore = students[i].getsJava();
        }
    }
    return maxScore;
}

int main() {
    int n;
    cin >> n;
    Student students[n];
    for (int i = 0; i < n; i++) {
        string sNO, sName;
        int sJava;
        cin >> sNO >> sName >> sJava;
        students[i] = Student(sNO, sName, sJava);
    }
    int maxScore = getHigh(students, n);
    cout << maxScore << endl;
    return 0;
}

基于python的代码

class Student:
    def __init__(self, sNO, sName, sJava):
        self.sNO = sNO
        self.sName = sName
        self.sJava = sJava

    def getsNO(self):
        return self.sNO

    def setsNO(self, sNO):
        self.sNO = sNO

    def getsName(self):
        return self.sName

    def setsName(self, sName):
        self.sName = sName

    def getsJava(self):
        return self.sJava

    def setsJava(self, sJava):
        self.sJava = sJava


def getHigh(students):
    maxScore = 0
    for i in range(len(students)):
        if students[i].getsJava() > maxScore:
            maxScore = students[i].getsJava()
    return maxScore


n = int(input())
students = []
for i in range(n):
    sNO, sName, sJava = input().split()
    sJava = int(sJava)
    student = Student(sNO, sName, sJava)
    students.append(student)

maxScore = getHigh(students)
print(maxScore)

作业二

定义并实现一个复数类Complex，要求实现复数的加法和减法。

类拥有两个成员变量a和b，分别代表复数的实部和虚部。

类有默认构造方法（a和b的默认值为0），也有拷贝构造方法（参数为复数类对象的引用）。

另外还应该有一个Print方法打印复数，打印格式为a bi，若实部虚部都为0，则输出0。两个复数的实部、虚部在main方法中由键盘输入。

输入：

3 4 1 2（输入两个复数的实部和虚部）

输出：

4 6i（输出两个复数的和的实部和虚部）

2 2i（输出两个复数的差的实部和虚部）

注：输入和输出括号里面的是说明。

import java.util.Scanner;

public class Main {

    public static class Complex {
        private int a; // 实部
        private int b; // 虚部
        // 默认构造方法
        public Complex() {
            this.a = 0;
            this.b = 0;
        }
        // 带参构造方法
        public Complex(int a, int b) {
            this.a = a;
            this.b = b;
        }

        // 拷贝构造方法
        public Complex(Complex c) {
            this.a = c.a;
            this.b = c.b;
        }

        // 复数加法
        public Complex add(Complex c) {
           int new_a = this.a + c.a;
           int new_b = this.b + c.b;
            return new Complex(new_a, new_b);
        }

        // 复数减法
        public Complex subtract(Complex c) {
            int new_a = this.a - c.a;
            int new_b = this.b - c.b;
            return new Complex(new_a, new_b);
        }

        // 打印复数
        public void print() {
            if (this.a == 0 && this.b == 0) {
                System.out.println("0");
            } else if (this.a == 0) {
                System.out.println(this.b + "i");
            } else if (this.b == 0) {
                System.out.println(this.a);
            } else {
                System.out.println(this.a + " " + this.b + "i");
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a1 = scanner.nextInt();
        int b1 = scanner.nextInt();
        int a2 = scanner.nextInt();
        int b2 = scanner.nextInt();
        Complex c1 = new Complex(a1, b1);
        Complex c2 = new Complex(a2, b2);
        Complex c3 = c1.add(c2);
        Complex c4 = c1.subtract(c2);
        c3.print();
        c4.print();
    }
}

基于C++的代码

#include <iostream>
 
using namespace std;
 
class Complex {
private:
    double a; // 实部
    double b; // 虚部
 
public:
    // 默认构造方法
    Complex() {
        this->a = 0;
        this->b = 0;
    }
 
    // 带参构造方法
    Complex(double a, double b) {
        this->a = a;
        this->b = b;
    }
 
    // 拷贝构造方法
    Complex(const Complex& c) {
        this->a = c.a;
        this->b = c.b;
    }
 
    // 复数加法
    Complex add(Complex c) {
        double new_a = this->a + c.a;
        double new_b = this->b + c.b;
        return Complex(new_a, new_b);
    }
 
    // 复数减法
    Complex subtract(Complex c) {
        double new_a = this->a - c.a;
        double new_b = this->b - c.b;
        return Complex(new_a, new_b);
    }
 
    // 打印复数
    void print() {
        if (this->a == 0 && this->b == 0) {
            cout << "0" << endl;
        } else if (this->a == 0) {
            cout << this->b << "i" << endl;
        } else if (this->b == 0) {
            cout << this->a << endl;
        } else {
            cout << this->a << "+" << this->b << "i" << endl;
        }
    }
};
 
int main() {
    double a1, b1, a2, b2;
    cin >> a1 >> b1 >> a2 >> b2;
    Complex c1(a1, b1);
    Complex c2(a2, b2);
    Complex c3 = c1.add(c2);
    Complex c4 = c1.subtract(c2);
    c3.print();
    c4.print();
    return 0;
}

基于python的代码

class Complex:
    def __init__(self, a=0, b=0):
        self.a = a
        self.b = b

    def add(self, c):
        new_a = self.a + c.a
        new_b = self.b + c.b
        return Complex(new_a, new_b)

    def subtract(self, c):
        new_a = self.a - c.a
        new_b = self.b - c.b
        return Complex(new_a, new_b)

    def print(self):
        if self.a == 0 and self.b == 0:
            print("0")
        elif self.a == 0:
            print(str(self.b) + "i")
        elif self.b == 0:
            print(str(self.a))
        else:
            print(str(self.a) + "+" + str(self.b) + "i")


a1, b1, a2, b2 = map(float, input().split())
c1 = Complex(a1, b1)
c2 = Complex(a2, b2)
c3 = c1.add(c2)
c4 = c1.subtract(c2)
c3.print()
c4.print()

作业三

设计用户实体类User，包含用户姓名，账户余额，地址；全属性构造函数
设计商品实体类Product，包含商品名称，商品价格，全属性构造函数
*由于同一商品可购买多个，设计购买项实体类Item，包含购买商品，商品的购买数量，全属性构造函数
*设计订单实体类Order，包含本次订单的用户，购买的全部商品项，本次购买总花费(后续商品价格的改变不应对本次已购买数据产生影响)，全属性构造函数
实体类应包含属性对应的按命名约定编写的getter/setter方法

设计订单业务逻辑处理类OrderService，提供静态方法addOrder()，实现：
传入购买的用户，以及本次购买的全部购买项
当用户余额大于购买商品总花费时，创建订单，封装购买用户/购买项/总花费，并返回订单对象
当余额小于总花费时，返回空引用
此业务方法的返回类型？参数？实现具体业务逻辑

创建测试类及主函数，假设已有四类商品及单价分别如下：

Product p1 = new Product("方便面", 5.5);

Product p2 = new Product("火腿肠", 2.2);

Product p3 = new Product("矿泉水", 1.0);

Product p4 = new Product("饮料", 3.5);

输入用户姓名，账户余额，地址模拟用户，输入购买商品的种类数，再输入购买的商品名称及数量，

（提示此处根据商品名称，得到对应的商品对象。字符串的比较用String类的equals()方法）

调用订单逻辑方法测试。
当订单创建成功时，打印商品总额，用户余额，地址；当订单创建失败时，打印用户余额不足
结果保留2位小数

输入：

张三 100 nefu

2

方便面 2

矿泉水 1

输出：

购买商品总额：12.00

用户余额：100.00

地址：nefu

import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        // 创建商品
        Product p1 = new Product("方便面", 5.5);
        Product p2 = new Product("火腿肠", 2.2);
        Product p3 = new Product("矿泉水", 1.0);
        Product p4 = new Product("饮料", 3.5);

        // 创建用户
        Scanner scanner = new Scanner(System.in);
        //System.out.println("请输入用户名、余额和地址：");
        String name = scanner.next();
        double balance = scanner.nextDouble();
        String address = scanner.next();
        User user = new User(name, balance, address);

        // 创建订单
        //System.out.println("请输入商品数量：");
        int count = scanner.nextInt();
        Item[] items = new Item[count];
        double totalCost = 0;
        for (int i = 0; i < count; i++) {
            //System.out.println("请输入第" + (i+1) + "件商品的名称和数量：");
            String productName = scanner.next();
            int quantity = scanner.nextInt();
            Product product = null;
            switch (productName) {
                case "方便面":
                    product = p1;
                    break;
                case "火腿肠":
                    product = p2;
                    break;
                case "矿泉水":
                    product = p3;
                    break;
                case "饮料":
                    product = p4;
                    break;
                default:
                    System.out.println("没有该商品！");
                    i--;
                    continue;
            }
            Item item = new Item(product, quantity);
            items[i] = item;
            totalCost += product.getPrice() * quantity;
        }
        Order order = new Order(user, items, totalCost);

        // 处理订单
        if (user.getBalance() < order.getCost()) {
            System.out.println("用户余额不足");
        } else {
            //user.setBalance(user.getBalance() - order.getCost());
            System.out.println("购买商品总额：" + String.format("%.2f", order.getCost()));
            System.out.println("用户余额：" + String.format("%.2f", user.getBalance()));
            System.out.println("地址：" + user.getAddress());
        }
    }
}
// 购买项实体类
class Item {
    private Product product; // 商品对象
    private int quantity; // 商品数量

    public Item(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
    }

    public Product getProduct() {
        return product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
}

// 订单实体类
class Order {
    private User user; // 用户对象
    private Item[] items; // 购买的商品项数组
    private double cost; // 本次购买总花费

    public Order(User user, Item[] items, double cost) {
        this.user = user;
        this.items = items;
        this.cost = cost;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Item[] getItems() {
        return items;
    }

    public void setItems(Item[] items) {
        this.items = items;
    }

    public double getCost() {
        return cost;
    }

    public void setCost(double cost) {
        this.cost = cost;
    }
}

// 商品实体类
class Product {
    private String name; // 商品名称
    private double price; // 商品价格

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

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

// 用户实体类
class User {
    private String name; // 用户姓名
    private double balance; // 用户账户余额
    private String address; // 用户地址

    public User(String name, double balance, String address) {
        this.name = name;
        this.balance = balance;
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getAddress() {
        return address;
    }

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

// 订单业务逻辑处理类
class OrderService {
    private Order[] orders; // 订单数组
    private int numOfOrders; // 订单数量
    private static Scanner scanner = new Scanner(System.in); // 用于输入的 Scanner 对象

    // 构造方法
    public OrderService(int capacity) {
        orders = new Order[capacity];
        numOfOrders = 0;
    }

    // 添加订单
    public void addOrder(User user, Item[] items) {
        double cost = 0;
        for (Item item : items) {
            cost += item.getProduct().getPrice() * item.getQuantity();
        }
        if (user.getBalance() < cost) {
            System.out.println("余额不足，下单失败！");
            return;
        }
        Order order = new Order(user, items, cost);
        orders[numOfOrders++] = order;
        user.setBalance(user.getBalance() - cost);
        System.out.println("下单成功！");
    }

    // 取消订单
    public void cancelOrder(int orderId) {
        if (orderId >= numOfOrders || orderId < 0) {
            System.out.println("不存在该订单，取消失败！");
            return;
        }
        Order order = orders[orderId];
        order.getUser().setBalance(order.getUser().getBalance() + order.getCost());
        for (Item item : order.getItems()) {
            item.getProduct().setPrice(item.getProduct().getPrice() * (1 - item.getQuantity() / 10.0));
        }
        System.out.println("取消订单成功！");
    }

    // 显示所有订单
    public void showAllOrders() {
        System.out.println("所有订单如下：");
        for (int i = 0; i < numOfOrders; i++) {
            System.out.println("订单号：" + i);
            Order order = orders[i];
            System.out.println("用户：" + order.getUser().getName());
            System.out.println("收货地址：" + order.getUser().getAddress());
            System.out.println("订单详情：");
            for (Item item : order.getItems()) {
                System.out.println(item.getProduct().getName() + " x " + item.getQuantity());
            }
            System.out.println("总价：" + order.getCost());
            System.out.println("---------------------------");
        }
    }

    // 显示某个用户的所有订单
    public void showOrdersByUser(User user) {
        System.out.println("用户 " + user.getName() + " 的订单如下：");
        for (int i = 0; i < numOfOrders; i++) {
            Order order = orders[i];
            if (order.getUser() == user) {
                System.out.println("订单号：" + i);
                System.out.println("收货地址：" + order.getUser().getAddress());
                System.out.println("订单详情：");
                for (Item item : order.getItems()) {
                    System.out.println(item.getProduct().getName() + " x " + item.getQuantity());
                }
                System.out.println("总价：" + order.getCost());
                System.out.println("---------------------------");
            }
        }
    }
}

这是一个用Java编写的购物系统模拟程序。它创建了四个产品，允许用户创建一个用户对象，并基于用户的输入创建一个订单对象。订单对象包含一个条目数组，这些条目包含有关产品及其数量的信息。

该程序允许用户将商品添加到订单中，检查用户的余额是否足以支付订单，并在用户余额充足时显示总费用、用户余额和地址。

代码还包含了几个类：Product（产品）、User（用户）、Item（订单中的商品）、Order（订单）和OrderService（订单服务）。

Product类表示一个产品，包含有关其名称和价格的信息。

User类表示一个用户，包含有关用户姓名、余额和地址的信息。

Item类表示订单中的商品，包含有关产品及其数量的信息。

Order类表示一个订单，包含有关用户、订单中的商品以及订单的总费用的信息。

OrderService类包含将订单添加到订单数组中并从数组中检索订单的方法。

总的来说，该代码提供了Java中面向对象编程原则的简单示例。

烟雨平生9527

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
NEFU-2023-Java实验二

大底包含了JAVA硬性规定的作业代码，并非最优解，仅供参考并会持续更新。勿要无脑copy，对自己负责。如果代码有误或者优化建议，直接相应博客下方评论或者qq找我如果对代码有理解不了的或者疑惑可以询问我，但是请确保你已经自己思考过或者查过搜索引擎（如果我原模原样搜到了资料的话我会锤你的hh）。一些语法和库的资料查询网站受个人风格影响，部分题目解题方式可能没按照教学要求，如有必要请自己按教学要求做一遍。如果可以的话，麻烦借鉴完以后给我博客来个三连啥的，这可能对我以后找工作或者其他博客的推广什么的有些帮助，感谢
复制链接

扫一扫