面向对象大作业(自主选题)-第一次提交

最新推荐文章于 2024-10-29 18:51:42 发布
最新推荐文章于 2024-10-29 18:51:42 发布
阅读量87 收藏
点赞数
文章标签： 课程设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74023012/article/details/134359582
版权

零、我使用了什么AI工具辅助选题

无。

一、选题与前期调查。

选题：网络通信系统

用户可以在客户端进行注册账号，与他人私聊，发送离线消息，以及文件。也可以群发消息，以及安全下线。

管理员可以向所有用户进行推送消息。

二、系统功能设计

客户端：用户注册 私聊 离线消息 登录 群发 发送文件

服务端：推送消息

三、数据如何存储：文件、数据库、内存。

文件

四、界面：GUI、控制台、Web?

控制台

五、开发工具：Eclipse, NetBeans, JUnit, git, 阿里巴巴代码规约IDE插件、AI工具。

IDEA

六、包结构

服务端

客户端 

七、部分代码 

SeverConnectClientThread

package com.wwb.service;

import com.wwb.message.Message;
import com.wwb.message.MessageType;
import com.wwb.user.LodeAllUsers;
import com.wwb.user.OfflineInformationList;
import com.wwb.user.StoringFilesMap;
import com.wwb.user.User;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;

public class ServerConnectClientThread extends Thread{
    private Socket socket;
    private User user;

    public ServerConnectClientThread(Socket socket, User user) {
        this.socket = socket;
        this.user = user;
    }

    public User getUser() {
        return user;
    }

    public Socket getSocket() {
        return socket;
    }

