Java Programming Enumerations And Interfaces Complete Guide

Java Programming: Enumerations and Interfaces

Enumerations

Declaring an Enumeration: To declare an enum in Java, you need to use the enum keyword followed by the name of the enum. Each enum constant is separated by a comma.

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

Using Enumerations: You can use enums just like any other data type in Java. They can be assigned to variables, passed as arguments to methods, and can be used in switch-case statements.

public class EnumExample {
    Day day;  
    public EnumExample(Day day) {
        this.day = day;
    }

    public void tellItLikeItIs() {
        switch (day) {
            case MONDAY:
                System.out.println("Mondays are blue.");
                break;
            case FRIDAY:
                System.out.println("Fridays are better.");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("Weekends are best.");
                break;
            default:
                System.out.println("Midweek days are so-so.");
                break;
        }
    }
}

public static void main(String[] args) {
    EnumExample firstDay = new EnumExample(Day.MONDAY);
    firstDay.tellItLikeItIs();
    EnumExample thirdDay = new EnumExample(Day.WEDNESDAY);
    thirdDay.tellItLikeItIs();
    EnumExample fifthDay = new EnumExample(Day.FRIDAY);
    fifthDay.tellItLikeItIs();
    EnumExample sixthDay = new EnumExample(Day.SATURDAY);
    sixthDay.tellItLikeItIs();
    EnumExample seventhDay = new EnumExample(Day.SUNDAY);
    seventhDay.tellItLikeItIs();
}

Enum Methods and Fields: Enums can also have instance fields, constructors, and methods. Unlike static constants, enums can maintain separate copies of enum constants and are more powerful.

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    private final double mass;   // in kilograms
    private final double radius; // in meters

    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }

    public double mass() { return mass; }
    public double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }

    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

Enum Utility Methods: Java enums come with several utility methods.

• values(): Returns an array containing all the values of the enum.
• valueOf(String name): Returns the enum constant of the specified string value.
• ordinal(): Returns the ordinal (position in declaration) of this enum constant.

Interfaces

Interfaces in Java are used to support the concept of Multiple Inheritance. An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance fields. The methods in interfaces are abstract by default.

Declaring an Interface: To declare an interface, use the interface keyword and then the name of the interface.

interface Animal {
    void eat();
    void travel();
}

Implementing an Interface: A class implements an interface, thereby inheriting the abstract methods of the interface.

public class MammalInt implements Animal {

    @Override
    public void eat() {
        System.out.println("Mammal eats");
    }

    @Override
    public void travel() {
        System.out.println("Mammal travels");
    } 

    public int numberOfLegs() {
        return 4;
    }

    public static void main(String args[]) {
        MammalInt m = new MammalInt();
        m.eat();
        m.travel();
    } 
}

Interface Methods:

• Abstract Methods: Traditional interface methods that do not have an implementation. Each class that implements the interface must implement every method declared without an implementation.
• Default Methods: Introduced in Java 8, default methods have an implementation and can be overridden by a class implementing the interface.
• Static Methods: Introduced in Java 8, static methods are defined in an interface and can be accessed directly by the interface name, without creating an instance of the interface.
• Private Methods: Introduced in Java 9, private methods can only be used by default or static methods of the same interface.

interface Vehicle {
    // Abstract method
    void start();

    // Default method
    default void stop() {
        System.out.println("Vehicle stops");
    }

    // Static method
    static void honk() {
        System.out.println("Honk honk");
    }

    // Private method
    private void checkValve() {
        System.out.println("Checking valve");
    }
}

Multiple Interfaces: A class can implement multiple interfaces, which provides for multiple inheritance. Interfaces can extend other interfaces, and classes can implement multiple interfaces simultaneously.

References:

• Java SE Documentation: Enums
• Java SE Documentation: Interfaces