Construtores

A ideia principal por trás da OO é separar claramente os conceitos dos algoritmos em entidades atômicas, de modo a tornar o código mais organizado, legível e fácil de manter. Entende-se aqui por entidades atômicas aquelas que são autossuficientes, ou seja, podem existir por si só. Justamente por serem atômicas é que o acesso aos atributos internos das classes, se bem controlados, deixam o código mais seguro.

No exemplo anterior, a seguinte instrução, quando implementada em uma classe diferente da classe Motor, resultaria em erro:

motor.potencia = 10; // erro porque o atributo potencia é privado.

Mas, então, você poderia perguntar: como modificar e acessar o conteúdo de potência? A resposta mais apropriada, mantendo a atomicidade da classe, seria: por meio de métodos específicos para isso, como, por exemplo:

public int getPotencia() {  // obtem potencia

    return(potencia);

}

e

public void setPotencia(int _p) {  // atribui potencia

    potencia = _p;

}

Para modificar o valor do atributo potencia, faríamos:

motor.setPotencia(10); // Maneira correta de atribuir um valor a uma variável privada.

Dessa forma, somente métodos da classe podem acessar seus atributos, garantindo maior segurança na execução do algoritmo.

Normalmente, os atributos são declarados como privados e os métodos como públicos. Atente para o fato de que pelo menos um método da classe, necessariamente, precisa ser público; caso contrário, os objetos dessas classes não poderão interagir com o resto do programa. Assim como para atributos, métodos privados somente podem ser acessados por outros métodos da mesma classe.

Obviamente, como conceitos não existem sozinhos, as classes necessitam se relacionar com outras classes. Por exemplo, os conceitos apresentados anteriormente para a criação/definição de carros (rodas, motor, carenagem, volante e acelerador) necessitam se relacionar de modo a conceitualizar corretamente um carro e colocá-lo em funcionamento. Relacionamentos: podem ser implementados por meio do instanciamento de um objeto internamente a uma classe ou de um ponteiro para esse objeto.

Por exemplo, poderia ser declarada uma classe chamada Valvula e um objeto dessa classe ser instanciado dentro da classe Motor, estabelecendo-se, assim, um relacionamento entre motor e um de seus componentes internos: as válvulas. Veja o exemplo a seguir:

public class Motor {

    private float cilindrada;

    private int potencia;

    private int temperatura;

    private Valvula v; // instância da classe Valvula

    Motor(int _cilindrada) {

        cilindrada = _cilindrada;

        temperatura = 0;

        v = new Valvula();

    }

       public int getTemperatura() {

        return temperatura;

    }

} 

Observe que somente os métodos da classe Motor podem acessar o objeto "v", uma vez que esse atributo é declarado como privado. Ainda, os atributos privados de Valvula também somente poderão ser acessados pelos métodos dessa classe. Por exemplo, imagine que a classe Valvula possui um atributo booleano e privado chamado "executa" e que inicia (no método construtor de Valvula) como false. Se algum método de Motor quiser atribuir true para o atributo "executa" de Valvula, então, terá que ser feito da seguinte forma:

v.setExecuta(true);

Obviamente, o método setExecuta (boolean valor) deverá estar implementado na classe Valvula e deverá ser público (public).