Problem: A class contains a collection field and a simple getter and setter for working with the collection.

Solution: Make the getter-returned value read-only and create methods for adding/deleting elements of the collection.

Problem: You have a coded type that affects behavior but you cannot use subclasses to get rid of it.

Solution: Replace type code with a state object. If it is necessary to replace a field value with type code, another state object is "plugged in".

Signs and Symptoms

Understanding and maintaining classes always costs time and money. So if a class doesn't do enough to earn your attention, it should be deleted.

Problem:
Calling a query method and passing its results as the parameters of another method, while that method could call the query directly.

Solution:
Instead of passing the value through a parameter, try placing a query call inside the method body.

Signs and Symptoms

• Use of primitives instead of small objects for simple tasks (such as currency, ranges, special strings for phone numbers, etc.)

• Use of constants for coding information (such as a constant USER_ADMIN_ROLE = 1 for referring to users with administrator rights.)

• Use of string constants as field names for use in data arrays.

Problem:
You get several values from an object and then pass them as parameters to a method.

Solution:
Instead, try passing the whole object.

Problem: So you have many identical instances of a single class that you need to replace with a single object.

Solution: Convert the identical objects to a single reference object.

Signs and Symptoms

A method is filled with explanatory comments.

Signs and Symptoms

A class contains many fields/methods/lines of code.

Signs and Symptoms

Two code fragments look almost identical.

Problem: A class has a field that contains type code. The values of this type are not used in operator conditions and do not affect the behavior of the program.

Solution: Create a new class and use its objects instead of the type code values.

Problem: You have an array that contains various types of data.

Solution: Replace the array with an object that will have separate fields for each element.

Problem: Your code uses a number that has a certain meaning to it.

Solution: Replace this number with a constant that has a human-readable name explaining the meaning of the number.

Problem

You use direct access to private fields inside a class.

Solution

Create a getter and setter for the field, and use only them for accessing the field.

Problem: A class (or group of classes) contains a data field. The field has its own behavior and associated data.

Solution: Create a new class, place the old field and its behavior in the class, and store the object of the class in the original class.

Problem:
The value of a field should be set only when it is created, and not change at any time after that.

Solution:
So remove methods that set the field's value.

Problem:
A method is not used by other classes or is used only inside its own class hierarchy.

Solution:
Make the method private or protected.

Problem: So you have many identical instances of a single class that you need to replace with a single object.

Solution: Convert the identical objects to a single reference object.

Problem

A method returns a special value that indicates an error?

Solution

Throw an exception instead.

Problem

You throw an exception in a place where a simple test would do the job?

Solution

Replace the exception with a condition test.

Signs and Symptoms

More than three or four parameters for a method.

Problem: Is domain data stored in classes responsible for the GUI?

Solution: Then it is a good idea to separate the data into separate classes, ensuring connection and synchronization between the domain class and the GUI.

Problem:
You have a complex constructor that does something more than just setting parameter values in object fields.

Solution:
Create a factory method and use it to replace constructor calls.

Signs and Symptoms

A method contains too many lines of code. Generally, any method longer than ten lines should make you start asking questions.

Problem: You have a coded type that directly affects program behavior (values of this field trigger various code in conditionals).

Solution: Create subclasses for each value of the coded type. Then extract the relevant behaviors from the original class to these subclasses. Replace the control flow code with polymorphism.

Problem:
A method is split into parts, each of which is run depending on the value of a parameter.

Solution:
Extract the individual parts of the method into their own methods and call them instead of the original method.

Problem: You have a public field.

Solution: Make the field private and create access methods for it.

Problem: You have subclasses differing only in their (constant-returning) methods.

Solution: Replace the methods with fields in the parent class and delete the subclasses.

Problem: You have a bidirectional association between classes, but one of the classes does not use the other's features.

Solution: Remove the unused association.

Signs and Symptoms

Sometimes different parts of the code contain identical groups of variables (such as parameters for connecting to a database). These clumps should be turned into their own classes.

Problem: You have two classes that each need to use the features of the other, but the association between them is only unidirectional.

Solution: Add the missing association to the class that needs it.

Problem: You have a reference object that is too small and infrequently changed to justify managing its life cycle.

Solution: Turn it into a value object.