Os
construtores são utilizados para inicializar uma classe, apesar de
serem simples de se utilizar e entender, algumas pessoas tem dúvidas e/ou acabam
utilizando sem saber sobre sua existencia, com este post eu pretendo mostrar o conceito
de construtor com um exemplo prático. A linguagem utilizada será o
Java, os construtores serão utilizados para inicializar um JFrame já
com algumas informações da nossa entidade.
Sobre a sintaxe dos construtores:
- Construtores DEVEM ter o exato nome da classe, lembrando que Java é case sensitive
- Construtores NUNCA terão retorno, nem mesmo void. Se for colocado algum tipo de retorno ele deixará de ser um construtor e se tornará um metodo normal.
- Construtores podem ter qualquer visibilidade (public, default, protected ou private) porem construtores private podem dificultar herança (veja a seguir)
- Usa-se o comando this() para chamar um construtor sem parametros
- Usa-se o comando this("construtor") para chamar um construtor que pede uma String como parametro
- Usa-se o comando super() para chamar o construtor da classe pai que não pede nenhum parâmetro
- Usa-se o comando super("construtor pai") para chamar o construtor da classe pai que pede uma String como parâmetro.
- Se você não definir um construtor, será criado um construtor padrão pela JVM: um construtor sem parametros e que apenas chama super()
- Todo construtor, por padrão, chama o construtor sem parâmetros da classe pai, então mesmo que você escreva código para isso, está implicito que na primeira linha depois de sua declaração existe o comando super(). O único jeito de alterar isto é você declarar explicitamente a chamada de algum outro consstrutor com this ou super.
- Pelo item anterior, podemos observar que quando uma classe é instanciada, pelo menos um construtor de cada nivel da hierarquia é chamado até chegarmos no construtor da classe Object (pois nossas classes implicitamente herdam de Object)
- Se você definir apenas um construtor com visibilidade private, sua classe não poderá ser instanciada fora da própria classe, isto é utilizado no padrão Singleton por exemplo.
Primeiro
eu criei um POJO de cliente:
public class Cliente {
private String nome;
private String tel;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
}
Nada de novo por aqui, uma classe de entidade com dois atributos, 2 getters e 2 setters.
Depois eu
criei um JFrame, este JFrame tem dois campos de texto, um para exibir
o nome do cliente e outro para exibir o telefone:
public class ClienteFrame extends JFrame{
private JTextField txtNome = new JTextField();
private JTextField txtTel = new JTextField();
public ClienteFrame() {
this.setLayout(new GridLayout(4, 1));
this.add(new JLabel("Nome"));
this.add(txtNome);
this.add(new JLabel("Telefone"));
this.add(txtTel);
this.setSize(300, 300);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public ClienteFrame(Cliente c){
this();
this.txtNome.setText(c.getNome());
this.txtTel.setText(c.getTel());
}
}
O JFrame
tem dois atributos privados, que são os campos de texto que exibirão
as informações. Além
destes atributos, a classe ClienteFrame tem dois “métodos” que
tem o mesmo nome da classe, estes são
os construtores desta classe. O construtor sem argumentos monta o layout no nosso frame, enquanto, o construtor que pede um argumento chama o construtor sem argumentos (para que o layout seja montado) e depois adiciona as informações que recebeu como parametro.
SEMPRE que uma classe é instanciada, seu construtor é chamado. Perceba:
SEMPRE que uma classe é instanciada, seu construtor é chamado. Perceba:
JTextField txt = new JTextField();
Cliente c = new Cliente(); //outro construtor
JTextField txt2 = new JTextField("caixa com texto"); //construtor para inicializar o campo contendo um texto
Para finalizar, vamos instanciar nossa classe ClienteFrame com os dois construtores e ver a diferença:
primeiro instanciamos o Frame sem passar nenhum argumento:
public class Main {
public static void main (String[] args){
ClienteFrame frame = new ClienteFrame();
frame.setVisible(true);
}
}
o resultado é um frame com os campos em branco, como mostra a figura:
Mas podemos também instanciar nosso frame passando um objeto do tipo Cliente como parâmetro:
public class Main {
public static void main (String[] args){
//criamos o objeto parametro:
Cliente c = new Cliente();
c.setNome("Nome do cliente");
c.setTel("2673-9000");
//passamos o objeto criado para o nosso frame:
ClienteFrame frame = new ClienteFrame(c);
frame.setVisible(true);
}
}
O resultado será:
No momento acredito que isto seja o básico, se tiver qualquer dúvida sobre o assunto deixe nos comentários
