Translating the kingdom example above. First of all we have some interfaces and implementation for the objects in the kingdom

public interface Castle {

String getDescription();

}

Then we have the abstraction and implementations for the kingdom factory

public interface KingdomFactory {

Castle createCastle();

King createKing();

Now we have our abstract factory that lets us make family of related objects i.e. Elven kingdom factory creates Elven castle, king and army etc.

KingdomFactory factory = new ElfKingdomFactory();

Castle castle = factory.createCastle();

King king = factory.createKing();

The client can use FactoryMaker to create the desired concrete factory which, in turn, will produce different concrete objects (Army, King, Castle).

In this example, we also used an enum to parameterize which type of kingdom factory the client will ask for.

public static class FactoryMaker {

public enum KingdomType {

First we have interfaces `RowingBoat` and `FishingBoat`

public interface RowingBoat {

void row();

}

And captain expects an implementation of `RowingBoat` interface to be able to move

public class Captain implements RowingBoat {

private RowingBoat rowingBoat;

Now let's say the pirates are coming and our captain needs to escape but there is only fishing boat available. We need to create an adapter that allows the captain to operate the fishing boat with his rowing boat skills.

public class FishingBoatAdapter implements RowingBoat {

private static final Logger LOGGER = LoggerFactory.getLogger(FishingBoatAdapter.class);

And now the `Captain` can use the `FishingBoat` to escape the pirates.

Captain captain = new Captain(new FishingBoatAdapter());

captain.row();

Translating our weapon example from above. Here we have the `Weapon` hierarchy

public interface Weapon {

void wield();

void swing();

And the separate enchantment hierarchy

public interface Enchantment {

void onActivate();

void apply();

And both the hierarchies in action

Sword enchantedSword = new Sword(new SoulEatingEnchantment());

enchantedSword.wield();

enchantedSword.swing();

Having said that let me add a bit about what telescoping constructor anti-pattern is. At one point or the other we have all seen a constructor like below:

public Hero(Profession profession, String name, HairType hairType, HairColor hairColor, Armor armor, Weapon weapon) {

}

The sane alternative is to use the Builder pattern. First of all we have our hero that we want to create

public final class Hero {

private final Profession profession;

private final String name;

And then we have the builder

public static class Builder {

private final Profession profession;

private final String name;

And then it can be used as:

Hero mage = new Hero.Builder(Profession.MAGE, "Riobard").withHairColor(HairColor.BLACK).withWeapon(Weapon.DAGGER).build();

Translating our example with orcs from above. First we have the request class

public class Request {

private final RequestType requestType;

Then the request handler hierarchy

public abstract class RequestHandler {

private static final Logger LOGGER = LoggerFactory.getLogger(RequestHandler.class);

private RequestHandler next;

Then we have the Orc King who gives the orders and forms the chain

public class OrcKing {

RequestHandler chain;

Then it is used as follows

Taking our sentence example from above. Here we have the base class and different printable types

public abstract class LetterComposite {

private List<LetterComposite> children = new ArrayList<>();

public void add(LetterComposite letter) {

Then we have a messenger to carry messages

public class Messenger {

LetterComposite messageFromOrcs() {

List<Word> words = new ArrayList<>();

And then it can be used as

LetterComposite orcMessage = new Messenger().messageFromOrcs();

orcMessage.print(); // Where there is a whip there is a way.

LetterComposite elfMessage = new Messenger().messageFromElves();

Let's take the troll example. First of all we have a simple troll implementing the troll interface

public interface Troll {

void attack();

int getAttackPower();

Next we want to add club for the troll. We can do it dynamically by using a decorator

public class ClubbedTroll implements Troll {

private static final Logger LOGGER = LoggerFactory.getLogger(ClubbedTroll.class);

Here's the troll in action

Troll troll = new SimpleTroll();

troll.attack(); // The troll tries to grab you!

Taking our goldmine example from above. Here we have the dwarven mine worker hierarchy

public abstract class DwarvenMineWorker {

private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenMineWorker.class);

To operate all these goldmine workers we have the facade

public class DwarvenGoldmineFacade {

private final List<DwarvenMineWorker> workers;

Now to use the facade

DwarvenGoldmineFacade facade = new DwarvenGoldmineFacade();

facade.startNewDay();

Taking our blacksmith example above. First of all we have a blacksmith interface and some implementations for it

public interface Blacksmith {

Weapon manufactureWeapon(WeaponType weaponType);

}

Now as the customers come the correct type of blacksmith is summoned and requested weapons are manufactured

Blacksmith blacksmith = new ElfBlacksmith();

blacksmith.manufactureWeapon(WeaponType.SPEAR);

blacksmith.manufactureWeapon(WeaponType.AXE);

Translating our alchemist shop example from above. First of all we have different potion types

public interface Potion {

void drink();

}

Then the actual Flyweight object which is the factory for creating potions

public class PotionFactory {

private final Map<PotionType, Potion> potions;

And it can be used as below

PotionFactory factory = new PotionFactory();

factory.createPotion(PotionType.INVISIBILITY).drink(); // You become invisible. (Potion=6566818)

factory.createPotion(PotionType.HEALING).drink(); // You feel healed. (Potion=648129364)