Java >> Java tutorial >  >> Tag >> private

Private konstruktører i Java

1. Introduktion

Private konstruktørertillader os at begrænse instansieringen af ​​en klasse . Kort sagt forhindrer de oprettelsen af ​​klasseforekomster et hvilket som helst andet sted end selve klassen.

Offentlige og private konstruktører, brugt sammen, tillader kontrol over, hvordan vi ønsker at instansiere vores klasser – dette er kendt som konstruktørdelegation.

2. Typisk brug

Der er flere mønstre og fordele ved at begrænse eksplicit klasseforekomst, og vi gennemgår de mest almindelige i denne øvelse:

  • Singleton-mønsteret
  • Delegering af konstruktører
  • Uinstantiable klasser
  • Builder-mønsteret

Lad os se hvordan man definerer en privat konstruktør :

public class PrivateConstructorClass {
    
    private PrivateConstructorClass() {
        // in the private constructor
    }
}

Vi definerer private konstruktører på samme måde som offentlige konstruktører; vi har simpelthen ændret offentligheden søgeord til privat .

3. Brug af private konstruktører i Singleton-mønsteret

Singleton-mønsteret er et af de mest almindelige steder, vi vil støde på brugen af ​​en privat konstruktør. Den private konstruktør giver os mulighed for at begrænse klasseinstansering til en enkelt objektinstans :

public final class SingletonClass {
    
    private static SingletonClass INSTANCE;
    private String info = "Initial info class";

    private SingletonClass() {
    }

    public static SingletonClass getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new SingletonClass();
        }

        return INSTANCE;
    }

    // getters and setters
}

Vi kan oprette en instans ved at kalde SingletonClass.getInstance() – dette returnerer enten en eksisterende instans eller opretter en, hvis dette er den første instansiering. Vi kan kun instansiere denne klasse ved at bruge getInstance() statisk metode.

4. Brug af private konstruktører til at uddelegere konstruktører

En anden almindelig anvendelse for private konstruktører er at tilvejebringe et middel til konstruktørdelegering. Konstruktørdelegering giver os mulighed for at sende parametre gennem flere forskellige konstruktører, mens initialisering begrænses til bestemte steder .

I dette eksempel er ValueTypeClass tillader initialisering med en værdi og type - men vi ønsker kun at tillade det for en undergruppe af typer. Den generelle konstruktør skal være privat for at sikre, at der kun anvendes tilladte typer:

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

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

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

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

    // getters and setters
}

Vi kan initialisere ValueType Klasse via to forskellige offentlige konstruktører:den ene accepterer en int , og den anden en boolsk . Hver af disse konstruktører kalder derefter en fælles privat konstruktør for at fuldføre objektinitialiseringen.

5. Brug af private konstruktører til at skabe uinstantiable klasser

Uinstantierbare klasser er klasser, som vi ikke kan instantiere. I dette eksempel opretter vi en klasse, der blot indeholder en samling statiske metoder :

public class StringUtils {
    
    private StringUtils() {
        // this class cannot be instantiated
    }

    public static String toUpperCase(String s) {
        return s.toUpperCase();
    }

    public static String toLowerCase(String s) {
        return s.toLowerCase();
    }
}

 StringUtils klasse indeholder et par statiske hjælpemetoder og kan ikke instansieres på grund af den private konstruktør.

Faktisk er der ingen grund til at tillade objektforekomst, da statiske metoder ikke kræver, at en objektinstans skal bruges.

6. Brug af private konstruktører i Builder-mønsteret

Builder-mønsteret giver os mulighed for at konstruere komplekse objekter trin for trin, i stedet for at have flere konstruktører, der giver forskellige måder at skabe objektet på. En privat konstruktør begrænser initialisering, hvilket giver bygherren mulighed for at administrere objektoprettelse i stedet .

I dette eksempel har vi oprettet en medarbejder klasse, der indeholder navnet , alder , og afdeling af en medarbejder:

public class Employee {

    private final String name;
    private final int age;
    private final String department;

    private Employee(String name, int age, String department) {
        this.name = name;
        this.age = age;
        this.department = department;
    }
}

Som vi kan se, har vi lavet medarbejderen constructor private – derfor kan vi ikke instansiere klassen eksplicit.

Vi tilføjer nu en indre Builder klasse til medarbejderen klasse:

public static class Builder {

    private String name;
    private int age;
    private String department;

    public Builder setName(String name) {
        this.name = name;
        return this;
    }

    public Builder setAge(int age) {
        this.age = age;
        return this;
    }

    public Builder setDepartment(String department) {
        this.department = department;
        return this;
    }

    public Employee build() {
        return new Employee(name, age, department);
    }
}

Bygherren kan nu oprette forskellige medarbejdere med et navn , alder eller afdeling – der er ingen begrænsning på, hvor mange felter vi skal levere:

Employee.Builder emplBuilder = new Employee.Builder();

Employee employee = emplBuilder
  .setName("baeldung")
  .setDepartment("Builder Pattern")
  .build();

Vi har oprettet en medarbejder med navnet "baeldung ” og en afdeling af “Builder Pattern ". Alder er ikke angivet, så standard primitive int værdien 0 vil blive brugt.

7. Brug af private konstruktører til at forhindre underklassificering

En anden mulig anvendelse for private konstruktører er at forhindre underklassificering af en klasse. Hvis vi forsøgte at oprette en underklasse, ville den ikke være i stand til at kalde super konstruktør. Det er dog vigtigt at bemærke, at vi normalt laver en klasse finale for at forhindre underklassering frem for at bruge en privat konstruktør .

8. Konklusion

Den primære anvendelse af private konstruktører er at begrænse instansieringen af ​​klasser. Private konstruktører er især nyttige, når vi ønsker at begrænse den eksterne oprettelse af en klasse .

Singletons, fabrikker og statiske metodeobjekter er eksempler på, hvordan begrænsning af objektinstansiering kan være nyttig til at håndhæve et bestemt mønster.

Konstantklasser og statiske metodeklasser dikterer også, at en klasse ikke skal være instantiérbar. Det er vigtigt at huske, at vi også kan kombinere private konstruktører med offentlige konstruktører for at tillade kodedeling i forskellige offentlige konstruktørdefinitioner.

Koden til disse eksempler kan findes på GitHub.


Java tag