java constructor class
Este tutorial discutirá o Construtor Java, seus tipos e conceitos, como sobrecarga de construtor e encadeamento de construtor com exemplos de código:
De nossos tutoriais anteriores, sabemos que a instância de uma classe é chamada de objeto. Um objeto de uma classe é criado usando a palavra-chave “novo”. Um método especial chamado “construtor” é chamado quando criamos um objeto com uma nova palavra-chave ou quando o objeto é instanciado.
Um construtor é definido como um bloco de código para inicializar o objeto de classe. É idêntico ao método, mas não é um método. No entanto, pode ser denominado como um “método especial” em Java.
=> Verifique aqui para ver A-Z dos tutoriais de treinamento de Java aqui.
O que você aprenderá:
- Construtor Java
- Conclusão
Construtor Java
O construtor Java é usado para inicializar o objeto recém-criado. Um objeto precisa ter alguns dados antes de ser usado no programa. Portanto, usamos construtor para que possamos atribuir alguns dados iniciais ao objeto.
Como um exemplo simples, considere uma classe ABC para a qual precisamos criar um objeto. Vamos criar um objeto ‘myObj’ para a classe ABC usando uma nova palavra-chave.
ABC myObj = new ABC ();A instrução acima cria um objeto myObj. Quando este objeto está sendo criado, um construtor para a classe ABC sem argumento é chamado (ABC () mostra que não há argumentos para o construtor). Como não há argumentos fornecidos para o construtor acima, os campos de membro do myObj serão inicializados com seus valores iniciais padrão.
Por exemplo,
- Tipos de dados numéricos como int são definidos como 0.
- O valor da variável do tipo de dados char é definido como caractere nulo (‘ 0’).
- As referências são definidas como nulas.
Neste tutorial, discutiremos os construtores em detalhes, juntamente com os vários construtores usados em Java.
Como criar um construtor em Java
Para criar um construtor em Java, precisamos seguir certas regras conforme fornecidas abaixo.
- O construtor da classe tem o mesmo nome que o da classe.
- Não pode haver um construtor que seja final, abstrato, sincronizado ou estático. Isso ocorre porque o Final atua como uma constante, abstrato não pode ser instanciado. Enquanto synchronized é usado no caso de multiencadeamento, e a palavra-chave static é usada no nível da classe.
- Podemos usar modificadores de acesso com os construtores.
- Um construtor não pode ter um tipo de retorno.
Por exemplo,vamos definir uma classe Aluno da seguinte maneira:
class Student{ String name; int roll_no; } Podemos criar objetos da classe acima usando a nova palavra-chave. Enquanto o objeto está sendo criado, podemos inicializar as variáveis de dois membros dessa classe fornecendo um construtor. Observe que, mesmo se não fornecermos um construtor e apenas executarmos a instrução abaixo,
Aluno aluno = novo aluno ();
Ainda assim, o Java executará um construtor padrão que inicializará as variáveis de dois membros para seus padrões de sistema. Agora, se quisermos que o valor inicial de Student.name seja “Keith” e roll_no seja 27, então, para fazer isso, podemos criar o seguinte método de construtor.
Student () { name = 'Keith'; roll_no = 27; } Quando criamos um objeto da classe do aluno com a declaração abaixo
Student student = new Student ();Então, os valores iniciais das variáveis de membro name e roll_no serão Keith e 27, respectivamente.
Agora que um construtor foi criado, quando ele será chamado?
Um construtor é chamado toda vez que um objeto é criado com a nova palavra-chave, como no caso acima. Como já mencionado, se nenhum construtor for fornecido, Java fornece um construtor padrão que é chamado quando o objeto é criado usando a nova palavra-chave.
Exemplo de construtor
O programa a seguir mostra um exemplo de construtor no qual temos um construtor simples sem nenhum argumento. Este construtor simplesmente atribui valores iniciais às suas variáveis de membro.
//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }Resultado:
Construtor padrão em Java
O construtor padrão também é chamado de Construtor Vazio . Este construtor é inserido pelo compilador Java no código da classe onde não há construtor implementado pelo programador. O construtor padrão é inserido durante a compilação e, portanto, aparecerá apenas no arquivo ‘.class’ e não no código-fonte.
Considere a seguinte classe Java.
arquivo fonte (.java) arquivo de classe (.class)
Na figura acima, a primeira figura mostra o código-fonte em que não especificamos nenhum construtor. Portanto, quando compilamos esse código e o arquivo .class é gerado, podemos ver que o compilador Java inseriu um construtor padrão conforme mostrado na figura ao lado (em azul).
Nota:
Às vezes, um construtor padrão é usado para descrever o construtor sem arg em Java. Mas esses dois termos são diferentes na realidade. Construtor sem arg é um tipo de construtor em Java que é especificado pelo programador. O construtor padrão é o construtor inserido pelo compilador Java.
que tipo de e-mail tem lá
Portanto, embora esses dois termos sejam usados alternadamente pela maioria do programador, é aconselhável não confundir esses dois termos.
Quando o Java insere um construtor padrão, se o programa tiver alguma variável, eles são atribuídos aos valores padrão.
A tabela abaixo mostra os valores padrão de cada tipo de dados.
| Modelo | Valor padrão |
|---|---|
| Caracteres | u0000 |
| Objeto | Referência nula |
| boleano | falso |
| byte | 0 |
| baixo | 0 |
| int | 0 |
| longo | 0L |
| flutuador | 0.0f |
| em dobro | 0.0d |
O programa a seguir fornece um exemplo de construtor padrão em Java.
class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }Resultado:
Tipos de construtores em Java
Existem dois tipos de construtores em Java, conforme mostrado abaixo.
# 1) Construtor sem argumentos
Um construtor sem argumentos é chamado de construtor sem argumentos ou sem argumentos. Se não tivermos um construtor sem argumentos, o compilador Java não criará um construtor padrão para a classe.
Em geral, se definirmos um construtor em nossa classe, o construtor padrão não será inserido pelo compilador Java.
A seguir está um exemplo do Construtor No-arg
import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } } Resultado:
Neste programa, fornecemos um construtor no-args. Aqui, imprimimos algumas mensagens incluindo as variáveis de membro. Podemos ver na saída que as mensagens do construtor são exibidas indicando que o construtor no-args foi executado.
# 2) Construtor parametrizado
Um construtor parametrizado possui um ou mais parâmetros. Podemos usar um construtor parametrizado no caso de precisarmos passar alguns valores iniciais para a variável membro da classe.
import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } } Resultado:
Aqui, fornecemos um construtor parametrizado que leva dois argumentos, ou seja, nome e id.
Dentro do corpo do construtor, os argumentos são atribuídos como valores às variáveis de membro name e id respectivamente.
Então, no método principal, quando criamos um novo objeto usando a nova palavra-chave, passamos dois valores para o nome da classe após uma nova palavra-chave. Isso indica que estamos chamando o construtor parametrizado. Quando exibimos as variáveis de membro, podemos ver que eles têm os valores que passamos ao criar o objeto.
Construtores sobrecarregados em Java
Agora surge a questão de saber se uma classe pode ter mais de um construtor ou será que uma classe pode ter apenas um construtor?
Bem, podemos ter vários construtores em uma classe. Uma classe pode ter tantos construtores nela, contanto que eles estejam devidamente sobrecarregados.
Então, o que exatamente significa sobrecarga de construtores?
Sobrecarga de construtor é um mecanismo que permite que uma classe tenha tantos construtores de modo que todos esses construtores tenham listas de parâmetros diferentes, dependendo dos tipos de parâmetro ou da ordem dos parâmetros.
O programa abaixo demonstra a sobrecarga do construtor.
//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }Resultado:
No programa acima, temos uma classe contendo três construtores. O primeiro construtor é um construtor sem arg, e então temos um cada um com um argumento e dois argumentos, respectivamente. Como o construtor possui uma lista de parâmetros única, podemos dizer que os construtores estão sobrecarregados.
Construtor ‘this ()’ em Java
Em uma classe que contém vários construtores, e se quisermos chamar um construtor de outro construtor nesta classe?
Para este propósito, usamos a palavra-chave “this” dentro do construtor a partir do qual queremos chamar outro construtor.
Então, quando uma classe tem vários construtores, um construtor no-arg e um construtor parametrizado, usamos a palavra-chave ‘this’ para chamar um construtor parametrizado do construtor no-args. Isso também é chamado “Invocação explícita do construtor”.
Por que precisamos dessa palavra-chave?
Precisamos disso porque a invocação explícita de construtores não é possível diretamente usando apenas o nome do construtor.
Pontos a serem observados:
- A palavra-chave ‘this’ deve ser a primeira instrução no construtor de chamada.
- Se um construtor possui a palavra-chave “this”, então não pode ter “super”. Isso significa que o construtor pode ter super ou this.
class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }Resultado:
No programa acima, temos uma ‘TestClass’ com dois construtores. Chamamos isso de (“SoftwareTestingHelp”) do construtor no-args. Esta é a invocação explícita do construtor parametrizado.
Copiar Construtor em Java
Estamos cientes do construtor de cópia em C ++. O construtor de cópia é um construtor que tem uma referência de objeto como argumento e um novo objeto é criado usando os dados do objeto de referência.
C ++ fornece um construtor de cópia padrão se nenhum for fornecido no programa.
Java também fornece suporte para o construtor de cópia, mas não fornece um construtor de cópia padrão.
O programa Java a seguir demonstra o construtor de cópia usando o exemplo clássico de números complexos que possuem componentes reais e imaginários.
class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } } Resultado:
O programa acima tem uma classe ‘Complex’ que tem um construtor parametrizado e um construtor de cópia. No método principal primeiro, criamos um objeto c1 usando um construtor parametrizado. Então, usando a declaração abaixo,
Complex c2 = new Complex (c1); A instrução acima chama o construtor de cópia conforme a referência c1 é passada para o construtor durante a criação de um novo objeto c2.
Encadeamento de construtor em Java
O encadeamento de construtor é um processo em que um construtor chama outro construtor da mesma classe.
Mesmo quando herdamos de uma classe base, o construtor da classe base é invocado primeiro quando o objeto da classe filha é criado. Este também é um exemplo de encadeamento de construtor.
Em Java, o encadeamento do Construtor pode ser alcançado usando duas abordagens:
- Dentro da mesma classe : Quando estamos chamando um construtor de outro construtor da mesma classe, então podemos usar a palavra-chave this ().
- Da classe base: Um construtor da classe base pode ser chamado por aquele da classe derivada usando a palavra-chave super.
Por que precisamos do encadeamento de construtores?
Quando queremos realizar várias tarefas em nosso construtor, em vez de realizar cada tarefa em um construtor, dividimos as tarefas em vários construtores e, em seguida, chamamos os construtores um do outro, resultando no encadeamento do construtor.
A seguir estão algumas das regras que precisamos seguir ao executar o encadeamento do construtor.
- O encadeamento do construtor é feito em qualquer ordem e produzirá os mesmos resultados.
- A expressão ‘esta’ palavra-chave deve ser a primeira expressão no construtor.
- Devemos ter pelo menos um construtor sem essa palavra-chave.
Quando temos uma herança em nosso programa, também podemos executar o encadeamento do construtor. Nesse caso, a subclasse chamará o construtor da classe base. Ao fazer essa subclasse, a criação dos objetos começa com a inicialização dos membros da superclasse.
Agora vamos implementar o encadeamento de construtor em Java usando as abordagens acima.
# 1) Encadeamento de construtor dentro da mesma classe
class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } } Resultado:
Como já mencionado, alcançamos o encadeamento do construtor dentro da mesma classe usando a palavra-chave ‘this’. No programa acima, temos três construtores e chamamos um construtor de outro usando a palavra-chave ‘this’.
Da classe base
Quando uma classe herda outra classe, o construtor da classe pai é invocado primeiro, quando criamos um objeto de uma classe derivada que é o encadeamento do construtor.
Se quisermos chamar explicitamente o construtor da classe base na classe derivada, devemos usar a palavra-chave “super” para esse propósito. Usando a palavra-chave ‘super’ podemos chamar os construtores da superclasse na hierarquia de herança até chegarmos à classe superior.
O programa a seguir demonstra o uso de uma palavra-chave ‘super’ para encadeamento de construtor.
qual é o melhor conversor de youtube para mp3
class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }Resultado:
No programa acima, invocamos o construtor parametrizado da classe derivada com o valor “Java”. Este construtor, por sua vez, tem uma chamada para o construtor da classe base usando “super (nome);” que executa o construtor parametrizado da classe base.
perguntas frequentes
P # 1) Como você cria um construtor em Java?
Responda: Criamos um construtor como um método especial que tem o mesmo nome que o nome da classe. Um construtor também não pode ter um tipo de retorno. Ele pode ter modificadores de acesso, mas não pode ser final, estático, abstrato ou sincronizado.
Se ABC é uma classe, então podemos definir seu construtor como
ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructorP # 2) Qual é a vantagem de um construtor em Java?
Responda: Usando o construtor, podemos inicializar os membros da classe como a primeira coisa que o objeto de momento é criado. O construtor elimina a necessidade de chamar métodos normais implicitamente.
Podemos realizar várias tarefas relacionadas à inicialização, início de tarefas, etc. no construtor à medida que os construtores são chamados durante a fase de criação do objeto.
Q # 3) Por que os construtores são usados?
Responda: Construtores são usados principalmente para inicializar os membros da classe e são chamados quando o objeto da classe está sendo criado.
P # 4) O Constructor pode ser privado?
Responda: Sim, podemos ter um construtor privado. Quando o construtor é privado, a classe pode ser impedida de ser instanciada.
Q # 5) O construtor pode ser final?
Responda: Não, não podemos ter um construtor final.
Conclusão
Neste tutorial, começamos nossa discussão sobre construtores em Java. Aprendemos o básico do construtor, sua criação e as regras a seguir. Também discutimos construtores de cópia em Java.
O construtor padrão e tipos de construtores e conceitos como sobrecarga de construtor e encadeamento de construtor foram resumidos com exemplos. Como parte desses tópicos, também vimos o uso da palavra-chave ‘this’ em construtores.
=> Leia a série de treinamento Easy Java.
Leitura recomendada
- Java Class Vs Object - Como usar classe e objeto em Java
- Java Basics: Java Syntax, Java Class e Core Java Concepts
- Java Integer e classe Java BigInteger com exemplos
- Tutorial da classe Java Scanner com exemplos
- Tutorial da classe Java Array - classe java.util.Arrays com exemplos
- O que é Java Vector | Tutorial da classe Java Vector com exemplos
- Interface Java e tutorial de classe abstrata com exemplos
- Classe de robô no Selenium WebDriver com Java