Peut un constructeur en Java en être privé?

Oui, un constructeur ne peut être privé. Il y a différentes utilisations de ce. Une telle utilisation est pour le singleton conception anti-pattern, qui je ne vous le conseille, vous aide. Un autre, plus légitime, est en déléguant les constructeurs; vous pouvez avoir un constructeur qui prend beaucoup de différentes options, c'est vraiment un détail d'implémentation, afin de vous le rendre privé, mais alors votre reste constructeurs de lui déléguer.

Comme un exemple de déléguer les constructeurs, la classe suivante vous permet d'enregistrer une valeur et un type, mais il ne vous permet de le faire pour un sous-ensemble de types, afin de faire le grand constructeur privé est nécessaire pour s'assurer que seuls les types d'observations sont utilisés. La commune constructeur privé permet la réutilisation du code.

public class MyClass {
     private final String value;
     private final String type;

     public MyClass(int x){
         this(Integer.toString(x), "int");
     }

     public MyClass(boolean x){
         this(Boolean.toString(x), "boolean");
     }

     public String toString(){
         return value;
     }

     public String getType(){
         return type;
     }

     private MyClass(String value, String type){
         this.value = value;
         this.type = type;
     }
}

Modifier

En regardant cette réponse de plusieurs années plus tard, je tiens à souligner que cette réponse est à la fois incomplet et peut-être un peu extrême. Les Singletons sont en effet un anti-modèle et doit généralement être évitée lorsque cela est possible; cependant, il existe de nombreuses utilisations des les constructeurs privés en plus des singletons, et ma réponse noms d'un seul.

Pour donner un peu plus de cas où les constructeurs privés sont utilisés:

1. Pour créer un uninstantiable classe qui est juste une collection de fonctions statiques (ce qui est essentiellement un singleton, mais si elle est apatride et les fonctions statiques fonctionnent strictement sur les paramètres plutôt que sur l'état de classe, ce n'est pas comme déraisonnable, une approche que mon ancienne auto, il semble, bien que l'utilisation d'une interface qui est de la dépendance injecté souvent il est plus facile de maintenir l'API lors de la mise en œuvre nécessite un plus grand nombre de dépendances ou d'autres formes de contexte).

2. Lorsqu'il y a plusieurs différentes façons de créer un objet, un constructeur privé peut être plus facile de comprendre les différents modes de construction (p. ex., qui est plus lisible pour vous new ArrayList(5) ou ArrayList.createWithCapacity(5), ArrayList.createWithContents(5), ArrayList.createWithInitialSize(5)). En d'autres termes, un constructeur privé permet de fournir de l'usine de la fonction dont les noms sont plus compréhensibles, et ensuite faire le constructeur privé s'assure que les gens utilisent seulement le plus évident de tous les noms. C'est aussi couramment utilisé avec le générateur de modèle. Par exemple:

   MyClass myVar = MyClass
       .newBuilder()
       .setOption1(option1)
       .setOption2(option2)
       .build();

Oui, il peut. Un constructeur privé d'empêcher la classe d'être instancié, ou parce que la construction se passe seulement à l'interne, par exemple un modèle de Fabrique. Voir ici pour plus d'informations.

Bien, si tous vos méthodes dans une classe statique, puis un constructeur privé est une bonne idée.

Oui.

Un constructeur privé est utilisé pour prévenir exemple lors de l'initialisation, tels que le calcul final de la classe que vous l'utilisez en java. Singleton également utiliser constructeur privé

Oui, classe peut avoir un constructeur privé. Il est nécessaire d'interdire l'accès du constructeur à partir d'autres classes et restent accessibles dans la classe définie par.

Pourquoi voudriez-vous les objets de votre classe uniquement être créés à l'interne? Ce qui pourrait être fait pour n'importe quel raison, mais une raison possible est que vous voulez implémenter un singleton. Un singleton est un modèle de conception qui permet à une seule instance de votre classe à être créé, et ce qui peut être accompli à l'aide d'un constructeur privé.

oui un constructeur ne peut être privé. Un Constructeur privé empêche les autres de la classe à partir de l'instanciation d'exemple de constructeur privé

public class CustomHttpClient {
private static HttpClient customHttpClient;

/** A private Constructor prevents any other class from instantiating. */
private CustomHttpClient() {
}}

Peut être un constructeur privé? Comment un constructeur privé utile?

Oui, il peut. Je considère cette autre exemple de qu'il soit utile:

//... ErrorType.java
public enum ErrorType {
    X,
    Y,
    Z
}

//... ErrorTypeException.java
import java.util.*;
import java.lang.*;
import java.io.*;

//Translates ErrorTypes only
abstract public class ErrorTypeException extends Exception {
    private ErrorTypeException(){}

    //I don't want to expose thse
    static private class Xx extends ErrorTypeException {}
    static private class Yx extends ErrorTypeException {}
    static private class Zx extends ErrorTypeException {}

    //Want translation without exposing underlying type
    public static Exception from(ErrorType errorType) {
        switch (errorType) {
            case X:
                return new Xx();    
            case Y:
                return new Yx();
            default:
                return new Zx();
        }
    }

    //Want to get hold of class without exposing underlying type
    public static Class<? extends ErrorTypeException> toExceptionClass(ErrorType errorType) {
        switch (errorType) {
            case X:
                return Xx.class;    
            case Y:
                return Yx.class;
            default:
                return Zx.class;
        }
    }
}

Dans le cas ci-dessus, il empêche la classe abstraite d'être instancié par une classe dérivée autre que statique à l'intérieur des classes. Les classes abstraites ne peuvent pas être définitif, mais dans ce cas, le constructeur privé rend effectivement final à toutes les classes qui ne sont pas les classes internes

Selon moi, nous pouvons déclarer constructeur privé et nous aussi, nous
pouvez obtenir l'instance de cette classe dans la sous-classe en utilisant la méthode statique de la classe dans laquelle nous déclarons constructeur et ensuite de retour de classe de l'objet. on classe cette méthode à partir de la sous-classe
en utilisant classname.method nom bcz c'est la méthode statique et la nous allons obtenir l'instance de la classe dans laquelle nous déclarer const.