Introdução ao Static Constructor em Java
Um construtor estático é o pedaço de código usado para inicializar dados estáticos, o que significa que uma tarefa específica precisa ser executada apenas uma vez ao longo do programa. Geralmente, é chamado automaticamente antes que quaisquer membros estáticos mencionados ou uma primeira instância seja gerada. Um construtor estático é aquele declarado explicitamente usando a palavra-chave "estática". Um construtor não pode ser estático, abstrato, final, nativo, sincronizado ou strictfp em Java.
Eles têm alguns recursos exclusivos, como a seguir:
- Parâmetros ou modificadores de acesso não são utilizados por um construtor estático.
- Uma classe específica pode possuir apenas um único construtor estático.
- Herança ou sobrecarga não são permitidas em construtores estáticos.
- Não pode ser chamado diretamente, pois é sempre invocado automaticamente.
- Se os valores de inicialização dos campos estáticos não forem fornecidos, ele será inicializado com o valor padrão, como na tabela Valores padrão.
Sintaxe :
public class (
private ;
public static () ()
)
Aqui, estamos tentando declarar um construtor na classe, definindo-o como estático. Quando esse código é compilado, recebemos uma mensagem de erro informando que o modificador ilegal está sendo usado para o construtor no tipo e somente público, protegido e privado são permitidos.
Trabalho do Construtor estático em Java
Os construtores não podem ser estáticos em Java pelo seguinte motivo:
Em Java, métodos e variáveis estáticas se aplicam às classes. Mas um construtor é chamado quando um novo operador é usado para criar uma instância. Como não pertence à classe de propriedade, não é permitido que seja estático. Se um construtor for considerado estático, ele não poderá ser acessado por um objeto de sua subclasse.
Porém, se um construtor puder ser estático, ele poderá ser acessado dentro da classe, mas não por sua subclasse. Também não pode ser herdado, o que significa que eles pertencem à classe em que são declarados. Permitir que um construtor estático viole todo o conceito de herança, portanto, é ilegal.
Exemplos de construtor estático em Java
Podemos entender melhor o conceito de Static Constructor em Java nos seguintes exemplos:
Exemplo 1
Código:
public class Employee (
//Initialising variables for employee name and ID
public String emp_name;
public int emp_id;
//Declaration of the static constructor
public static Employee()(
System.out.println("Printing Constructor of the Employee class");
)
//Declaring method to print message
public void displayMsg()(
System.out.println("Employee Name is: "+this.emp_name );
System.out.println("Employee ID is: "+this.emp_id );
)
public static void main(String args()) (
//Creating a new object to call the display message constructor
new Employee().displayMsg();
)
)
Resultado:
Aqui estamos recebendo um erro de tempo de compilação nos dizendo que o estático do modificador não é permitido para o construtor Employee () dentro da classe Employee (), pois estamos chamando o mesmo criando um novo objeto abaixo. Isso pode ser resolvido não declarando-o como estático. Confira o exemplo abaixo para o mesmo.
Exemplo 2
Temos que criar 2 classes dentro do mesmo pacote; ParentExample.java e ChildExample.java, que se estendem de sua classe pai.
Código:
ParentExample.java:
public class ParentExample (
ParentExample()(
super();
System.out.println("Printing Super constructor inside Parent class");
)
void displayMessage()(
System.out.println("Printing inside display Message class");
)
)
ChildExample.java:
public class ChildExample extends ParentExample (
ChildExample()(
super();
System.out.println("Printing super constructor inside child class");
)
@Override
void displayMessage()(
System.out.println("Printing display message inside Parent example");
)
public static void main(String() args)(
ChildExample childexample = new ChildExample();
childexample.displayMessage();
)
)
Agora execute o ChildExample.java.
Resultado:
Observações:
- As classes Parent e Child têm construtores padrão sem argumentos e uma mensagem impressa para tornar a execução clara.
- O construtor estático é o primeiro bloco de código a ser executado na classe, pois eles são executados imediatamente quando a execução da respectiva classe é iniciada.
- A subclasse substitui o método display message () e imprime a mensagem.
- Criamos um novo objeto da classe ChildExample que executa o primeiro construtor da superclasse e, em seguida, a segunda subclasse.
- Por fim, o método de exibição do objeto recém-criado é chamado para exibir a mensagem.
- Nos casos em que a herança é implementada, os construtores são chamados explícita ou implicitamente. Portanto, ele deve ser tornado não estático para que seja acessível.
- Quando se torna estática, é associada a uma classe específica que suas instâncias e, portanto, não estará disponível durante a instanciação do objeto.
Exemplo 3
Neste exemplo, combinaremos os construtores estáticos e não estáticos acima e verificaremos sua implementação.
Código:
class ParentClass(
private static String message= "Test message";
// Declaring a nested static class
public static class StaticNestedClass(
// In the nested class only static members belonging to parent class can be accessed
// in a static nested class
public void displayprint() (
// We get a compiler error if we try and make this message
// a non-static variable
System.out.println("Displaying from nested class: " + message);
)
)
// Declaring Inner class or also called non-static nested class
public class ChildClass(
// The static and non-static constructor both can be accessed in
// this Child class
public void displayprint()(
System.out.println("Printing from static non-nested class: "+ message);
)
)
)
class Main
(
public static void main(String args())(
// Instance of static nested class creation
ParentClass.StaticNestedClass printer = new ParentClass.StaticNestedClass();
//Calling the non-static constructor of static nested class
printer.displayprint();
// Creating Parent class instance first in order
//to create the child class instance
ParentClass outer = new ParentClass();
ParentClass.ChildClass inner = outer.new ChildClass();
// Here we call the non-static method of Child class
inner.displayprint();
// Creation of instance for child class in one line
//by combining above 2 lines
ParentClass.ChildClass innerObject = new ParentClass().new ChildClass();
// Now we call the child method
innerObject.displayprint();
)
)
Resultado:
Limitações do Static Constructor em Java
Aqui estão algumas limitações do construtor estático em java fornecidas abaixo:
- Os nomes de construtores não podem ser explícitos e devem ser obrigatoriamente iguais ao nome da classe. Como eles estão confinados a essas convenções, nomes mais legíveis não podem ser dados a eles.
- Toda vez que um construtor precisa ser chamado, um novo objeto deve ser criado. Isso também afeta o desempenho do código, tornando-o lento.
- Os tipos de retorno de construtores são restritos para retornar o mesmo tipo que o do objeto.
- Não podemos usar construtores estáticos na construção de subclasses, pois a implementação de apenas construtores de superclasses é permitida.
- Um construtor estático não permite o uso da palavra-chave "this" para acessar uma instância.
- Os esforços de teste necessários estão mais envolvidos nos construtores estáticos.
Conclusão
A principal tarefa de um construtor é inicializar um objeto e, como visto em todos os exemplos acima, não é permitido que um construtor seja estático pelo principal motivo pelo qual o objeto de uma subclasse e outros membros não estáticos não podem ser acessados por ele. A alternativa ao construtor estático é usar blocos de código estáticos para inicializar variáveis estáticas de uma classe.
Artigos recomendados
Este é um guia para o Static Constructor em Java. Aqui discutimos o trabalho, limitações e exemplos de construtores estáticos em java em java, juntamente com sua implementação. Você também pode consultar os seguintes artigos para saber mais:
- HashMap em Java
- JavaFX FileChooser
- JavaFX TextField
- Botão JavaFX
- Exemplos de método estático JavaScript