Czy konstruktorzy zawsze muszą być jawni? [duplikat]

Tak, konstruktory mogą mieć dowolny access specifier/access modifier.

Konstruktory prywatne są przydatne do tworzenia klas singleton.

Singleton - klasa singleton jest klasą, w której można utworzyć tylko jeden obiekt w czasie wykonywania (na JVM).

Prostym przykładem klasy singleton jest -

class Ex {
    private static Ex instance;
    int a;
    private Ex() {
        a = 10;
    }
    public static Ex getInstance() {
        if(instance == null) {
            instance = new Ex();
        }
        return instance;
    }
}

Uwaga, dla powyższej klasy, jedynym sposobem uzyskania obiektu (poza tą klasą) jest wywołanie funkcji getInstance (), która utworzyłaby tylko jedną instancja i zwracaj to dalej.

Należy również pamiętać, że nie jest to bezpieczne dla wątków.

Konstruktory mogą być publiczne, domyślne lub prywatne i wszystko zależy od tego, co chcesz z nimi zrobić.

Na przykład, jeśli definiujesz klasę Singleton, lepiej Ukryj konstruktor (co oznacza uczynienie go prywatnym, aby był dostępny tylko dla klasy, do której należy), aby uniemożliwić innym klasom tworzenie instancji twojej klasy według ich woli.

Możesz chcieć zadeklarować wartość domyślną, powiedzmy, dla celów testowych, aby przypadki testowe w tym samym pakiecie mogły uzyskaj dostęp.

Bardziej szczegółowe informacje można znaleźć tutaj

Nie ma reguły, aby konstruktor był publiczny .Ogólnie definiujemy go jako publiczny tylko dlatego, że chcielibyśmy utworzyć instancję z innych klas .

Prywatny konstruktor oznacza: "nie pozwalam nikomu tworzyć mojej instancji poza mną". Więc zwykle robisz to, gdy chcesz mieć wzór Singletona.

Poniżej znajduje się klasa w JDK, która używa prywatnego konstruktora .

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    // Don't let anyone else instantiate this class
    private Runtime() {
    }
}

Nie,konstruktory mogą używać dowolnego modyfikatora dostępu, w tym prywatnego. (Prywatny konstruktor oznacza, że tylko kod wewnątrz samej klasy może utworzyć instancję obiektu tego typu, więc jeśli Klasa prywatnego konstruktora chce zezwolić na wystąpienie klasa, która ma być użyta, musi zapewniać statyczną metodę lub zmienną, która umożliwia dostęp do instancji utworzonej z poziomu klasy.)

Przykład

class Alpha {
   static String s = " ";
   protected Alpha() { s += "alpha "; }
 }
 class SubAlpha extends Alpha {
   private SubAlpha() { s += "sub "; }
 }
 public class SubSubAlpha extends Alpha {
   private SubSubAlpha() { s += "subsub "; }
   public static void main(String[] args) {
     new SubSubAlpha();
     System.out.println(s);
   }
 }

Wyjście powyższego programu będzie

Alpha subsub

Konstruktory mogą mieć wszelkiego rodzaju modyfikatory dostępu. Użycie różnych modyfikatorów dostępu na konstruktorach jest różne.

Tworzysz konstruktor public, jeśli chcesz, aby klasa została utworzona z dowolnego miejsca.

Tworzysz konstruktor protected jeśli chcesz, aby klasa była dziedziczona, a jej dziedziczone klasy były instancjonowane.

Tworzysz konstruktor private jeśli chcesz, aby klasa była tworzona z własnych elementów, zwykle jako statyczny blok lub statyczna metoda. Informatyka oznacza to, że przejmujesz kontrolę nad tworzeniem instancji klasy i stosujesz pewną regułę dotyczącą tworzenia instancji. Przykładem użycia prywatnego konstruktora jest singleton design pattern.

Zgadzam się z poprzednimi odpowiedziami, że Singleton jest dobrym przykładem klasy posiadającej prywatny konstruktor. Polecam jednak inną implementację: a thread safe Singleton:

/**
 * Thread safe singleton
 */
public class Singleton {

    private static volatile Singleton instance = null;

    /**
     * Private constructor
     */
    private Singleton() {
    }

