枚举列表与布尔类的列表

Question

For now, I have a class with fields.

@Entity
public class Fuel {

    @Id @GeneratedValue
    private Long id;

    private boolean diesel;
    private boolean gasoline;
    private boolean etanhol;
    private boolean cng;
    private boolean electric;

    public Fuel() {
        // this form used by Hibernate
    }

    public List<String> getDeclaredFields() {
        List<String> fieldList = new ArrayList<String>();

        for(Field field : Fuel.class.getDeclaredFields()){
            if(!field.getName().contains("_") && !field.getName().equals("id") && !field.getName().equals("serialVersionUID") ) {
                fieldList.add(field.getName());

            }
            Collections.sort(fieldList);
        }
        return fieldList;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public boolean isDiesel() {
        return diesel;
    }

    public void setDiesel(boolean diesel) {
        this.diesel = diesel;
    }

    public boolean isGasoline() {
        return gasoline;
    }

    public void setGasoline(boolean gasoline) {
        this.gasoline = gasoline;
    }

    public boolean isEtanhol() {
        return etanhol;
    }

    public void setEtanhol(boolean etanhol) {
        this.etanhol = etanhol;
    }

    public boolean isCng() {
        return cng;
    }

    public void setCng(boolean cng) {
        this.cng = cng;
    }

    public boolean isElectric() {
        return electric;
    }

    public void setElectric(boolean electric) {
        this.electric = electric;
    }   

}

I think it makes sense, but when I asked another question (maybe a stupid example since there can only be either automatic or manual gearbox) https://stackoverflow.com/questions/11747644/selectonemenu-from-declared-fields-list-in-pojo , a user recommend me to use enums instead. Like this way:

public enum Fuel {
    DIESEL("diesel"),
    GASOLINE("gasoline"),
    ETANHOL("etanhol"),
    CNG("cng"),
    ELECTRIC("electric");

    private String label;

    private Fuel(String label) {
        this.label = label;
    }

    public String getLabel() {
        return label;
    }

}

However, since there exists hybrids on the market (like Toyota Prius) the parent class would implement the boolean class at this way:

private Fuel fuel = new Fuel();

and if using enumerated list at this way:

private List<Fuel> fuelList = new ArrayList<Fuel>();

What is the best practice? Keep in mind that I might have 100 different fuels (just for example =). Do not forget that it is an entity and hence persisted in a database.

Thanks in advance =)

Answer 1

It sounds to me like you want an EnumSet, yes, definitely over a bunch of bool's.

This reminds me a lot of the design patterns for flags and I recently posted an SO question on exactly that: Proper design pattern for passing flags to an object

This supports having 100 different fuel types easily. However it doesn't support a car using 100 different fuel types simultaneously easily. But that to me sounds perfectly fine - it would be very hard to build such a car and this is perfectly reflected in the programmatic complexity of coding this :) (Unless of course it really was just supporting all corn-based fuels - in which you might prefer a polymorphic pattern.)

Answer 2

You should definetly use enums.

Image you want to get the fuel-type of an object.

If you would use bools you would end up with something like this:

if (myClass.IsGasoline())
else if (myClass.IsOtherFuel())
else if
...

If you use enums you can simply do something like:

Fuel fuel = myClass.GetFuelType()

(This is just pseudo-code ;))

Answer 3

If the number of hybrids is low, and I guess it will be better to use Enums, and include hybrids as a different case. Otherwise you will have to manage the logic in a way that can be cumbersome, as when you set a certain Fuel to true you, most likely, will have also to set to false the current one set to true. I am saying this as you have setters for your fuel categories and you don't only define at construction.

EDIT: the way on how to ask for the type of fuel you are using would also be an argument in favor of enums.