This manual is for IT-FPX2249 Assessment 2, start to submission. Assessment 2 of IT-FPX2249 normally moves from writing a procedure to designing objects: fields and the methods that operate on them, access kept private and reached through accessors, and at introductory depth one parent with a child or two. Your scoring guide fixes the exact requirements, and the row that decides your grade is the one asking why the structure is shaped this way. Our tutors' sequence for this one follows, with a structure derived from the criteria and an annotated sample excerpt. Prefer to hand it over? The premium original sample for this exact assessment comes back within 24 to 48 hours, and revisions stay free until the criteria are met. Your courseroom may print this as IT FPX 2249 Assessment 2 or IT2249 Assessment 2; it is the same deliverable, and IT-FPX2249 Assessment 2 is what this manual walks through.
One honesty note before the manual: Capella revises courses and scoring guides over time, so always write to the exact scoring guide attached to your assessment in the courseroom. The course identity above is verified on capella.edu; the method and structure below are our tutors' approach to it, not Capella's official rubric text.
How IT-FPX2249 Assessment 2 is scored
Nothing here resolves to a percentage. Each criterion is placed at one of four levels, and the wording tells you what the code and the commentary have to show:
| Level | What it means on a class design deliverable |
|---|---|
| Distinguished | Responsibilities are divided so each class has one job, fields are private with accessors, the overriding is justified by what would happen when a new case is added, and the write-up names the alternative structure it rejected. Rejecting an alternative out loud is where the top level lives. |
| Proficient | A correct class structure with encapsulation and inheritance used properly. Sound design, one justification short of the column above. |
| Basic | Classes present but effectively containers, with the logic still living in main and the inheritance decorative. Where most first object designs land. |
| Non-performance | A required element is absent, commonly the accessors or the overridden method the prompt named. The row is graded on what is in the file. |
Static members belong to the class and instance members belong to an object, and mixing them produces compiler errors that read as mysterious until the distinction lands. Say which of your members are static and why, because the explanation costs a sentence and answers a row most submissions leave blank.
The IT-FPX2249 Assessment 2 method, step by step
-
List the nouns, then give each one a single job
Read the requirement and write down the things it talks about. Each becomes a candidate class, and each class earns its place by having one responsibility you can state in a sentence. A class you cannot describe without the word and is usually two classes, and splitting it before you code is far cheaper than splitting it afterwards.
-
Keep fields private and reach them through methods
Fields private, accessors for the ones that genuinely need reading, and no setter for anything that should not change after construction. Validate inside the constructor rather than trusting the caller. This is the cheapest encapsulation row on the guide and the one most often lost to a public field left in from a first draft.
-
Use inheritance only where the behaviour differs
One parent and one or two children is the expected depth. The test is simple: if the subtypes differ only in a value, a field will do, and if they differ in how something is computed, an overridden method is the right instrument. A hierarchy built for its own sake reads as decoration and the design row treats it that way.
-
Justify the structure by what a fourth case would cost
This is the sentence that lifts the criterion. Say what adding one more subtype costs in your design: one new class and no edits, against a switch statement that has to be found and extended in three methods. Naming the future cost turns a description of the structure into a defence of it.
-
Write comments that explain intent, not syntax
A documentation comment on each method saying what goes in, what comes back, and what it assumes. Nothing that restates the line beneath it. Where you adapted code from anywhere, put a comment above the adapted block naming the source and add it to the reference list, because unattributed borrowed code is an integrity problem before it is a formatting one.
-
Compile it clean, then self-score
Build from the command line at least once so an editor-specific project layout is not hiding a missing class, match any method signature the prompt fixed exactly, and turn off generated accessors where the rubric asked you to write them, since generated blocks are recognisable. Then grade each criterion yourself and submit early.
A structure that maps to the criteria
Planning lengths our tutors work to on an object design of this size rather than requirements from Capella; expand where your guide asks more.
| Section | What it must do | Guide |
|---|---|---|
| Requirement and responsibilities | What the program must do, and the one job each proposed class will own. | ~200 words |
| Class diagram or outline | Fields, methods and relationships, with visibility shown for every member. | ~220 words |
| Encapsulation decisions | What is private, what is exposed, and where validation happens. | ~200 words |
| Inheritance and overriding | The parent, the children, what each overrides, and why a field would not do instead. | ~280 words |
| The structure defended | What adding one more case costs in this design compared with the alternative you rejected. | ~220 words |
| Comments, evidence and references | Documentation comments, execution captures, and any adapted source attributed. | as needed |
Annotated sample excerpt
An original excerpt from our team showing how a hierarchy is defended rather than described. Take the reasoning and apply it to the objects in your own requirement.
A load arriving at the depot carries a ticket number, a weight and a container type, and the three container types differ only in how the tipping fee is computed, which is the shape that argues for a parent and three children rather than a switch statement sitting in main.1 The parent holds the ticket number and the weight as private fields with accessors and declares a fee method that each child overrides: the skip charges a flat rate, the roll-off charges by the ton, and the compactor charges by the ton with a minimum.2 Adding a fourth container type then costs one new class and no edit to any existing method, which is the sentence that belongs in the design section, because it is the reason the structure was chosen rather than a description of what the structure is.3
- 1Identifies what the subtypes actually share and what they do not, in one sentence, and names the alternative in the same breath. The comparison is what makes the design a decision.
- 2Shows encapsulation and overriding together, with each child's behaviour stated concretely. Three different fee rules are the evidence that an overridden method was the right instrument.
- 3Defends the structure by what a future change costs. This clause is the one that moves the design row, and it is three lines of writing rather than three hours of code.
The full premium sample for your exact assessment, written fresh to your scoring guide and issue, is free to request. Study it, revise it into your own voice, and submit work you understand.
The five mistakes that cost Distinguished
- Classes used as containers with the logic left in main. The decomposition row asks where the behaviour lives, and correct output cannot stand in for structure that is not there.
- A hierarchy where the subtypes differ only by a value. A field would have done the job, so the inheritance reads as decoration and the justification row goes unanswered.
- Public fields left in from an early draft. One of them undoes the encapsulation argument the rest of the write-up is making, and it is the first thing a reviewer greps for.
- Strings compared with the double equals operator. It tests whether two references point at the same object, so the comparison succeeds or fails for reasons unrelated to what was typed.
- Comments that restate the line below them. A comment adding no information is noise, and the documentation criterion is written about intent rather than about coverage.
Pre-submission checklist
- Each class has one responsibility you can state in a single sentence
- Fields private, with accessors only where reading is genuinely needed
- Validation performed in the constructor rather than trusted to the caller
- Overriding used only where behaviour differs, with the reason stated
- The structure defended by what adding one more case would cost
- Compiles cleanly from the command line, with any fixed signature matched exactly
Class design deliverable due?
Send the prompt, the criteria and any signature your prompt fixes. The sample returns in 24 to 48 hours with responsibilities divided, encapsulation intact, and the hierarchy defended by what a future case would cost. It compiles on your stated release before it leaves us, and faculty comments about structure come back into the same queue at no charge.