    /**
     * Gets the Instance of the Singleton in a thread safe way.
     * @return
     */
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Używanie Singletona w bezpieczny sposób wątku zabezpieczy Cię wiele bólu w kodzie równoległym.

Konstruktor ma być przynajmniej chroniony lub nawet prywatny podczas tworzenia, na przykład, niestandardowych klas fabrycznych, takich jak:

public final class MyFactory {
  private MyFactory(){} // this one prevents instances of your factory
}

public static void doSomething(){} // access that with MyFactory.doSomething

Zauważ, że jest to tylko jeden przykład pokazujący, kiedy konstruktor nie powinien być publiczny.

Większość z tych odpowiedzi odnosi się do klasy singleton lub factory. Innym razem, gdy pojawia się prywatny konstruktor, jest (na przykład) w java.lang.Klasa matematyczna , gdzie wszystko jest statyczne i nikt nigdy nie powinien wywoływać konstruktora (łącznie z samą klasą). Posiadając prywatny konstruktor, uniemożliwiasz komukolwiek spoza klasy wywołanie konstruktora. (To nie uniemożliwia komuś wewnątrz klasy wywołania konstruktora, ale potem łamie własną regułę.)

Inni zauważyli, że konstruktory mogą mieć modyfikatory dostępu; aspekt jeszcze nie wymieniony jest, że modyfikatory aspektu w konstruktorze kontrolują dwa bardzo różne aspekty budowy, ale nie pozwalają na ich oddzielne sterowanie: {18]}

1. kto może tworzyć instancje z ClassName i jakich konstruktorów może używać.
2. kto może tworzyć rozszerzenia z ClassName i jakie konstruktory mogą użyj.

Zarówno Java, jak i. NET wymagają, aby odpowiedzi na te dwa pytania były razem; jeśli klasa nie jest final (lub sealed) i pozwala konstruktorowi na użycie zewnętrznego kodu do tworzenia nowych instancji, to Zewnętrzny kod będzie miał całkowitą swobodę używania tego samego konstruktora do tworzenia typów pochodnych.

W wielu przypadkach może być właściwe, aby klasa miała tylko konstruktory package-private (internal), ale wystawiała publiczne metody zwracające nowe instancje. Taki metoda może być użyta, jeśli projektuje się od podstaw Typ typu String; pakiet zawierający {[5] } może zdefiniować go jako typ abstrakcyjny, ale zawiera konkretne typy pochodne, takie jak AsciiString i UCS16String, które przechowują swoją zawartość odpowiednio jako byte[] i Char[]; metody zwracające String mogą następnie zwrócić jeden z pochodnych w zależności od tego, czy łańcuch zawiera znaki spoza zakresu ASCII. Jeśli ani String, ani żadne typy pochodne nie ujawniają żadnych konstruktorów poza swoim pakietem, a wszystkie typy pochodne w pakiecie zachowują się jak łańcuch znaków, wtedy kod, który otrzymuje referencję typu String, może oczekiwać, że będzie zachowywał się jak łańcuch znaków (np. gwarantując, że wszelkie obserwacje dotyczące jego wartości na zawsze pozostaną prawdziwe). Ujawnienie konstruktorów poza pakietem umożliwiłoby jednak typom pochodnym zachowanie się w dziwny i dziwaczny sposób (np. zmiana ich zawartości po sprawdzeniu i zatwierdzeniu).

Od a perspektywa składniowa, umiejętność mówienia Fnord foo = new Fnord(123); jest trochę ładniejsza niż mówienie Fnord foo = Fnord.Create(123);, ale Klasa Fnord, która wymaga tej ostatniej składni, może zachować znacznie lepszą kontrolę nad procesem tworzenia obiektu.

Proste wyjaśnienie jest takie, że jeśli nie ma konstruktora w klasie, kompilator automatycznie tworzy konstruktor domyślny.

Konstruktor nie zawsze jest zadeklarowany jako publiczny, może być również prywatny, chroniony lub domyślny.

Konstruktory prywatne uniemożliwiają klasie pełne i wyraźnie wyrażone / reprezentowane przez jej wywołujące. W takim przypadku przydatne są konstruktory prywatne. A jeśli nie chcemy, aby nasza klasa była podklasowana, możemy użyć konstruktorów prywatnych.