CODEWITHSUNDEEP
javaenumsconstants
VladYev
VladYev

Reputation: 51

Using Enum to hold object constants

So I've learned a bunch recently so I'm going back and sort of refactoring the homeworks from a previous course that I took to implement them using good practices. One homework had us implement a Planner object that contained an array of Course objects. I'm trying to create some Course constants so that I can access some popular Courses without having to create brand new Objects every time and so I can easily access them without going through the Course building process. I don't have much experience with enums and I can't seem to find anything on how I can actually use an Enum to store constants that are Objects. I originally wanted to make them constants in the Course class but Effective Java insists enumns should be used in such a situation. Does my implementation make sense at all? How should I go about making this enum that contains Course constants so I can actually retrieve them? I use the Builder method for creating a Course.

public enum Courses {
    CSE_114, CSE_214, CSE_219, CSE_215;

    private final static Course CSE_114_COURSE = new Course
        .Builder("Computer Science 1", "Paul Fodor", 114)
        .section((byte)1).department("CSE").build();

    private static final Course CSE_214_COURSE = new Course
        .Builder("Data Structures", "Ahmad Esmaili", 214)
        .section((byte)1).department("CSE").build();

    private static final Course CSE_219_COURSE = new Course
        .Builder("Software Development", "Richard McKenna", 219)
        .section((byte)1).department("CSE").build();

    private static final Course CSE_215_COURSE = new Course
        .Builder("Foundations of CS", "Paul Fodor", 215)
        .section((byte)1).department("CSE").build();

    public static Course get(Courses c) {
        switch(c) {
            case CSE_114: return CSE_114_COURSE;
            case CSE_214: return CSE_214_COURSE;
            case CSE_219: return CSE_219_COURSE;
            case CSE_215: return CSE_215_COURSE;
            default: throw new IllegalArgumentException("Course does not exist.");
    }
}
}

Upvotes: 5

Views: 5023

Answers (3)

Andrew Williamson
Andrew Williamson

Reputation: 8696

You can actually treat an enum like an object:

public enum Course {
    CSE_114("Computer Science 1", "Paul Fodor");

    public final String room;
    public final String lecturer;

    private Course(room, lecturer) {
        this.room = room;
        this.lecturer = lecturer;
    }
}

Because it is an enum, all values must be known at compile time. This is enforced by the Java language, which requires that the enum constructor is private.

While this would work for your situation, I don't recommend it - in fact, I don't recommend using an enum at all. An enum represents a fixed, known set of values. If you want to create more courses at runtime, then the enum is incomplete, and that contradicts the definition of an enum.

Instead, I suggest you use a CourseManager. Create one class, which holds the collection of all known courses. Then, when you need a course, you request it by name.

Course cs114 = courses.get("CS 114");

You could also take it one step further, by instantiating the CourseManager from a file, which contains a list of courses in a basic format like JSON.

Upvotes: 6

awsome
awsome

Reputation: 2153

You are mixing enum constants with static constants. Get these courses and selection of courses out of the enum class. Or you can use something like Andrew Williamson showed. Just don't mix the static constants with the enums. Static constants don't belong to the enum class. Enum class has a fixed set of values and that is where its role ends. All the other logic using these enums should be done somewhere else

Upvotes: 1

Alberto S.
Alberto S.

Reputation: 7649

That's not a bad implementation but I think a have a bit better solution: add an abstract method to your enum definition.

public enum Courses {
    CSE_114 {
        public Course getCourse() {
            return CSE_114_COURSE;
        }
    }
    ...

    private final static Course CSE_114_COURSE = new Course
        .Builder("Computer Science 1", "Paul Fodor", 114)
        .section((byte)1).department("CSE").build();

    ...

    public abstract Course getCourse();

}

That way you can access to any course object vía Courses.CSE_114.getCourse() and you are also forcing that every enum has a course (imagine that you add an enum constant but forgot to add it in the get method. The way I proposed makes that scenario non sense)

Upvotes: 1

Related Questions