Singleton na enumie

0
enum Singleton
{
    INSTANCE;

    // instance vars, constructor
    private final Connection connection;

    Singleton()
    {
        // Initialize the connection
        connection = DB.getConnection();
    }

    // Static getter
    public static Singleton getInstance()
    {
        return INSTANCE;
    }

    public Connection getConnection()
    {
        return connection;
    }
}

Wywołanie:

final Singleton s = Singleton.getInstance()

Czy może ktoś wyjaśnić jak to działa? Rozumiem, że metoda statyczna robi return INSTANCE;

Ale co to zwraca. Skąd wiemy co znajduje się pod INSTANCE.

A jakby były tam dwa typy enumeryczne czyli np. INSTANCE, ABCD i jeszcze jedna metoda getABCD();

Co się dzieje dalej, bo nie jest to jawnie powiedziane w kodzie. I nie ciśnijcie mnie za bardzo :D

0

http://stackoverflow.com/questions/26285520/implementing-singleton-with-an-enum-in-java

An enum type is a special type of class type.

Your enum declaration actually compiles to something like

public final class MySingleton {
public final static MySingleton INSTANCE = new MySingleton();
}
When your code first accesses INSTANCE, the class MySingleton will be loaded and initialized by the JVM. This process initializes the static field above once (lazily).

(..)

In this Java best practices book by Joshua Bloch, you can find explained why you should enforce the Singleton property with a private constructor or an Enum type. The chapter is quite long, so keeping it summarized:

Making a class a Singleton can make it difficult to test its clients, as it’s impossible to substitute a mock implementation for a singleton unless it implements an interface that serves as its type. Recommended approach is implement Singletons by simply make an enum type with one element:

// Enum singleton - the preferred approach
public enum Elvis {
INSTANCE;
public void leaveTheBuilding() { ... }
}
This approach is functionally equivalent to the public field approach, except that it is more concise, provides the serialization machinery for free, and provides an ironclad guarantee against multiple instantiation, even in the face of sophisticated serialization or reflection attacks.

While this approach has yet to be widely adopted, a single-element enum type is the best way to implement a singleton.

0

Każdy enum w javie jest singletonem out-of-box. Singleton ten może zawierać proste metody np. robiące obliczenia. Jest to spoko opisane w effective java.

0

Warto dodać, że jest to zalecany sposób tworzenia singletona w Javie. Poleca go znana osobowość w Javie - Joshua Bloch.

0

Nie jestem ekspertem, ale wydaje mi sie, że można to rozumieć w ten sposób:


public class Main {

    public static void main(String[] args) {

        System.out.println(TestEnum.TEST); // TEST
        System.out.println(TestEnum.TEST.test()); // Enum Test

        System.out.println(TestEnumClass.TEST); //  TEST
        System.out.println(TestEnumClass.TEST.test()); // Enum Test Clas

    }

}

enum TestEnum {
    TEST;

    public static String test() {
        return "Enum Test";
    }
}

class TestEnumClass {
    public static final TestEnumClass TEST = new TestEnumClass() {
        @Override public String toString() {
            return "TEST";
        }
    };

    public static String test() {
        return "Enum Test Class";
    }
}

Dlatego możesz wywołać sobie metodę na zwróconej instancji. Gdybyś dodał kolejne ABCD i zrobił get to:


public class Main {

    public static void main(String[] args) {

        final Singleton s = Singleton.getInstance();
        final Singleton abcd_s = Singleton.getInstance();

        System.out.println(s.getConnection());
        System.out.println(abcd_s.getConnection());
    }

}

enum Singleton
{
    INSTANCE, ABCD;

    // instance vars, constructor
    private final String connection;

    Singleton()
    {
        // Initialize the connection
        connection =  "returning conneciton...";
    }

    // Static getter
    public static Singleton getInstance()
    {
        return INSTANCE;
    }

    // Static getter
    public static Singleton getABCD()
    {
        return ABCD;
    }

    public String getConnection()
    {
        return connection;
    }
}

da ci :

returning conneciton...
returning conneciton...

Jak dobierasz się do INSTANCE to jest wywoływany konstruktor.


public class Main {

    public static void main(String[] args) {
        System.out.print(Singleton.INSTANCE);
    }

}

enum Singleton
{
    INSTANCE;

    Singleton()
    {
        System.out.println("Hello constructor");
    }

    // Static getter
    public static Singleton getInstance()
    {
        return INSTANCE;
    }
}

// Hello constructor
// INSTANCE

1 użytkowników online, w tym zalogowanych: 0, gości: 1