Construtores

   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)

 Algumas coisas que você deve saber sobre construtores:

• 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.

A seguir está um exemplo simples de utilização de construtores:
 

  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:

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