Constructori Java (cu exemple)

În acest tutorial, vom învăța despre constructorii Java, tipurile lor și cum să le folosim cu ajutorul exemplelor.

Ce este un constructor?

Un constructor în Java este similar cu o metodă care este invocată atunci când este creat un obiect al clasei.

Spre deosebire de metodele Java, un constructor are același nume ca cel al clasei și nu are niciun tip de returnare. De exemplu,

 clasa Test (Test () (// corpul constructorului))

Iată Test()un constructor. Are același nume ca cel al clasei și nu are un tip de returnare.

Lectură recomandată: De ce constructorii nu returnează valori

Exemplul 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); ) )

Ieșire :

 Constructor apelat: numele este Programiz

În exemplul de mai sus, am creat un constructor numit Main(). În interiorul constructorului, inițializăm valoarea variabilei de nume.

Observați declarația de a crea un obiect din clasa Main.

 Main obj = new Main();

Aici, atunci când obiectul este creat, Main()se numește constructorul. Și, valoarea variabilei de nume este inițializată.

Prin urmare, programul afiseaza valoarea variabilelor de nume ca Programiz.

Tipuri de constructor

În Java, constructorii pot fi împărțiți în 3 tipuri:

  1. No-Arg Constructor
  2. Constructor parametrizat
  3. Constructor implicit

1. Constructori Java No-Arg

Similar metodelor, un constructor Java poate avea sau nu parametri (argumente).

Dacă un constructor nu acceptă niciun parametru, este cunoscut ca un constructor fără argumente. De exemplu,

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

Exemplul 2: constructor privat Java fără argumente

 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); ) )

Ieșire :

 Constructorul se numește Valoarea lui i: 5

În exemplul de mai sus, am creat un constructor Main(). Aici, constructorul nu acceptă niciun parametru. Prin urmare, este cunoscut ca un constructor fără argumente.

Observați că am declarat constructorul drept privat.

Odată ce un constructor este declarat private, acesta nu poate fi accesat din afara clasei. Deci, crearea obiectelor din afara clasei este interzisă folosind constructorul privat.

Aici, creăm obiectul în aceeași clasă. Prin urmare, programul poate accesa constructorul. Pentru a afla mai multe, vizitați Java Implement Private Constructor.

Cu toate acestea, dacă dorim să creați obiecte în afara clasei, atunci trebuie să declare constructorului ca public.

Exemplul 3: constructori publici Java fără argumente

 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); ) )

Ieșire :

 Nume companie = Programiz

Citire recomandată: modificator de acces Java

2. Constructor parametrizat Java

Un constructor Java poate accepta, de asemenea, unul sau mai mulți parametri. Astfel de constructori sunt cunoscuți ca constructori parametrizati (constructor cu parametri).

Exemplul 4: Constructor parametrizat

 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"); ) )

Ieșire :

 Limbaj de programare Java Limbaj de programare Python Limbaj de programare C

În exemplul de mai sus, am creat un constructor numit Main(). Aici, constructorul ia un singur parametru. Observați expresia,

 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

În exemplul de mai sus, avem doi constructori: Main()și Main(String language). Aici, atât constructorul inițializează valoarea limbajului variabil cu valori diferite.

Pe baza parametrului transmis în timpul creării obiectului, se apelează diferiți constructori și se atribuie valori diferite.

De asemenea, este posibil să apelați un constructor de la un alt constructor. Pentru a afla mai multe, vizitați Java Call One Constructor from Another.

Notă : Am folosit thiscuvinte cheie pentru a specifica variabila clasei. Pentru a afla mai multe despre thiscuvintele cheie, vizitați Java acest cuvânt cheie.

Articole interesante...