Em 2007 escrevi neste blog duas aulas de Java. A primeira sendo uma rápida introdução à linguagem e alguns exemplos de código e a segunda falando sobre Orientação à Objetos. Hoje, quase 3 anos depois, resolvi publicar mais aulas de Java. Fui olhar as que já havia publicado para ver o que precisava ser feito e o que poderia ser melhorado e realmente vi que a segunda aula não ficou realmente clara e muita coisa pode melhorar. Nesta terceira farei uma pequena revisão e tentarei deixar um pouco mais claro o que já foi passado, além de passar algumas coisas a mais sobre métodos.

Atributos

Já havia falado sobre atributos na aula anterior. Podemos resumir aqui que são as características de um objeto. Por exemplo, a raça de um cachorro, ou a cor de um pincel, ou os programas de monetização usados em um blog

Em linguagens não-orientadas à objetos costumamos usar o termo variáveis. Segundo o TIExpert.net, não existe praticamente nenhuma diferença entre atributos e variáveis, além do termo. Na verdade, costumamos chamar as varíaveis de atributos em Java pelo simples fato delas estarem dentro de uma classe. Segundo meu amigo Rebert Matheus, “atributos são variáveis das classes (características). Variáveis são internas que só funcionam dentro da classe e não tem nenhum tipo de ligação externa. Um atributo, por exemplo, tem formas de receber e retornar valores externamente. Uma variável não. Um exemplo de variável que não é atributo seria um contador de loops”.

Vamos pegar como exemplo um carro. Seus atributos podem ser: cor, marca, modelo, placa, renavam, chassi, quantide de portas, tipo de câmbio, tipo de espelho, combustível.

Claro que esses atributos, tem um tipo de dado específico. A cor do carro, por exemplo, terá de ser uma String, enquanto a quantidade de portas, um inteiro (int). Com os atributos acima e a definição dos tipos de dados de cada um deles já podemos criar uma classe carro:

Métodos Construtores

Um método é o mesmo que uma função. Em Java podemos dizer que o objetivo do método é realizar uma função. Um exemplo que pode ser usado em cima da classe que já criamos é um método que define as características dos atributos de um carro (devemos lembrar que o método deve ser construído dentro da classe). Veja a imagem…

Todos os atributos receberam um valor. Para ser mais específico, o atributo “renavam” recebeu o valor 0, o atributo “qtde_portas” recebeu o valor 2 e todos os outros, que tem String como tipo de dado, receberam um valor onde não há nada escrito.

Tendo feito isso, podemos declarar um objeto com o comando:

carro objCarro;

Nesse comando o primeiro parâmetro, carro, se refere à classe carro, enquanto o segundo, objCarro, se é o nome que demos ao objeto. Depois disso podemos instanciar o objeto com o comando:

objCarro = new carro();

Onde o primeiro parâmetro, objCarro, é o nome do objeto que declaramos anteriormente e carro() é o nome do construtor (justamente o método mostrado na imagem acima). Também podemos declarar e instanciar um objeto ao mesmo tempo se usarmos o comando abaixo:

carro objCarro = new carro();

Agora que temos o objeto declarado e instanciado (tanto faz se foram usados os dois primeiros ou apenas o último comando), podemos chamá-lo de outra classe com o comando abaixo:

objCarro.carro();

Isso irá fazer justamente o que foi proposto. Deixará todos os atributos de String sem nada escrito e os atributos “renavam” e “qtde_portas” com os valores 0 e 2 respectivamente.

Passagem de Parâmetros

Também é possível (e obviamente muito mais interessante) passar parâmetros para os métodos. O exemplo abaixo mostra o mesmo método com uma pequena diferença: o atributo cor recebe um valor específico. Para isso ser possível definimos depois da classe o tipo de dado que seria passado e usamos o comando this para diferenciar o atributo da classe do parâmetro usado no método (já que os dois tem o nome cor):

Como pode ver na imagem acima, todos os outros atributos continuaram com os mesmos valores que já haviam sido definidos, enquanto o atributo “cor” foi o único que recebeu um valor por passagem de parâmetros. Para o método criado passamos o parâmetro quando instanciamos o objeto:

objCarro.carro = new carro("Azul");

Dessa forma o atributo “cor” recebe o valor “Azul” que foi passado durante a instanciação do objeto. Claro que na prática outras formas serão usadas para passar o parâmetro, como o JOptionPane, por exemplo, para que o programa dê ao usuário a opção de digitar um valor:

objCarro.carro = new carro(JOptionPane.showInputDialog("Digite a cor do carro:"));

Para saber mais detalhadamente sobre métodos, recomendo a leitura do artigo de Rafael Cardoso Pereira.

Classe Principal

Com os métodos já construídos, precisamos de uma classe principal, também chamada de main, que é por onde o programa é iniciado (leia mais sobre a classe principal no HTMLStaff). Na imagem abaixo podemos ver a classe principal (chamada digitação) e notar dentro dela a seguinte linha: “public static void main (String args[])“. É justamente isso que faz dela a classe principal do programa. Dentro desse bloco que serão executados os primeiros comandos do programa:

Neste exemplo o objeto foi declarado e depois instanciado sem passar nenhum parâmetro. Apenas isso… Já para a imagem anterior usei como exemplo o comando  “objCarro.carro = new carro(JOptionPane.showInputDialog("Digite a cor do carro:"));” que pede ao usuário uma cor e passa por parâmetro na hora de instanciar o objeto.

Código do programa

Segue abaixo os códigos usados nas imagens caso alguém queira copiar e compilar para estudos. A única diferença aqui é que fiz a classe principal pedindo a cor para o usuário na hora da instanciação. Os dois métodos criados no começo do post estão dentro da classe carro – o método que não aceita parâmetros e o que recebe a cor por parâmetro (sim, é possível vários métodos de mesmo nome dentro de uma mesma classe. O nome disso é sobrecarga de métodos. O TIExpert.net tem um artigo explicando mais detalhadamente esse assunto).

Na classe principal é usado o comando JOptionPane para pegar um valor digitado pelo usuário na hora de instanciar o objeto. Por isso foi necessário usar o comando import. Leia mais sobre import e pacotes aqui e sobre JOptionPane aqui.

carro.java

[sourcecode language="java"]
public class carro {
String cor;
String marca;
String modelo;
String placa;
float renavam;
String chassi;
int qtde_portas;
String cambio_tipo;
String espelho_tipo;
String combustível;

public carro() {
cor = "";
marca = "";
modelo = "";
renavam = 0;
chassi = "";
qtde_portas = 2;
cambio_tipo = "";
espelho_tipo = "";
combustivel = "";
}

public carro(String cor) {
this.cor = cor;
marca = "";
modelo = "";
renavam = 0;
chassi = "";
qtde_portas = 2;
cambio_tipo = "";
espelho_tipo = "";
combustivel = "";
}
}
[/sourcecode]

digitação.java

[sourcecode language="java"]
import javax.swing.JOptionPane;

public class digitacao {
public static void main (String args[]) {
carro objCarro;
objCarro = new carro(JOptionPane.showInputDialog("Digite a cor do carro:"));
}
}
[/sourcecode]

Na próxima aula explicarei sobre herança e, se sobrar tempo, encapsulamento. Comentários, elogios, críticas e qualquer outro tipo de feedback são bem-vindos. Obrigado!

Para acessar todas as aulas do blog clique aqui!