Creating object from enum reference

Question

If I have a standard enum (in this example a representation of a list of buildings) such as this:

public enum BuildingType {
   farm, shop, house
}

and a function that creates objects based on a "building" superclass such as:

public void addBuilding(BuildingType bType) {
   Building b = new Building();
   b.start();
}

All of my subclasses have names matching the BuildingType enum. Is there a way that I can use my enum parameter to set the class of object b without a class statement?

clearly incorrectly, but something like this

Building b = new bType(); //using the argument

Thanks as always.

Bohemian · Accepted Answer · 2014-02-17 00:52:02Z

2

You can define an enum that is also a factory:

public enum BuildingType {
    farm(Farm.class),
    shop(Shop.class),
    house(House.class);
    private Class<? extends Building> clazz;
    private BuildingType(Class<? extends Building> clazz) {
        this.clazz = clazz;
    }

    public Building createBuilding() {
        try {
            return clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(clazz + " has no default constructor");
        }
    }
}

Or slightly more code, but avoiding reflection, make the enum class an abstract factory and let the instances be factories:

public enum BuildingType {
    farm() {
        public Building createBuilding() {
            return new Farm();
        }
    },
    shop() {
        public Building createBuilding() {
            return new Shop();
        }
    },
    house() {
        public Building createBuilding() {
            return new House();
        }
    };

    public abstract Building createBuilding();
}

Either way, to use:

public void addBuilding(BuildingType bType) {
   Building b = bType.createBuilding();
   b.start();
}

edited Feb 17, 2014 at 0:52

answered Feb 16, 2014 at 14:08

Bohemian♦

427k103 gold badges603 silver badges750 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Katona Over a year ago

Is there any reason using reflection? The enums could simply instantiate the buildings with constructor, right?

Bohemian Over a year ago

@katona you couldn't do it in the constructor, because then you would return the same Building instance every time, but you could do it with an abstract factory pattern on the enum and have the enums themselves be the factories. See updated answer.

TrewTzu Over a year ago

Great answer. Is there a reason to avoid reflection? i don't have any experience with it.

Bohemian Over a year ago

@TrewTzu reflection is in general "less safe", because the compiler can't check most operations. In this example, the call to newInstance() assumes a default constructor exists. If one doesn't (which may become the case in the future), an exception is thrown at runtime, whereas in the non-reflection version, problems are detected at compile time (much easier to detect and fix). Further, construction can be tailored for each type, eg return new House(3); eg for 3 bedrooms or whatever, or even be locale based, or even delegate to an injected factory.

Katona Over a year ago

Happy to see the update, that is exactly what I meant in my previous comment. Using constructor makes it less readable though... Great answer anyway!

Smutje · Accepted Answer · 2014-02-16 13:31:30Z

0

It would be a more OO appropriate way, if the different behaviour of buildings would be represented in a class hierarchy rather than enum literals - i.e., having a FarmBuilding, a ShopBuilding and a HouseBuilding sub class of a Building abstract base class implementing the Building specific behaviour.

answered Feb 16, 2014 at 13:31

Smutje

18.2k4 gold badges26 silver badges42 bronze badges

Comments

ug_ · Accepted Answer · 2014-02-16 13:34:01Z

0

You could create a parameter that declares what class type each enum is referencing to. It could look like this:

// Enums should be all caps btw
public enum BuildingType {
   FARM(Farm.class), SHOP(Shop.class), HOUSE(House.class);
   private Class<? extends Building> type;
   private BuildingType(Class<? extends Building> type) {
       this.type = type;
   }

   public Class<? extends Building> getType() {
       return type;
   }
}

you could then create a new instance of that class when you need.

Building myBuilding = BuildingType.FARM.getType().newInstance();

This sample assumes you have a default no arguments constructor for your class as well so watch out for that.

answered Feb 16, 2014 at 13:34

ug_

11.5k2 gold badges37 silver badges56 bronze badges

2 Comments

Katona Over a year ago

What about unifying this with the abstract factory design pattern, i.e. let the enums create the buildings?

ug_ Over a year ago

@Katona I think this style of class in enum for any factory style design pattern isnt ideal. Fixing your creatable types inside an enum is a shutdown switch for any further hierarchy someone else may want to put on top. If your in a set enviroment like a game its whatever but if your building a framework of some kind I dont think it would be a good idea. Especially because its really not necessary.

over9k · Accepted Answer · 2014-02-16 13:39:14Z

0

I recommend you to read about design patterns and especially about Factory pattern. Here is a wiki link http://en.wikipedia.org/wiki/Software_design_pattern , but you can find a ton of examples in the internet. For example

BuildingFactory bf = BuildingFactory.newInstance();
Building b = bf.createBuilding(bType);

and in createBuilding method:

// return Building superclass which you can cast to specific type

public Building createBuilding(BuildingType bType) {
 if(bType == something) {
    return new FarmBuilding();
 }
 else if(...) {
    return something else;
 }
}

answered Feb 16, 2014 at 13:39

over9k

1151 silver badge10 bronze badges

1 Comment

Rob Over a year ago

There is no design pattern Factory. There's Factory Method, Abstract Factory, no just Factory...

Saclyr Barlonium · Accepted Answer · 2016-10-27 10:50:49Z

Like some answers above state, you could use an abstract method to implement them on the Enums. Unlike many say, you CAN use reflection to instantiate an Object with parameters, like this:

public enum BuildingType {
    FARM(Farm.class), SHOP(Shop.class), HOUSE(House.class);

    private final Class<? extends Building> buildingType;

    private BuildingType(Class<? extends Building> buildingType ) {
        this.buildingType = buildingType;
    }

    public Building getBuilding( Furniture... furniture ) {
        Building building = null;
        try {
            Constructor<? extends Building> constructor = 
                    ( Constructor<? extends Building> ) buildingType.getDeclaredConstructor( Furniture[].class );
            building = constructor.newInstance( furniture );
        }
        catch ( NoSuchMethodException | SecurityException | 
                InstantiationException | IllegalAccessException | 
                IllegalArgumentException | InvocationTargetException ex ) {
            //I have a method to handle exceptions, you could do the same, 
            //but in principle it shouldn't be necessary.
            //handleExceptionsGracefully(...);
        }

        return building;
    }
}

For more on reflection, I advise you to read this from O'reilly: http://chimera.labs.oreilly.com/books/1234000001805/ch07.html#learnjava3-CHP-7-SECT-2

And to Bohemian: for convention, Java Enums should be Upercase, and if you don't have arguments in Enums, you can remove the parentheses.

I hope I have helped.

Have a nice day. :)

Collectives™ on Stack Overflow

Creating object from enum reference

5 Answers 5

5 Comments

Comments

2 Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

5 Comments

Comments

2 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related