Search

Primitive Obsession with Example


Primitive Obsession is the name of a code smell that occurs when we use primitive data types to represent domain ideas. For example, we use a string to represent a message or an integer to represent an amount of money.
For Example: Code with Primitive Obsession
// primitiveObsession.java

public
class primitiveObsession {

    public static void main(String args[]) {

           Integer[] cityPopulations = {

           13000000, // London

           21903623, // New York

           12570000, // Tokyo

           1932763, // Stockholm

           1605602, // Barcelona

           4119190 // Sydney

           };

 
           for (Integer cityPopulation:cityPopulations)

           {

              System.out.println(cityPopulation);
           }

   }

}


 

Example: Code without Primitive Obsession
//City.java

 

public class City {


private final String name;


private final int  population;


private final Continent continent;


public String getName() {
return name;

}


public int getPopulation() {


return  population;

}


public Continent getContinent() {


return continent;

}




public City(String name, int population, Continent continent) {


this.name = name;


this.population = population;


this.continent = continent;

}




public String toString() {


return String.format( "%s has a popluation of %s and is located in %s",


name, population, continent);

}


public static final City[] ALL_CITIES={


new City("London",13000000,Continent.EUROPE),


new City("New York",21903623,Continent.AMERICA),


new City("Tokyo",12570000,Continent.ASIA),


new City("Stockholm",1932763,Continent.EUROPE),


new City("Barcelona",1605602,Continent.EUROPE),


new City("Sydney",4119190,Continent.AUSTRALIA)

};

}



//Continent.java


public
enum Continent {


AMERICA,


EUROPE,


AFRICA,


ASIA,


AUSTRALIA

}

// withOutPrimitiveObsession.java

public class withOutPrimitiveObsession {

    public static void main(String args[]) {



        for (City city:City.ALL_CITIES) {

          System.out.println(city.toString());

        }

    }

}

Factory Pattern


  • This pattern is used when it must be decided at run time which one of several compatible classes is to be instantiated.
  • For example, the abstract Collator class's getInstance() method returns a collation object that is appropriate for the default locale, as determined by java.util.Locale.getDefault():
  • Like other locale-sensitive classes, you can use the static factory method, getInstance, to obtain the appropriate Collator object for a given locale. 
  • The following example shows how to compare two strings using the Collator for the default locale.
  • Compare two strings in the default locale
    • Collator myCollator = Collator.getInstance();
    • if( myCollator.compare("abc", "ABC") < 0 )
    • System.out.println("abc is less than ABC");
    • else
    • System.out.println("abc is greater than or equal to ABC");

Singleton Pattern

Lazy Initialization:-The instantiation of an object can be delayed until it is actually needed.

Usage: This especially beneficial when the constructor is doing a costly job like, accessing a remote database.

Example:

This code demonstrates how the Singleton pattern can be used to create a counter to provide unique sequential numbers, such as might be required for use as primary keys in a

Database:


 

Sequence.java


 

public class Sequence {

private static Sequence instance;

private static int counter;

private Sequence()

{

counter = 0; // May be necessary to obtain

// starting value elsewhere...

}

public static synchronized Sequence getInstance()

{

if(instance==null) // Lazy instantiation

{

instance = new Sequence();

}

return instance;

}

public static synchronized int getNext()

{

return ++counter;

}

}


 

Some things to note about this implementation:

  • Synchronized methods are used to ensure that the class is thread-safe.
  • This class cannot be subclassed because the constructor is private. This may or may not be a good thing depending on the resource being protected. To allow subclassing, the visibility of the constructor should be changed to protected.
  • Object serialization can cause problems; if a Singleton is serialized and then deserialized more than once, there will be multiple objects and not a singleton