CSSE2002程序写作、辅导Java编程

” CSSE2002程序写作、辅导Java编程School of ITEECSSE2002/7023 Semester 1, 2021Assignment 1Due: 1 April 2021 16:00 AESTRevision: 1.0.0AbstractThe goal of this assignment is to implement and test a set of classes and interfaces1to be used inthe second assignment.Language requirements: Java version 11, JUnit 4.Please carefully read the Appendix A Document. It outlines critical mistakeswhich you must avoid in order to avoid losing marks. This is being heavily emphasisedhere because these are critical mistakes which must be avoided.If at any point you are even slightly unsure, please check as soon as possible withcourse staff !PreambleAll work on this assignment is to be your Own individual work. As detailed in Lecture 1, codesupplied by course staff (from this semester) is acceptable, but there are no other exceptions. Youare expected to be familiar with What not to do from Lecture 1 and httpss://www.itee.uq.edu.au/itee-student-misconduct-including-plagiarism. If you have questions about whatis acceptable, please ask course staff.All times are given in Australian Eastern Standard Time. It is your responsibility to ensure thatyou adhere to this timezone for all assignment related matters. Please bear this in mind, especiallyif you are enrolled in the External offering and may be located in a different time zone.IntroductionIn this assignment, and continuing into the second assignment, you will build a simple simulationof an air traffic control (ATC) system. The first assignment will focus on implementing the classesthat provide the core model for the system.An ATC system manages the movement of aircraft around an airport, including assigningaircraft to terminals and gates, and managing situations such as emergencies. An ATC systemalso maintains various Queues including a landing queue, and takeoff queue (more about this inassignment 2).Terminals each contain a number of Gates, and can be designed to only cater to specific typesof aircraft, such as Airplanes or Helicopters.An aircraft can be either an Airplane or a Helicopter. An Aircraft can have two primarypurposes; they can either be a Passenger aircraft, or a Freight aircraft.Each aircraft has various characteristics which are known to the ATC system including theaircrafts empty weight, fuel capacity, passenger capacity, and freight capacity. These characteristicscan determine how long it can take to complete various actions such as boarding passengers1From now on, classes and interfaces will be shortened to simply classes1or freight, or refueling the Aircraft. The total weight of an aircraft can change depending on theoccupancy level (passengers or freight) of the aircraft (for example, more passengers means theaircraft will be heavier).Each aircraft also has a list of tasks that it completes. Tasks represent the actions or statesthat an aircraft can take including: being away from the airport (for assignment simplicity weonly care the aircraft is in an away state, we do not care what it might be doing in this time),waiting to land, waiting to take off, loading (i.e. passengers or freight), and waiting idle at thegate. Tasks can take different amounts of time depending on characteristics of the aircraft, andthe requirements of each recorded task (for example, loading takes longer when there are morepassengers or freight).The list of tasks which an aircraft has must follow a strict set of requirements. The tasks canonly occur in a specific order (for example, it would not make logical sense to be waiting in theair in a landing queue, and then takeoff the aircraft must land first). Aircraft also complete atask list in a circular manner. Once the aircraft has completed the last task in the list, it will thencommence the first task in the list again. This behaviour will go on forever (this simplificationof aircraft behavior is for assignment simplicity. A real aircraft would have much more complexschedules, but this is way beyond the scope of this course).Supplied Material This task sheet. Code specification document (Javadoc).2 Gradescope, an online website where you will submit your assignment.3 An empty assignment Solution (i.e. skeleton code) is provided in your Subversion repository.These files provide a minimal framework for you to work from, and build upon. These fileshave been provided so that you can avoid (some of) the critical mistakes described in theAppendix. Each of these files: is in the correct directory (do not change this!) has the correct package declaration at the top of the file (do not change this!) has the correct public Class or public interface declaration. Note that you may still needto make classes abstract, extend classes, implement interfaces etc. as detailed in thespecifications.As the first step in the assignment (after reading through the specifications) you should checkoutthe ass1 repository from Subversion. Once you have created a new project from the repositoryyou have checked out, you should start implementing the specifications.JavadocCode specifications are an important tool for developing code in collaboration with other people.Although assignments in this course are individual, they still aim to prepare you for writingcode to a strict specification by providing a specification document (in Java, this is called Javadoc).You will need to implement the specification precisely as it is described in the specification document.The Javadoc can be viewed in either of the two following ways:1. Open httpss://csse2002.uqcloud.net/assignment/1/ in your web browser. Note that thiswill only be the most recent version of the Javadoc.2Detailed in the Javadoc section3Detailed in the Submission section22. Navigate to the relevant assignment folder under Assessment on Blackboard and you will beable to download the Javadoc .zip file containing HTML documentation. Unzip the bundlesomewhere, and open doc/index.html with your web browser.Tasks1. Fully implement each of the classes and interfaces described in the Javadoc.2. Write JUnit 4 tests for all the methods in the following classes: Gate (in a class called GateTest) TaskList (in a class called TaskListTest)MarkingThe 100 marks available for the assignment will be divided as follows:Symbol Marks Marked DescriptionF T 45 Electronically Functionality according to the specificationCF 10 Electronically Conformance to the specificationSL 10 Electronically Code Style: Structure and LayoutCR 20 By course staff Code Style review: (Style and Design)JU 15 Electronically Whether JUnit tests identify and distinguish betweencorrect and incorrect ImplementationsThe overall assignment mark will be A1 = F T + CF + SL + CR + JU with the followingadjustments:1. If F T is 0, then the manual code style review will not be marked. CR will be automatically0.2. If SL is 0, then the manual code style review will not be marked. CR will be automatically0.3. If SL + CR F T, then SL + CR = F T. For example: F T = 22, CF = 8, SL = 7, CR = 18, J = 13 A1 = 22 + 8 + (7 + 18) + 13.The reasoning here is to place emphasis on good quality functional code.Well styled code that does not implement the required functionality is of no valuein a project, consequently marks will not be given to well styled code that is notfunctional.Functionality MarkingThe number of functionality marks given will beF T =Unit Tests passedTotal number of Unit Tests 453ConformanceConformance is marked starting with a mark of 10.Every single occurrence of a conformance violation in your solution then results in a 1 mark deduction,down to a minimum of 0. Note that multiple conformance violations of the same typewill each result in a 1 mark deduction.Conformance Violations include (but are not limited to): Placing files in incorrect directories. Incorrect package declarations at the top of files. Using modifiers on classes, methods and member variables that are different to those specifiedin the Javadoc. Modifiers include private, protected, public, abstract, final, andstatic. For example, declaring a method as public when it should be private. Adding extra public methods, constructors, member variables or classes that are not describedin the Javadoc. Incorrect parameters and exceptions declared as thrown for constructors. Incorrect parameters, return type and exceptions declared as thrown for methods. Incorrect types of public fields.Code StyleCode Structure and LayoutThe Code Structure and Layout category is marked starting with a mark of 10.Every single occurrence of a style violation in your solution, as detected by CheckStyle using thecourse-provided configuration4, results in a 0.5 mark deduction, down to a minimum of 0. Notethat multiple style violations of the same type will each result in a 0.5 mark deduction.Note: There is a plugin available for IntelliJ which will highlight style violations in your code.Instructions for installing this plugin are available in the Java Programming Style Guide on Blackboard(Learning Resources Guides). If you correctly use the plugin and follow the style requirements,it should be relatively straightforward to get high marks for this section.Code ReviewYour assignment will be style marked with respect to the course style guide, located under LearningResources Guides. The marks are broadly divided as follows:Metric Marks AllocatedNaming 6Commenting 6Readability 3Code Review 5Note that style marking does involve some aesthetic judgement (and the markers aesthetic judgementis final).Note that the plugin available for IntelliJ mentioned in the Code Structure and Layout sectioncannot tell you whether Your code violates style guidelines for this section. To do so, it would needcomplex AI capabilities, which is not realistic. You will need to manually check your code against4The latest version of the course CheckStyle configuration can be found at https://csse2002.uqcloud.net/checkstyle.xml. See the Style Guide for instructions.4the style guide.The Code Review is marked starting with a mark of 20. Penalities are then applied where applicable,to a minimum of 0.Metric How it is markedNaming Misnamed variables (-4 marks max)e.g. Non-meaningful or one-letter names String temp; // bad naming char a; // bad naming int myVar, var, myVariable; // all bad naming Variable names using Hungarian notation int roomInteger; // bad naming ListhGatei gateList; // bad namingCommenting Javadoc comments lacking sufficient detail (-4 marks max)e.g. Insufficient detail or non-meaningful Javadoc comments on (any) classes Insufficient detail or non-meaningful Javadoc comments on (any) methods Insufficient detail or non-meaningful Javadoc comments on (any) constructors Insufficient detail or non-meaningful Javadoc comments on (any) class variables etc.Lack of inline comments, or comments not meaningful (-2 marks max)e.g. There needs to be sufficient comments which explain your code so thatsomeone else can readily understand what is going. Someone should not needto guess or make assumptions. Lack of inline comments, or Comments not meaningful in methods Lack of inline comments, or comments not meaningful in constructors Lack of inline comments, or comments not meaningful for variables etc.Readability Readability issues (-3 marks max)e.g. Class content is laid out in a way which is not straightforward to follow Methods are laid out in Classes or Interfaces in a way which is not straightforwardto follow Method content is laid out in a way which is not straightforward to follow Variables are not placed in logical locations etc.Code Design Code duplication issues (-2 marks max)e.g. Using class member variables where local variables could be used Duplicating sections of code instead of extracting into a private helpermethod Using magic numbers without explanatory comments object.someMethod(50); // what does 50 mean? What is theunit/metric?JUnit Test MarkingSee Appendix B for more details.The JUnit tests that you provide in GateTest and TaskListTest will be used to test both correct5and incorrect implementations of the Gate and TaskList classes. Marks will be awarded for testsets which distinguish between correct and incorrect implementations5. A test class which passesevery implementation (or fails every implementation) will likely get a low mark. Marks will berewarded for tests which pass or fail correctly.There will be some limitations on your tests:1. If your tests take more than 20 seconds to run, or2. If your tests consume more memory than is reasonable or are otherwise malicious,then your tests will be stopped and a mark of zero given. These limits are very generous (e.g. yourtests should not take anywhere near 20 seconds to run).Electronic MarkingThe electronic aspects of the marking will be carried out in a Linux environment. The environmentwill not be running Windows, and neither IntelliJ nor Eclipse (or any other IDE) will be involved.OpenJDK 11 will be used to compile and execute your code and tests.It is critical that your code compiles.If your submission does not compile, you will receive zero for Functionality (FT).SubmissionHow/Where to SubmitSubmission is via Gradescope (Submission is not via SVN repository like in previous semesters).Instructions for submitting to Gradescope will be made available on Blackboard (under Assessment Assignment 1) towards the start of week 4. You will not be able to submit your assignment beforethen.You must ensure that you have submitted your code to Gradescope before the submission deadline.Code that is submitted after the deadline will not be marked (1 nanosecond late is still late).What to SubmitYour submission should have the following internal structure:src/ folders (packages) and .java files for classes described in the Javadoctest/ folders (packages) and .java files for the JUnit test classesA complete submission would look like:5And get them the right way around6src/towersim/aircraft/Aircraft.javasrc/towersim/aircraft/AircraftCharacteristics.javasrc/towersim/aircraft/AircraftType.javasrc/towersim/aircraft/FreightAircraft.javasrc/towersim/aircraft/PassengerAircraft.javasrc/towersim/control/ControlTower.javasrc/towersim/ground/AirplaneTerminal.javasrc/towersim/ground/Gate.javasrc/towersim/ground/HelicopterTerminal.javasrc/towersim/ground/Terminal.javasrc/towersim/tasks/Task.javasrc/towersim/tasks/TaskList.javasrc/towersim/tasks/TaskType.javasrc/towersim/util/EmergencyState.javasrc/towersim/util/NoSpaceException.javasrc/towersim/util/NoSuitableGateException.javasrc/towersim/util/OccupancyLevel.javasrc/towersim/util/Tickable.javatest/towersim/ground/GateTest.java (must be test directory, not src!)test/towersim/tasks/TaskListTest.java (must be test directory, not src!)Ensure that your classes and interfaces correctly declare the package they are within. For example,Gate.java should declare package towersim.ground.Do not submit any other files (e.g. no .class files).Note that GateTest and TaskListTest will be compiled individually against a sample solutionwithout the rest of your test files.Provided set of unit testsA small number of the unit tests (about 10-20%) used for assessing Functionality (FT) (not conformance,style, or JUnit tests) Will be provided in Gradescope prior to the submision deadline,which you will be able to test your submission against.The purpose of this is to provide you with an opportunity to receive feedback on whether thebasic functionality of your classes is correct or not. Passing all the provided unit tests does notguarantee that you will pass all of the full set of unit tests used for functionality marking.Instructions about the provided set of unit tests will be made available on Blackboard (underAssessment Assignment 1) towards the start of week 4. Instructions will not be provided beforethen. This will still give you over two weeks to submit and check your work before the assignmentis due.Late SubmissionAssignments submitted after the submission deadline of 16:00 on April 1 2021 (by any amountof time), will receive a mark of zero unless an extension is granted as outlined in the ElectronicCourse Profile see the Electronic Course Profile for details.7Do not wait until the last minute to submit the final version of your assignment. A submissionthat starts before 16:00 but finishes after 16:00 will not be marked. Exceptions cannot be madefor individual students, as this would not be fair to all other students.Assignment ExtensionsFor assignment one, extensions longer than 7 calendar days will not be possible due to the dependencyof assignment two on the work completed in assignment one. This matches what is outlinedin the respective Electronic Course Profile.All requests for extensions must be made via my.UQ as outlined in section 5.3 of the respectiveElectronic Course Profile. Please not directly email the course coordinator seeking an extension(you will be redirected to my.UQ).Remark RequestsTo submit a remark of this assignment please follow the information presented here: httpss://my.uq.edu.au/information-and-services/manage-my-program/exams-and-assessment/querying-result.RevisionsIf it becomes necessary to correct or clarify the task sheet or Javadoc, a new version will be issuedand an announcement will be made on the Blackboard course site.Appendix A: Critical Mistakes Which can cause loss in marks.Things you need to avoid!This is being heavily emphasised here because these are critical mistakes which must be avoided.The way assignments are marked has been heavily revised this semester to address many of theseissues where possible, but there are still issues which can only be avoided by making sure thespecification is followed correctly.Code may run fine locally on your own computer in IntelliJ, but it is required that it also buildsand runs correctly when it is marked with the electronic marking tool in Gradescope. Your solutionneeds to conform to the specification for this to occur.Correctly reading specification requirements is a key objective for the course. Files must be in the exact correct directories specified by the Javadoc. If files are in incorrectdirectories (even slightly wrong), you may lose marks for functionality in these files becausethe implementation does not conform to the specification. Files must have the exact correct package declaration at the top of the file. If files haveincorrect package declarations (even slightly wrong), you may lose marks for functionality inthese files because the implementation does not conform to the specification. You must implement the public and protected members exactly as described in the supplieddocumentation (no extra public/protected members or classes). Creating public or protecteddata members in a class when it is not required will result in loss of marks, because theimplementation does not conform to the specification. Private members may be added at your own discretion.8 Never import the org.junit.jupiter.api package. This is from JUnit 5. This will automaticallycause the marks for the JUnit section to be 0 because JUnit 5 functionality is notsupported. Do NOT use any version of Java newer than 11 when writing your solution! If you accidentallyuse Java features which are only present in a version newer than 11, then your submissionmay fail to compile when marked. This will automatically cause the marks for associatedfiles with this functionality to be 0.Appendix B: How your JUnit unit tests are marked.The JUnit tests you write for a class (e.g. GateTest.java) are evaluated by checking whether theycan distinguish between a correct implementation of the respective class (e.g. Gate.java)(made by the teaching staff), and incorrect implementations of the respective class (deliberatelymade by the teaching staff).First, we run your unit tests (e.g. GateTest.java, TaskListTest.java) against the correct implementationof the respective Classes (e.g. Gate.java, TaskList.java).We look at how many unit tests you have, and how many have passed. Let us imagine that youhave 5 unit tests (it should be more than this, 5 is just an example) for GateTest.java and4 unit tests (it should be more than this, 4 is just an example) for TaskListTest.java, andthey all pass (i.e. none result in Assert.fail() in JUnit4).We will then run your unit tests in both classes (GateTest.java, TaskListTest.java) against anincorrect solution implementation of the respective class (e.g. Gate.java). For example, thegetGateNumber() method in the Gate.java file is incorrect.We then look at how many of your unit tests pass.TaskListTest.java should still pass 5 unit tests. However, we would expect that GateTest.javawould pass less than 4 unit tests.If this is the case, we Know that your unit tests can identify that there is a problem with thisspecific implementation of Gate.java.This would get you one identified faulty implementation towards your JUnit mark.The total marks you receive for JUnit are the correct number of identified faulty implementations,out of the total number of faulty implementations which the teaching staff create.If your unit tests identified 60% of the faulty implementations, you would receive a mark of:60% of 15 9/15.请加QQ：99515681 或邮箱：99515681@qq.com WX：codehelp

“