Java 构造函数

In questo tutorial, imparerai a conoscere i costruttori Java con l'aiuto di esempi, come crearli e utilizzarli e i diversi tipi di costruttori.

Cos'è un costruttore?

In Java, ogni classe ha il suo costruttore, che viene chiamato automaticamente quando viene creato un oggetto della classe. Il costruttore è simile a un metodo, ma in realtà non è un metodo.

unMetodi JavaE costruttori Java possono essere distinti per nome e tipo di ritorno. I costruttori hanno lo stesso nome del costruttore della classe e non restituiscono alcun valore. Ad esempio,

class Test {
　　　　Test() {
　　　　　　　　// 构造函数体
　　　　}
}

在这里，Test()是一个构造函数。它具有与该类相同的名称，并且没有返回类型。

class Test {
　　　　void Test() {
　　　　　　　　// 方法主体
　　　　}
}

　这里，Test()与类的名称相同。但是，它有一个返回类型void。因此，它是一个方法，而不是一个构造函数。

示例：Java构造函数

class Main {
　　　private int x;
　　　// corpo del costruttore
　　　private Main(){
　　　　　　　System.out.println("构造函数被调用");
　　　　　　　x = 5;
　　　}
　　　public static void main(String[] args){
　　　　　　　// 创建对象时调用构造函数
　　　　　　　Main obj = new Main();
　　　　　　　System.out.println("x 的值 = " + obj.x);
　　　}
}

Output:

构造函数被调用
x 的值 = 5

　在上面的示例中，我们有一个名为Main()的私有构造函数。在main方法中，我们正在创建一个名为obj的类对象。

Main obj = new Main();

　在此过程中，将调用构造函数。因此，执行print语句并初始化变量x。

构造函数的类型

在Java中，构造函数可以分为3种类型：

• Costruttore senza parametri

• Costruttore predefinito

• 参数构造函数

Costruttore senza parametri

Java构造函数可以具有或可以不具有任何参数。如果构造函数不接受任何参数，则称为无参数构造函数。例如，

private Constructor() {
　　　// corpo del costruttore
}

无参数构造函数的示例

class Main {
　　　int i;
　　　//Costruttore senza parametri
　　　private Main(){
　　　　　　　i = 5;
　　　　　　　System.out.println("Object created and i = " + i);
　　　}
　　　public static void main(String[] args) {
　　　　　　　// 不带任何参数调用构造函数
　　　　　　　Main obj = new Main();
　　　}
}

Output:

Object created and i = 5

在这里，构造Main()函数不接受任何参数。

您是否注意到Main()构造函数的访问修饰符是私有(private)的？

这是因为该对象是从同一类中实例化的。因此，它可以访问构造函数。

但是，如果对象是在类外部创建的，则必须声明构造函数为public才能访问它。例如：

class Company {
　　　　String domainName;
　　　　// 公共构造函数
　　　　public Company(){
　　　　　　　　domainName = "oldtoolbag.com";
　　　　}
}
public class Main {
　　　　
　　　　public static void main(String[] args) {
　　　　　　　　// 在另一个类中创建对象
　　　　　　　　Company companyObj = new Company();
　　　　　　　　System.out.println("Domain name = " + companyObj.domainName);
　　　　}
}

Output:

Domain name = oldtoolbag.com

Leggi di più: Modificatori di accesso Java

Costruttore predefinito

Se non si crea alcun costruttore, il compilatore Java crea automaticamente un costruttore senza parametri durante l'esecuzione. Questo costruttore si chiama costruttore predefinito. Il costruttore predefinito inizializza tutti i variabili di istanza non inizializzate con valori predefiniti.

Esempio: costruttore predefinito

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　public static void main(String[] args) {
　　　　　　　　// chiamata al costruttore predefinito
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = " + obj.a);
　　　　　　　　System.out.println("b = " + obj.b);
　　　　}
}

Output:

a = 0
b = false

Nel programma sopra, non abbiamo inizializzato i valori delle variabili a e b. Tuttavia, quando creiamo un oggetto della classe, possiamo vedere nei risultati di output che queste variabili sono state inizializzate con certi valori.

　Questo è perché il compilatore Java crea automaticamente un costruttore predefinito. Il costruttore inizializzerà i valori delle variabili a e b con i valori predefiniti 0 e false.

