data编程代写、代做Java设计程序

日期：2024-06-23 08:55

Requirements for Software Engineering and

Technologies Homework Projects

April 25, 2024

Abstract

This document speciffes the homework project requirements for

the Software Engineering and Technologies course.

1 Introduction

Your submission must be an Apache Maven 3 Java project. You can use

any integrated development environment for developing the project, however,

IntelliJ IDEA is the recommended IDE.

2 Functional Requirements

ˆ The software must have testable functionality (business logic), and unit

tests must be created for it.

ˆ The software must have a reasonable graphical user interface, which

must be implemented with JavaFX.

ˆ The implementation must be carried out according to the Model-ViewController

(MVC) architectural pattern.

ˆ The software must persistently store data, it must also read and write

data. Data must be stored (1) in XML documents via JAXB, or (2) in

JSON ffles via Gson or Jackson.

13 Portability

The project must be buildable and fully operational on each platform (including

Linux, macOS, and Windows) where the appropriate versions of OpenJDK

and Apache Maven are available. For example, the execution of the

mvn site command in the root directory of the project must always result

in the generation of the project’s site.

File names must consist of US-ASCII characters only.

4 Java-speciffc Requirements

You must use JDK 21 or JDK 22 to build the project.

5 Apache Maven-speciffc Requirements

5.1 Properties

In the pom.xml ffle, you must provide the following elements with proper

content:

ˆ description: must contain a brief description of the project

ˆ developers: must contain at least the full name and email address of

the developer

ˆ properties/project.build.sourceEncoding: must be set to UTF-8

ˆ properties/maven.compiler.release: must be set to either 21 or 22

ˆ properties/exec.mainClass

5.2 Reporting Plugins

At least the following plugins must be used to generate reports to be displayed

on the project’s site:

ˆ Maven Javadoc Plugin

ˆ Maven JXR Plugin

2ˆ Maven Checkstyle Plugin

1

ˆ Maven Sureffre Report Plugin

ˆ JaCoCo Maven Plugin

6 Documentation

Apart from the following exceptions, you must write API documentation for

all top-level types (i.e., classes and interfaces) and nested types with public

or package access and their members, too. Documentation comments must

provide all information necessary for developers to use the documented entity.

You do not have to document

ˆ unit tests,

ˆ graphical user interface classes,

ˆ the main(String[] args) method,

ˆ members whose visibility is not public.

Documentation comments must conform to the requirements discussed at

the classes, both in form and content.

In documentation comments try to use as many inline tags as possible.

For example, method parameter names should be enclosed between

<code></code> tags or in {@code} inline tags, and the {@link} inline tag

should be used for references. The text of documentation comments should

be brief and clear, the spelling and grammar should be correct.

Each package must contain an overview comment ffle named package-info.java.

Documentation must be checked with the Checkstyle plugin using the

checkstyle.xml conffguration ffle provided by the instructors.

7 Logging

The program must do logging for which you can use any of the following

libraries:

1Must be used only for checking API documentation using the conffguration ffle provided

by the instructors.

3ˆ Apache Log4j 2, or

ˆ tinylog 2, or

ˆ SLF4J with Apache Log4j 2 or tinylog 2 as a backend.

You must not use System.out.println() method calls for logging!

You must provide a conffguration ffle for the logging library being used in

the src/main/resources/ directory. Log messages must be written to the

console.

8 Unit Tests

Unit tests must be written using JUnit 5. You do not have to write unit

tests for graphical user interface classes and exception classes. All the tests

must pass with no errors or failures. Code coverage must be measured using

the JaCoCo Maven Plugin.

9 Handling of Files

All of the data, conffguration and other similar ffles must be put in the

src/main/resources/ or the src/test/resources/ directory, respectively.

It is strictly forbidden to use platform-speciffc absolute paths to access

ffles, such as the following:

File file = new File("C:\\file.txt");

or

OutputStream os =

new FileOutputStream("/home/me/.history");

These will work only on Windows or Linux, respectively!

Files must be accessed via the class loader mechanism. It is forbidden to

access ffles directly from the src/main/resources/ and the src/test/resources/

directories. Do not forget that these ffles are automatically copied to the

target/classes/ and the target/test-classes/ directories from where

they can be accessed via the class loader. Thus, for example, the following

is forbidden:

File f = new File("src/main/resources/file.txt");

410 Packaging (JAR creation)

In the package lifecycle phase, an executable uber JAR must be created that

contains the dependencies of the project too. Thus, running the JAR must

launch the application.

11 README.md ffle

The repository must contain a README.md ffle that provides a brief description

of the project (must contain at least the original description of the

assignment).

12 .gitignore ffle

The project must contain a .gitignore ffle that excludes ffles created by

developer tools (i.e., IntelliJ IDEA and Maven) from versioning. You can

use the https://gitignore.io/ service to generate a .gitignore ffle.

13 Development and Availability

The project must be developed on GitHub in a private repository created in

GitHub Classroom.

The instructor must be able to monitor the progress of development in

the repository. It is unacceptable if the repository contains a single commit

only. Commits should have clear and descriptive messages.

Manual ffle uploads to the repository are strictly forbidden, you must

always use a Git client to perform repository operations.

14 Use of Comments

Comments in the code should be used according to the rules of Clean Code.

For example, it is unacceptable if almost all code lines have a comment.

This is a clear indication that the code was written by someone else and the

submitter does not understand the code.

515 Use of Language

The text of the comments in the code (including Javadoc comments) and

also the content of the README.md file must be written in English. In the

code, it is strictly forbidden to use any language other than English.

16 Requirements for Logic Puzzles

If the project is about a logic puzzle, the class implementing the state-space

representation must implement the puzzle.State interface provided by the

instructors. The solution to the puzzle must be generated by the problem

solver provided by the instructors. It is strictly forbidden to modify the

puzzle.State interface or the code of the problem solver.

Both the problem solver and the graphical user interface must use the

same state-space representation.

17 Requirements for Two-player Games

If the project is about a two-player game, the class implementing the statespace

representation must implement the game.State interface provided by

the instructors. It is strictly forbidden to modify the game.State interface.

You must also implement a console-based user interface for the game

based on the code provided by the instructors. The console-based user interface

aims to demonstrate that the model is fully detached from any user

interface, thus, it doesn’t have to store data.

Both the console-based and the graphical user interface must use the same

state-space representation.

18 Further Requirements

Your submission must be your own work. The project must conform to all of

the requirements specified in this document and must provide all functionality

without any errors.

Debrecen, April 25, 2024

6