Costruttori Java (con esempi)

In questo tutorial impareremo a conoscere i costruttori Java, i loro tipi e come usarli con l'aiuto di esempi.

Cos'è un costruttore?

Un costruttore in Java è simile a un metodo che viene richiamato quando viene creato un oggetto della classe.

A differenza dei metodi Java, un costruttore ha lo stesso nome di quello della classe e non ha alcun tipo di ritorno. Per esempio,

 class Test (Test () (// costruttore corpo))

Ecco Test()un costruttore. Ha lo stesso nome di quello della classe e non ha un tipo di ritorno.

Letture consigliate: perché i costruttori non restituiscono valori

Esempio 1: Java Constructor

 class Main ( private String name; // constructor Main() ( System.out.println("Constructor Called:"); name = "Programiz"; ) public static void main(String() args) ( // constructor is invoked while // creating an object of the Main class Main obj = new Main(); System.out.println("The name is " + obj.name); ) )

Uscita :

 Costruttore chiamato: il nome è Programiz

Nell'esempio precedente, abbiamo creato un costruttore denominato Main(). All'interno del costruttore, stiamo inizializzando il valore della variabile name.

Si noti l'istruzione di creare un oggetto della classe Main.

 Main obj = new Main();

Qui, quando viene creato l'oggetto, Main()viene chiamato il costruttore. E il valore della variabile name viene inizializzato.

Quindi, il programma stampa il valore delle variabili nome come Programiz.

Tipi di costruttore

In Java, i costruttori possono essere suddivisi in 3 tipi:

  1. Costruttore No-Arg
  2. Costruttore parametrizzato
  3. Costruttore predefinito

1. Costruttori Java No-Arg

Simile ai metodi, un costruttore Java può o non può avere parametri (argomenti).

Se un costruttore non accetta alcun parametro, è noto come costruttore senza argomenti. Per esempio,

 private Constructor() ( // body of the constructor )

Esempio 2: costruttore Java privato no-arg

 class Main ( int i; // constructor with no parameter private Main() ( i = 5; System.out.println("Constructor is called"); ) public static void main(String() args) ( // calling the constructor without any parameter Main obj = new Main(); System.out.println("Value of i: " + obj.i); ) )

Uscita :

 Il costruttore si chiama Value of i: 5

Nell'esempio sopra, abbiamo creato un costruttore Main(). Qui, il costruttore non accetta alcun parametro. Quindi, è noto come costruttore senza argomenti.

Si noti che abbiamo dichiarato il costruttore come privato.

Una volta dichiarato un costruttore private, non è possibile accedervi dall'esterno della classe. Quindi, la creazione di oggetti dall'esterno della classe è vietata utilizzando il costruttore privato.

Qui stiamo creando l'oggetto all'interno della stessa classe. Quindi, il programma è in grado di accedere al costruttore. Per saperne di più, visita Java Implement Private Constructor.

Tuttavia, se vogliamo creare oggetti al di fuori della classe, dobbiamo dichiarare il costruttore come public.

Esempio 3: costruttori Java public no-arg

 class Company ( String name; // public constructor public Company() ( name = "Programiz"; ) ) public class Main ( public static void main(String() args) ( // object is created in another class Company obj = new Company(); System.out.println("Company name = " + obj.name); ) )

Uscita :

 Nome azienda = Programiz

Letture consigliate: Java Access Modifier

2. Costruttore parametrizzato Java

Un costruttore Java può anche accettare uno o più parametri. Tali costruttori sono noti come costruttori parametrizzati (costruttore con parametri).

Esempio 4: costruttore parametrizzato

 class Main ( String languages; // constructor accepting single value Main(String lang) ( languages = lang; System.out.println(languages + " Programming Language"); ) public static void main(String() args) ( // call constructor by passing a single value Main obj1 = new Main("Java"); Main obj2 = new Main("Python"); Main obj3 = new Main("C"); ) )

Uscita :

 Linguaggio di programmazione Java Linguaggio di programmazione Python Linguaggio di programmazione C.

Nell'esempio precedente, abbiamo creato un costruttore denominato Main(). Qui, il costruttore accetta un singolo parametro. Notare l'espressione,

 Main obj1 = new Main("Java");

Here, we are passing the single value to the constructor. Based on the argument passed, the language variable is initialized inside the constructor.

3. Java Default Constructor

If we do not create any constructor, the Java compiler automatically create a no-arg constructor during the execution of the program. This constructor is called default constructor.

Example 5: Default Constructor

 class Main ( int a; boolean b; public static void main(String() args) ( // A default constructor is called Main obj = new Main(); System.out.println("Default Value:"); System.out.println("a = " + obj.a); System.out.println("b = " + obj.b); ) )

Output:

 a = 0 b = false

Here, we haven't created any constructors. Hence, the Java compiler automatically creates the default constructor.

The default constructor initializes any uninitialized instance variables with default values.

Type Default Value
boolean false
byte 0
short 0
int 0
long 0L
char u0000
float 0.0f
double 0.0d
object Reference null

In the above program, the variables a and b are initialized with default value 0 and false respectively.

The above program is equivalent to:

 class Main ( int a; boolean b; // a private constructor private Main() ( a = 0; b = false; ) public static void main(String() args) ( // call the constructor Main obj = new Main(); System.out.println("Default Value:"); System.out.println("a = " + obj.a); System.out.println("b = " + obj.b); ) )

The output of the program is the same as Example 5.

Important Notes on Java Constructors

  • Constructors are invoked implicitly when you instantiate objects.
  • The two rules for creating a constructor are:
    The name of the constructor should be the same as the class.
    A Java constructor must not have a return type.
  • If a class doesn't have a constructor, the Java compiler automatically creates a default constructor during run-time. The default constructor initializes instance variables with default values. For example, the int variable will be initialized to 0
  • Constructor types:
    No-Arg Constructor - a constructor that does not accept any arguments
    Parameterized constructor - a constructor that accepts arguments
    Default Constructor - a constructor that is automatically created by the Java compiler if it is not explicitly defined.
  • A constructor cannot be abstract or static or final.
  • A constructor can be overloaded but can not be overridden.

Constructors Overloading in Java

Similar to Java method overloading, we can also create two or more constructors with different parameters. This is called constructors overloading.

Example 6: Java Constructor Overloading

 class Main ( String language; // constructor with no parameter Main() ( this.language = "Java"; ) // constructor with a single parameter Main(String language) ( this.language = language; ) public void getName() ( System.out.println("Programming Langauage: " + this.language); ) public static void main(String() args) ( // call constructor with no parameter Main obj1 = new Main(); // call constructor with a single parameter Main obj2 = new Main("Python"); obj1.getName(); obj2.getName(); ) )

Output:

 Programming Language: Java Programming Language: Python

Nell'esempio sopra, abbiamo due costruttori: Main()e Main(String language). Qui, entrambi i costruttori inizializzano il valore della variabile language con valori diversi.

In base al parametro passato durante la creazione dell'oggetto, vengono chiamati diversi costruttori e vengono assegnati valori diversi.

È anche possibile chiamare un costruttore da un altro costruttore. Per saperne di più, visita Java Call One Constructor from Another.

Nota : abbiamo utilizzato la thisparola chiave per specificare la variabile della classe. Per saperne di più sulla thisparola chiave, visita Java questa parola chiave.

Articoli interessanti...