Neste tutorial, aprenderemos sobre construtores Java, seus tipos e como usá-los com a ajuda de exemplos.
O que é um construtor?
Um construtor em Java é semelhante a um método que é chamado quando um objeto da classe é criado.
Ao contrário dos métodos Java, um construtor tem o mesmo nome da classe e não possui nenhum tipo de retorno. Por exemplo,
classe Test (Test () (// corpo do construtor))
Aqui Test()está um construtor. Possui o mesmo nome da classe e não possui tipo de retorno.
Leitura recomendada: por que os construtores não retornam valores
Exemplo 1: Construtor Java
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); ) )
Produto :
Construtor chamado: O nome é Programiz
No exemplo acima, criamos um construtor chamado Main(). Dentro do construtor, estamos inicializando o valor da variável name.
Observe a instrução de criação de um objeto da classe Main.
Main obj = new Main();
Aqui, quando o objeto é criado, o Main()construtor é chamado. E, o valor da variável de nome é inicializado.
Portanto, o programa imprime o valor das variáveis de nome como Programiz.
Tipos de construtor
Em Java, os construtores podem ser divididos em 3 tipos:
- Construtor No-Arg
- Construtor Parametrizado
- Construtor Padrão
1. Construtores Java No-Arg
Semelhante aos métodos, um construtor Java pode ou não ter parâmetros (argumentos).
Se um construtor não aceita nenhum parâmetro, ele é conhecido como um construtor sem argumento. Por exemplo,
private Constructor() ( // body of the constructor )
Exemplo 2: construtor Java privado sem 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); ) )
Produto :
O construtor é chamado de Valor de i: 5
No exemplo acima, criamos um construtor Main(). Aqui, o construtor não aceita nenhum parâmetro. Portanto, ele é conhecido como um construtor sem argumentos.
Observe que declaramos o construtor como privado.
Depois que um construtor é declarado private, ele não pode ser acessado de fora da classe. Portanto, criar objetos de fora da classe é proibido usando o construtor privado.
Aqui, estamos criando o objeto dentro da mesma classe. Portanto, o programa é capaz de acessar o construtor. Para saber mais, visite Java Implement Private Constructor.
No entanto, se quisermos criar objetos fora da classe, precisamos declarar o construtor como public.
Exemplo 3: construtores Java públicos sem 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); ) )
Produto :
Nome da empresa = Programiz
Leitura recomendada: modificador de acesso Java
2. Construtor Java Parametrizado
Um construtor Java também pode aceitar um ou mais parâmetros. Esses construtores são conhecidos como construtores parametrizados (construtor com parâmetros).
Exemplo 4: construtor parametrizado
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"); ) )
Produto :
Linguagem de programação Java Linguagem de programação Python Linguagem de programação C
No exemplo acima, criamos um construtor chamado Main(). Aqui, o construtor usa um único parâmetro. Observe a expressão,
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
intvariable will be initialized to0 - 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
abstractorstaticorfinal. - 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
No exemplo acima, temos dois construtores: Main()e Main(String language). Aqui, ambos os construtores inicializam o valor da variável language com valores diferentes.
Com base no parâmetro passado durante a criação do objeto, diferentes construtores são chamados e diferentes valores são atribuídos.
Também é possível chamar um construtor de outro construtor. Para saber mais, visite Java Call One Constructor from Another.
Nota : Nós usamos a thispalavra-chave para especificar a variável da classe. Para saber mais sobre thispalavras-chave, visite Java esta palavra-chave.