Il programma sopra è equivalente a:

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　// costruttore privato　
　　　　private DefaultConstructor() {
　　　　　　　　a = 0;
　　　　　　　　b = false;
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　// chiamata al costruttore
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = " + obj.a);
　　　　　　　　System.out.println("b = " + obj.b);
　　　　}
}

Output:

a = 0
b = false

Costruttore parametrizzato

Allo stesso modo dei metodi, possiamo passare parametri al costruttore. Questo tipo di costruttore si chiama costruttore parametrizzato. Ad esempio,

private Constructor(arg1, arg2, ..., argn) {
　　　　// corpo del costruttore
}

Esempio: costruttore parametrizzato

class Vehicle {
　　　　int wheels;
　　　　//接受单个值的构造函数
　　　　private Vehicle(int wheels){
　　　　　　　　this.wheels = wheels;
　　　　　　　　System.out.println(wheels + "wheeler vehicle created.");
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Chiamata al costruttore tramite la trasmissione di un singolo valore
　　　　　　　　Vehicle v1 = new Vehicle(2);
　　　　　　　　Vehicle v2 = new Vehicle(3);
　　　　　　　　Vehicle v3 = new Vehicle(4);
　　　　}
}

Output:

Veicolo a 2 ruote creato.
Veicolo a 3 ruote creato.
Veicolo a 4 ruote creato.

Nell'esempio sopra, abbiamo un costruttore chiamato Vehicle(). Il costruttore accetta un parametro chiamato wheels.

Qui, quando creiamo un oggetto, passiamo i parametri al costruttore. E, basandosi sui parametri, sta generando l'output.

Sovraccarica dei costruttori in Java

　Simile alla sovraccarica dei metodi, possiamo sovraccaricare i costruttori in Java. Se non sei familiare con la sovraccarica dei metodi, visitaSovraccarico dei metodi Java.

Nella sovraccarica del costruttore, ci sono due o più costruttori con parametri diversi. Ad esempio,

class Company {
　　　　String domainName;
　　　　//Costruttore senza parametri
　　　　public Company(){
　　　　　　　　this.domainName = "default";
　　　　}
　　　　//Costruttore con un singolo parametro
　　　　public Company(String domainName){
　　　　　　　　this.domainName = domainName;
　　　　}
　　　　public void getName(){
　　　　　　　　System.out.println(this.domainName);
　　　　}
　　　　public static void main(String[] args) {
　　　　　　　　//Chiamata al costruttore senza parametri
　　　　　　　　Company defaultObj = new Company();
　　　　　　　　//Chiamata al costruttore con un singolo parametro
　　　　　　　　Company w3codeboxObj = new Company("oldtoolbag.com");
　　　　　　　　defaultObj.getName();
　　　　　　　　w3codeboxObj.getName();
　　　　}
}

Output:

default
oldtoolbag.com

Nell'esempio sopra, abbiamo due costruttori: public Company() e public Company(String domainName).

Qui, entrambi i costruttori iniziano le variabili domainName con valori diversi.Quindi, a seconda dei valori di cui abbiamo bisogno, possiamo chiamare il costruttore dal metodo main().

Attenzione, usiamo la chiave this per specificare le variabili della classe. Per ulteriori informazioni sulla chiave this, visitareChiave Java this.

Nota importante

• 　Il costruttore viene chiamato implicitamente durante l'istanziazione degli oggetti.
  

• Le due regole per creare costruttori sono:

• Il nome del costruttore dovrebbe essere lo stesso del nome della classe.

• I costruttori Java non devono avere un tipo di ritorno.

• Se la classe non ha costruttori, il compilatore Java li crea automaticamente durante l'esecuzioneCostruttore predefinito. Il costruttore predefinito inizializza le variabili d'istanza con valori predefiniti. Ad esempio, un variabile int viene inizializzata a 0

• Tipo di costruttore:

• Costruttore senza parametri　 - Costruttore che non accetta alcun parametro

• Costruttore predefinito　 - Se non viene definito esplicitamente, il compilatore Java crea automaticamente un costruttore.

• Costruttore parametrizzato　 - Costruttore che accetta parametri

• I costruttori non possono essere astratti abstract, static o final.
  

• I costruttori possono essere sovraccaricati ma non possono essere sovrascritti.