DEV Community: Xavi

Design patterns in Java, a practical approach: The factory pattern

Xavi — Mon, 20 Jul 2020 18:51:29 +0000

The factory pattern is probably one of the most used patterns by software engineers, it provides a single point from where we can generate different implementations of a given class by any given conditions.

But there is a 'practical' in the title for a reason, so let's get our hands on the code, we will build an animal feeding service!

The Model

For our service to work, we need two things Animals and Food

Since there are lots of different animals and lots of different foods we will first implement their interfaces.

public interface Food {

}

public interface Animal {
    void eat(Food food);
}

We also defined a method in our interface so we make sure our animals can eat.

We have defined how food and animals should look like but right now we don't have anything real, let's change that.

In our feeding service we will be able to feed Cows, Dogs, and Rabbits:

public class Cow implements Animal {

    @Override
    public void eat(Food food) {
    }
}


public class Dog implements Animal {

    @Override
    public void eat(Food food) {
    }
}


public class Rabbit implements Animal {

    @Override
    public void eat(Food food) {
    }
}

We will also need food for every kind of animal:

public class CowFood implements Food {
}

public class DogFood implements Food {
}

public class RabbitFood implements Food {
}

Our Food Factory

Once we have our models we now need a way to get the proper food for each animal.

We can achieve this by using the factory pattern:

public class FoodFactory {

    public Food createFoodFor(Animal animal) {

        if (animal instanceof Rabbit)
            return new RabbitFood();

        if (animal instanceof Dog)
            return new DogFood();

        if (animal instanceof Cow)
            return new CowFood();

        throw new RuntimeException("We don't have food for your animal :(");
    }
}

In this factory, we will have one method that given any animal it will return the right food for them!!

But don't take my word for it, we can now implement the eat method on the animals to make sure they are getting their foods. This is what the implementation for the Cow class looks like:


public class Cow implements Animal {

    @Override
    public void eat(Food food) {

        if (food instanceof CowFood) {
            System.out.println("Cow: Yummy!");
        } else {
            throw new IndigestionException("That was bad..");
        }
    }
}

Putting it all together

We now can finally build our FeedingService:

public class FeedingService {

    private final FoodFactory foodFactory;

    public FeedingService() {
        this.foodFactory = new FoodFactory();
    }

    public void feedAnimal(Animal animal) {
        Food food = foodFactory.createFoodFor(animal);
        animal.eat(food);
    }
}

We now can feed ANY animal without even knowing which animal we have in our hands, the FoodFactory will get the right food so we can feed our animal right away.

We don't want upset animals in production so we test that everything works as planned:

    @Test
    void rabbit_does_not_get_an_indigestion() {
        Rabbit rabbit = new Rabbit();
        feedingService.feedAnimal(rabbit);
    }

    @Test
    void cow_does_not_get_an_indigestion() {
        Cow cow = new Cow();
        feedingService.feedAnimal(cow);
    }

    @Test
    void dog_does_not_get_an_indigestion() {
        Dog dog = new Dog();
        feedingService.feedAnimal(dog);
    }



>>> "Cow: Yummy!"
>>> "Cat: Yummy!"
>>> "Rabbit: Yummy!"

So that's about it! We got our feeding service up and running, powered by our food factory!

Feel free to leave questions in the comments.

You can find all the code used in this example here.

You also can follow me on twitter @xavigrimau.

What tools do you use to build your resume?

Xavi — Sun, 12 Apr 2020 16:14:41 +0000

In these times a lot of devs find ourselves updating our resume, either by necessity or "just in case". So I was curious about what is people using in this time to build their resumes, maybe a good old plain doc? Or some fancy illustrator template?

What is your prefered way to build a resume in 2020?

Java static and final, what are they and how to use them

Xavi — Tue, 21 Jan 2020 22:11:09 +0000

When I first started coding in Java I struggled to understand the differences between static and final, what were they or when to use them, so I decided to write a short summary for the newcomers.

To the point! Let's see how we can use them in our code.

The `final` keyword

It can be used in variables, methods, and classes.

Final variables

Final variables are intended to serve as constants, values that shouldn't (and won't) ever change:

    class Car {
        public final int numberOfWheels = 4; 
    }

Even if we wanted to modify this value, the compiler would throw an error:


Car myCar = new Car();
myCar.numberOfWheels = 1;

>>> The final field Car.numberOfWheels cannot be assigned

Final methods

Final methods cannot be overridden by any subclasses. Assume the class Car and the class Sedan:

class Car {

    public final int getNumberOfWheels() {
        return 4;
    }
}

class Sedan extends Car {

    // This won't work because the method getWeight is final!
    @Override
    public double getNumberOfWheels() {
        return 3;
    }
}

This can be useful in cases that, as the one described, the result or the behavior of the method should not change when called from subclasses.

Final classes

Using the final keyword in a class prevents it from being extended:

final class Pear {
    private double weight;
    private String color;
}

// This won't work because the Pear class is final! 
class MagicalPear extends Pear {

}

The `static` keyword

In Java, static simply implies that the field or method is not going to change its value or behavior across all the instances of an object.

In other words, that means that we can call it without instantiating the object we are using.

So, if we define a CurrencyConverter:

class CurrencyConverter {

    public static String EUR = "€";

    public static double convertDollarsToEuros(double amountInDollars) {
        double rate = 0.90; 
        return amountInDollars * rate;
    }
}

We can then call the convertDollarsToEuros method without declaring any instance of the class:

System.out.println(CurrencyConverter.convertDollarsToEuros(5.43D));

CurrencyConverter converter = new CurrencyConverter();
System.out.print(converter.convertDollarsToEuros(5.43D));

>>> 4.887
>>> 4.887

In the same way, we can call the static variable EUR without instantiating the object and, unlike final variables, we can even modify it.

But that we can do it doesn't mean that we should, as its considered bad practice to modify static variables.

That's why more often than not, static variables are also final:

public static final String EUR = "€"

Hopefully, we now understand a little bit better the differences between those two keywords as well as when to use them.

Suggestions and constructive criticism are always welcome!