Exceptions only for exceptional scenarios
Exceptions are a way of causing the system to quickly alert the system of some unexpected scenario. However, some people might start using exceptions as a functionality of the system and start relying on the to convey acceptable scenarios.
Minimize scope of local variables.
Local variables should be contained within the smallest scope possible.
The most optimal solution is therefore to create the local variable the same place as it is used. Thereby increasing the readability of the code and minimizing the chance of misusing the variable.
Assert method arguments validity
Whenever an object is given in as a method argument, it should be asserted in terms of validity as the first thing.
This can be done with something as Objects.requireNonNull(arg), which will throw an exception if the argument is null.
Additionally, if you want to determine which arguments, should be allowed to be nullable, the @Nullable annotation can be used.
42. Prefer Lambdas To Anonymous Classes
When using event listeners, comparators, or simple interfaces, which promises one method implementation, it is valuable to use lambdas, since there is no need to use multiple lines of boilerplate code to call the only method available.
Use enums instead of integer constants
Before the introduction of enums, it was common practice to use integer constant values to indicate different variations of domain constants.
The composite design pattern is intended for structuring data classes with a relationship to each other. It categorizes the data as either a composite- or and leaf class, which determines whether other classes can be stored within the class. For this reason, it should come as no shock that it is a structural design pattern.
The Facade Pattern is based on the concept of simplifying activities. It allows us to wrap complex procedures in a facade class and afterwards utilize these procedures by one simple method call. For this reason it is categorized as a structural design pattern. ​
The Adapter Pattern is a simple, yet convenient, utility, which you will most certainly find good use of.
The pattern uses and interface and its implementation to create a layer around another object, which then allows the behavior of the object to be converted into a desired form.Â
The Command Pattern uses an object to represent a method (aka command), which can be call upon later by an invoker. This means that it will be possible to send methods around the system and call upon them whenever they are needed.Â
The Singleton Pattern is without a doubt the simplest, but also most powerful design patterns. It provides a one-way access to a class, which ensures that whenever this class is retrieved, that it will always be the same instance.
INTEGU uses cookies to personalize your experience and provide traceability for affiliate links. By using the website, you agree to these terms and conditions. To learn more see the privacy policy page.