    public void setSocket(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {

        if(OfflineInformationList.containsKey(user.getUserId())){
            ArrayList<Message> offlineInformationList = OfflineInformationList.getListByUserId(user.getUserId());
            for (Message message : offlineInformationList) {

                try {
                    ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                    objectOutputStream.writeObject(message);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        while(true) {
            try {

                if(StoringFilesMap.getStoringFilesMap().containsKey(user.getUserId())){
                    ArrayList<Message> fileList = StoringFilesMap.getFileList(user.getUserId());
                    for (Message message1 : fileList) {
                        try {
                            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                            objectOutputStream.writeObject(message1);
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }

                ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
                Message message = (Message) objectInputStream.readObject();

                //测试
                System.out.println(message.getMesType());
                //获取当前在线用户列表
                if (message.getMesType().equals(MessageType.MESSAGE_ALL_ONLINE_USERS)) {
                    System.out.println("用户：" + user.getName() + " 正在获取在线用户列表");
                    String content = ManageClientThread.getAllOnlineUsers();

                    Message message1 = new Message();
                    message1.setSender(user.getName());
                    message1.setContent(content);
                    message1.setMesType(MessageType.MESSAGE_ALL_ONLINE_USERS);
                    message1.setLocalDateTime(LocalDateTime.now());

                    ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                    objectOutputStream.writeObject(message1);
                    //发送消息给某用户
                } else if (message.getMesType().equals(MessageType.MESSAGE_SEND_MESS_TO_ONE)) {
                    //如果用户在线
                    if (ManageClientThread.containKey(message.getGetter())) {
                        System.out.println(ManageClientThread.getByUserId(message.getSender()).user.getName() + " 正在给 " + ManageClientThread.getByUserId(message.getSender()).user.getName() + "私发消息");

                        ObjectOutputStream objectOutputStream1 = new ObjectOutputStream(ManageClientThread.getByUserId(message.getGetter()).socket.getOutputStream());
                        Message message1 = new Message();
                        message1.setGetter(ManageClientThread.getByUserId(message.getGetter()).user.getName());
                        message1.setSender(ManageClientThread.getByUserId(message.getSender()).user.getName());
                        message1.setMesType(MessageType.MESSAGE_RETURN_MESS_GETTER_ONE);
                        message1.setLocalDateTime(message.getLocalDateTime());
                        message1.setContent(message.getContent());

                        objectOutputStream1.writeObject(message1);

                        Message message2 = new Message();
                        message2.setLocalDateTime(message.getLocalDateTime());
                        message2.setContent("用户:" + ManageClientThread.getByUserId(message.getGetter()).user.getName() + " 在线.\n" +
                                "你 对 " + ManageClientThread.getByUserId(message.getGetter()).user.getName() + " 说:" + message.getContent());
                        message2.setMesType(MessageType.MESSAGE_RETURN_MESS_SENDER_ONE);
                        ObjectOutputStream objectOutputStream2 = new ObjectOutputStream(socket.getOutputStream());

                        objectOutputStream2.writeObject(message2);

                        //如果用户不在线
                    } else {
                        System.out.println(ManageClientThread.getByUserId(message.getSender()).user.getName() + " 正在给 " + LodeAllUsers.getAllUsersMap().get(message.getGetter()).getName() + "发送离线消息");

                        Message message1 = new Message();
                        message1.setLocalDateTime(message.getLocalDateTime());
                        message1.setContent("用户:" + LodeAllUsers.getAllUsersMap().get(message.getGetter()).getName() + " 不在线，发送离线消息\n" +
                                "你 对 " + LodeAllUsers.getAllUsersMap().get(message.getGetter()).getName() + " 说 " + message.getContent());
                        message1.setMesType(MessageType.MESSAGE_RETURN_MESS_SENDER_ONE);
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                        objectOutputStream.writeObject(message1);

                        Message message2 = new Message();
                        message2.setSender(LodeAllUsers.getAllUsersMap().get(message.getSender()).getName());
                        message2.setGetter(message.getGetter());
                        message2.setContent(message.getContent());
                        message2.setLocalDateTime(message.getLocalDateTime());
                        message2.setMesType(MessageType.MESSAGE_RETURN_MESS_GETTER_ONE);

                        OfflineInformationList.addOfflineInformation(message2.getGetter(), message2);
                    }
                }else if (message.getMesType().equals(MessageType.MESSAGE_SEND_MESS_TO_ALL)){

                    System.out.println(ManageClientThread.getByUserId(message.getSender()).user.getName() + "正在群发消息");
                    Message message1 = new Message();
                    message1.setSender(ManageClientThread.getByUserId(message.getSender()).user.getName());
                    message1.setMesType(MessageType.MESSAGE_RETURN_MESS_GETTER_ALL);
                    message1.setContent(message.getContent());
                    message1.setLocalDateTime(message.getLocalDateTime());

                    ConcurrentHashMap<String, ServerConnectClientThread> allClientThread = ManageClientThread.getAllClientThread();
                    Collection<ServerConnectClientThread> values = allClientThread.values();
                    for (ServerConnectClientThread value : values) {
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(value.socket.getOutputStream());
                        objectOutputStream.writeObject(message1);
                    }

                    Message message2 = new Message();
                    message2.setLocalDateTime(message.getLocalDateTime());
                    message2.setContent("你对大家说: " + message.getContent());
                    message2.setMesType(MessageType.MESSAGE_RETURN_MESS_SENDER_ALL);
                    ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                    objectOutputStream.writeObject(message2);
                } else if (message.getMesType().equals(MessageType.MESSAGE_SEND_FILE_TO_ONE)) {

                    System.out.println(LodeAllUsers.getAllUsersMap().get(message.getSender()).getName() + " 给 " + LodeAllUsers.getAllUsersMap().get(message.getGetter()).getName() + " 发送了以一个文件");
                    Message message1 = new Message();
                    message1.setSender(LodeAllUsers.getAllUsersMap().get(message.getSender()).getName());
                    message1.setGetter(LodeAllUsers.getAllUsersMap().get(message.getGetter()).getName());
                    message1.setMesType(MessageType.MESSAGE_SEND_FILE_RET_SENDER);
                    message1.setLocalDateTime(message.getLocalDateTime());
                    ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                    objectOutputStream.writeObject(message1);

                    Message message2 = new Message();
                    message2.setLocalDateTime(message.getLocalDateTime());
                    message2.setFileBytes(message.getFileBytes());
                    message2.setSender(LodeAllUsers.getAllUsersMap().get(message.getSender()).getName());
                    message2.setGetter(LodeAllUsers.getAllUsersMap().get(message.getGetter()).getName());
                    message2.setMesType(MessageType.MESSAGE_SEND_FILE_RET_GETTER);

                    StoringFilesMap.addFile(message.getGetter(), message2);

                } else if(message.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)){

                    System.out.println(message.getSender() + " 安全退出网络通信系统");
                    Message message1 = new Message();
                    message1.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
                    ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                    objectOutputStream.writeObject(message1);
                    ManageClientThread.removeServerConnectClientThread(message.getSender());
                    socket.close();
                    break;
                }
            } catch (IOException | ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

ClientConnectServerThread

package com.wwb.commclient.service;

import com.wwb.message.Message;
import com.wwb.message.MessageType;

import java.io.*;
import java.net.Socket;
import java.time.format.DateTimeFormatter;
import java.util.Scanner;

public class ClientConnectServerThread extends Thread{

    private Socket socket;
    public Scanner scanner = new Scanner(System.in);
    public ClientConnectServerThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {

        while (true) {
            System.out.println("客户端线程，等待读取服务端发送信息");
            try {
                ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
                Message message = (Message) objectInputStream.readObject();

                if(message.getMesType().equals(MessageType.MESSAGE_ALL_ONLINE_USERS)){

                    System.out.println("时间: " + message.getLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    System.out.println("在线用户如下:");
                    String[] s = message.getContent().split(" ");
                    for (String string : s) {
                        System.out.println(string);
                    }
                }else if(message.getMesType().equals(MessageType.MESSAGE_RETURN_MESS_SENDER_ONE)){
                    System.out.println("时间: " + message.getLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    System.out.println(message.getContent());
                }else if(message.getMesType().equals(MessageType.MESSAGE_RETURN_MESS_GETTER_ONE)){
                    System.out.println("时间: " + message.getLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    System.out.println(message.getSender() + " 对你说: " + message.getContent());
                } else if (message.getMesType().equals(MessageType.MESSAGE_RETURN_MESS_SENDER_ALL)){
                    System.out.println("时间: " + message.getLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    System.out.println(message.getContent());
                } else if (message.getMesType().equals(MessageType.MESSAGE_RETURN_MESS_GETTER_ALL)) {
                    System.out.println("时间: " + message.getLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    System.out.println(message.getSender() + " 对大家说: " + message.getContent());
                } else if(message.getMesType().equals(MessageType.MESSAGE_TO_ALL_CLIENT_MES)){
                    System.out.println("时间: " + message.getLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    System.out.println("服务器为大家推送消息: " + message.getContent());

                }else if(message.getMesType().equals(MessageType.MESSAGE_SEND_FILE_RET_SENDER)){
                    System.out.println("时间: " + message.getLocalDateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    System.out.println("你给 " + message.getGetter() + " 发送了一个文件");
                }else if(message.getMesType().equals(MessageType.MESSAGE_SEND_FILE_RET_GETTER)){
                    System.out.println(message.getSender() + " 给你发送了一个文件");
                    System.out.println("请输入存储文件的路径");
                    String filePath = scanner.next();
                    FileOutputStream fileOutputStream = new FileOutputStream(filePath);
                    fileOutputStream.write(message.getFileBytes());
                    fileOutputStream.close();
                    System.out.println("存储成功");
                }else if (message.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)) {

                    socket.close();
                    break;
                }
            } catch (IOException | ClassNotFoundException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

MessageType

package com.wwb.message;

/**
 * 消息类型
 */
public class MessageType {

    public static final String MESSAGE_USER_NOT_FOUND = "1";
    public static final String MESSAGE_LOGIN_SUCCESSFUL = "2";
    public static final String MESSAGE_LOGIN_FAILURE = "3";
    public static final String MESSAGE_ALL_ONLINE_USERS = "4";
    public static final String MESSAGE_SEND_MESS_TO_ONE = "5";
    public static final String MESSAGE_RETURN_MESS_GETTER_ONE = "6";
    public static final String MESSAGE_RETURN_MESS_SENDER_ONE = "7";
    public static final String MESSAGE_SEND_MESS_TO_ALL = "8";
    public static final String MESSAGE_RETURN_MESS_SENDER_ALL = "9";
    public static final String MESSAGE_RETURN_MESS_GETTER_ALL = "10";
    public static final String MESSAGE_CLIENT_EXIT = "11";
    public static final String MESSAGE_REGISTER_ACCOUNT = "12";
    public static final String MESSAGE_TO_ALL_CLIENT_MES = "13";
    public static final String MESSAGE_SEND_FILE_TO_ONE = "14";
    public static final String MESSAGE_SEND_FILE_RET_SENDER = "15";
    public static final String MESSAGE_SEND_FILE_RET_GETTER = "16";

}

UserClientServer

package com.wwb.commclient.service;

import com.wwb.message.Message;
import com.wwb.message.MessageType;
import com.wwb.user.User;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.time.LocalDateTime;

/**
 * 为客户端用户提供服务
 */
public class UserClientService {
    User user = new User();
    Socket socket = null;
    public User checkUser(String userId, String password){

        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8888);
            user.setUserId(userId);
            user.setPassword(password);
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(user);

            ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
            Message message1 = (Message)objectInputStream.readObject();

            //登录失败
            if(message1.getMesType().equals(MessageType.MESSAGE_LOGIN_FAILURE)){
                System.out.println("用户名或者密码错误");
                socket.close();
                return null;
            }//该用户未注册账号
            else if(message1.getMesType().equals(MessageType.MESSAGE_USER_NOT_FOUND)){

                System.out.println("该用户未注册，请先注册账号");
                socket.close();
                return null;
            }//登录成功
            else if (message1.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCESSFUL)) {

                System.out.println("登录成功");
                user = new User();
                user.setName(message1.getContent());
                user.setUserId(userId);
                user.setPassword(password);

                ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
                clientConnectServerThread.start();
            }
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        return user;
    }
    public void registerAccount(String userId, String password){

        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8888);
            user.setUserId(userId);
            user.setPassword(password);
            user.setName("未注册");
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(user);

            ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
            Message message1 = (Message)objectInputStream.readObject();
            if(message1.getMesType().equals(MessageType.MESSAGE_REGISTER_ACCOUNT)){
                System.out.println("注册成功");
            }
            user.setName(message1.getContent());
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        } finally {
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
            }
        }
    }
    public void getOnlineUsersList(){

        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_ALL_ONLINE_USERS);
        message.setSender(user.getName());

        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public void senderMessageToOne(String getterId, String content){

        Message message = new Message();
        message.setContent(content);
        message.setSender(user.getUserId());
        message.setGetter(getterId);
        message.setLocalDateTime(LocalDateTime.now());
        message.setMesType(MessageType.MESSAGE_SEND_MESS_TO_ONE);
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public void senderMessageToAll(String content){

        Message message = new Message();
        message.setContent(content);
        message.setSender(user.getUserId());
        message.setLocalDateTime(LocalDateTime.now());
        message.setMesType(MessageType.MESSAGE_SEND_MESS_TO_ALL);
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public void clientExit(){

        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
        message.setSender(user.getUserId());

        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            System.out.println(user.getUserId() + " 退出系统");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public void sendFileToOne(String filePath, String userId){

        File file = new File(filePath);
        byte[] fileBytes = new byte[(int) new File(filePath).length()];

        BufferedInputStream bufferedInputStream = null;
        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));
            bufferedInputStream.read(fileBytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if(bufferedInputStream != null){
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        Message message = new Message();
        message.setLocalDateTime(LocalDateTime.now());
        message.setMesType(MessageType.MESSAGE_SEND_FILE_TO_ONE);
        message.setFileBytes(fileBytes);
        message.setGetter(userId);
        message.setSender(user.getUserId());

        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

CommServer

package com.wwb.service;

import com.wwb.Administrator.AdministratorThread;
import com.wwb.message.Message;
import com.wwb.message.MessageType;
import com.wwb.user.LodeAllUsers;
import com.wwb.user.User;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;


public class CommServer {

    ConcurrentHashMap<String, User> allUsers = LodeAllUsers.getAllUsersMap();
    public static void main(String[] args) {

        new CommServer();
    }
    public CommServer() {

        ServerSocket serverSocket = null;
        new AdministratorThread().start();
        try {
            serverSocket = new ServerSocket(8888);
            LodeAllUsers.loadAllUsers();
            allUsers = LodeAllUsers.getAllUsersMap();
            System.out.println("服务端正在 8888 端口监听 等待用户访问");
            while(true){

                Socket socket = serverSocket.accept();

                ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
                User user = (User) objectInputStream.readObject();

                ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                Message message = new Message();
                if("未注册".equals(user.getName())){
                    System.out.println("用户: " + user.getUserId() + " 正在注册账号");
                    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src//AllUsersInformation.txt", true));
                    bufferedWriter.write("\n" + user.getUserId() + " " + user.getUserId() + " " + user.getPassword());
                    bufferedWriter.close();

                    message.setMesType(MessageType.MESSAGE_REGISTER_ACCOUNT);
                    message.setContent(user.getUserId());
                    objectOutputStream.writeObject(message);

                    LodeAllUsers.loadAllUsers();
                    allUsers = LodeAllUsers.getAllUsersMap();
                    socket.close();
                }
                else if(!allUsers.containsKey(user.getUserId())){
                    System.out.println("该用户未注册账号");
                    message.setMesType(MessageType.MESSAGE_USER_NOT_FOUND);
                    objectOutputStream.writeObject(message);
                    socket.close();
                } else if (!allUsers.get(user.getUserId()).getPassword().equals(user.getPassword())) {
                    System.out.println("用户 " + allUsers.get(user.getUserId()).getName() + " 输入密码错误");
                    message.setMesType(MessageType.MESSAGE_LOGIN_FAILURE);
                    objectOutputStream.writeObject(message);
                    socket.close();
                } else {
                    System.out.println("用户 " + allUsers.get(user.getUserId()).getName() + " 登录成功");
                    message.setMesType(MessageType.MESSAGE_LOGIN_SUCCESSFUL);
                    message.setContent(allUsers.get(user.getUserId()).getName());
                    objectOutputStream.writeObject(message);

                    ServerConnectClientThread serverConnectClientThread = new ServerConnectClientThread(socket, allUsers.get(user.getUserId()));
                    serverConnectClientThread.start();

                    ManageClientThread.addServerConnectClientThread(user.getUserId(), serverConnectClientThread);
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        } finally {

            if(serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
            }
        }
    }
}

 

 

 

 

王霸zyc
关注
面向对象（经典例题）
weixin_45777287的博客
12-05 3811
1.设计一个名为StopWatch的类，该类包含： 具有访问器方法的私有数据域startTime和endTime 一个无参构造方法，使用当前时间来初始化startTime 一个名为start()的方法，将startTime重设为当前时间 一个名为stop()的方法，将endTime设置为当前时间 一个名为getElapsedTime()的方法，以毫秒为单位返回秒表记录的流逝时间 public cl...
面向对象大作业之课程设计(自主选题)-第一次提交
weixin_75261941的博客
11-13 115
初步打算做一个图书管理系统，分为学生端和管理员端，学生端实现查找书籍，借书，还书，管理员端实现查看书籍，增加书籍，删除书籍。学生可以查看现有的图书以及详细信息，比如书名，作者，出版社，出版日期，数量。文心一言：https://yiyan.baidu.com/图书的详细信息，包括书名，作者、出版社、出版日期，数量。登录：输入数据库中已有的账号和密码进入相应页面。注册：创造一个新的账号和密码。分为两种用户：学生和管理员。完成图书的增加和删除功能。用户都有注册和登录功能。学生可以借阅和归还图书。
面向对象大作业
11-01 1855
面向对象留大作业了，具体如下，期末前交，先贴上具体要求，写完后贴代码 Normal 0 7.8 磅 0 2 false false false MicrosoftInternetExp
《面向对象程序设计（C++）》期末考试 大作业
m0_70752559的博客
12-02 1917
以 值 传 递 的 方 式 传 递 信 息 ， 那 么 从 函 数 compute 返 回 主 程 序 后 ， a 和 b 的 值 分 别。3、在 C++语言中，用 _____表达式来创建动态的类对象；6、在下面的程序中，若实参 a 与形参 x 以引用传递的方式传递信息，实参 b 与形参 y。9、假设类 AB 用成员函数的方式重载加法运算符，以实现两个 AB 类对象的加法，并返。1、函数的返回值是通过函数体中的_____ 语句带回的；4、类的访问权限有_____ 、_____ 和_____ 三种。
Java面向对象编程_2019级Java面向对象程序设计大作业题目及要求
weixin_39609457的博客
02-21 828
2019级Java面向对象程序设计大作业题目及要求一、作业目的1、掌握用Java实现面向对象程序设计的基本方法。2、熟练掌握Java程序开发环境的使用。3、完成一个GUI应用程序的设计、编码、调试，了解程序设计过程，锻炼实际应用能力，为后续课程打下基础。二、作业题目编写的代码需要体现面向对象的思想，需要根据题意分析创建几个类。所有的题目都建议实现GUI应用程序，即具有图形用户界面。建议批量信息的存...
面向对象第一次作业参考答案
GamesDuan的专栏
10-07 3708
第一题：#include void main() { int a,b,c; int d; cout<<"Input three different integers:"; cin>>a>>b>>c; cout<<"Sum is "<<a + b + c<<endl; //sum cout<<"Average
如何成为一名很酷的机器人工程师
MuscleMonk的博客
09-19 1926
观文有感 之 如何成为一名很酷的机器人工程师 闲来垂钓碧溪上。今天来钓一波职业规划，记录一下笔记（特别注意：本文中大部分内容是复制粘贴的，只有少数位置的删改和整理，目的是分享一下大佬的讲解）： 文章目录观文有感 之 如何成为一名很酷的机器人工程师1.前言2.大一3.大二4.大三5.大四6.原文作者的话 1.前言 （1）机器人学的公认难题是：在物理世界中实现类人的活动能力 （2）机器人学的核心问题是：做好与物理世界的交互，在主流的机器人学分支中分为三类：传感器和处理算法（激光雷达、多目视觉、融合算法），多刚体
软件工程期末复习题库
菜鸟-宇的个人博客
11-13 1万+
软件工程期末复习题库
大数据测试考题 - 纯技术交流(1)
Tony Gong的博客
07-22 5874
很多人都在谈大数据技术，但客户在真正启动大数据项目的时候有哪些技术思考？ 如何来选型大数据平台？从以下POC考题及案例就可以了解客户对大数据的细粒度需求。
烟草物流信息综合管理平台研究与应用——以H市卷烟厂烟草物流配送中心为例
qq_38086325的博客
11-03 9159
烟草物流信息综合管理平台研究与应用 ——以H市卷烟厂烟草物流配送中心 摘 要 自我国正式加入世界贸易组织（WTO）以来，我国卷烟与外国卷烟之间对零售终端市场的竞争日益激烈，中国烟草目前正面临前所未有的挑战。因此提高我国烟草业的整体竞争力是当前首要任务。在产品生产和销售过程中，物流起着重要作用，物流的管理和优化已经逐渐成为企业降低成本的重要途径。随着我国各地烟草销售网络的不断完善，现代烟草物流的发...
面向对象程序设计 C++大作业
热门推荐
对白的学习小屋
09-16 1万+
面向对象程序设计 C++大作业 题目：C++通信录 专业：计算机科学与技术 班级：信息A1611 组号：第一小组 内容： （1）输入信息； （2）显示信息； （3）删除记录； （4）查询、修改记录； （5）界面优化等； 五大主功能函数： void show_all(); /*显示全部。通过循环调用show（）函...
面向对象操作练习题目
qq_43210924的博客
01-02 535
商品信息类的封装 Medicine类属性如下： 药名 name 价格 price 生产日期 PD 失效日期 Exp Medicine类方法如下: 获取药品名称 get_name()返回str 计算保质期 ...
2020-2021学年第二学期期末考试《面向对象程序设计》大作业
open585858的博客
08-23 1028
2020-2021学年第二学期期末考试 面向对象程序设计 一 名词解释题 (共10题 ，总分值30分 ) 宏 （3 分） 用户界面 （3 分） 属性 （3 分） 文档 （3 分） 关键字 （3 分） 标识符 （3 分） 控件 （3 分） 预处理 （3 分） 调用 （3 分） 视图 （3 分） 二 简答题 (共5题 ，总分值40分 ) 11. 请将二进制数1001 0000转化为10进制： （8 分） 12. break和continue 的区别： （8 分） 13. 简要说明Visual C++和C++
基于python的语音识别与蓝牙通信的温控系统毕设项目
m0_70066267的博客
10-29 1156
大家好，我是俊星学长，一名在 Java 圈辛勤劳作的码农。今日，要和大家分享的是一款基于python的语音识别与蓝牙通信的温控系统毕设项目。项目源码以及部署相关事宜，请联系小村学长，文末会附上联系信息哦。🌟作者：陈辰学长🌟🌟个人简介：在 Java 领域已沉浸十余年，对 Java、微信小程序、Python、Android 等技术颇为精通。若大家在这些领域有任何问题，欢迎一起交流探讨！🌟。
开题报告Nodejs网上书城.docx
最新发布
10-30
毕业设计开题报告
面向对象程序设计选题系统实现
在这个实验中，我们关注的是一个基于面向对象编程的选题系统，特别适用于班级内的选题活动。这个系统的主要目标是存储和管理题目的相关信息，以及确保每个学生能随机抽取且唯一选定一个题目。以下是该系统的关键知识...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值