Introdução

A orientação a objetos é uma maneira de programar que trata de modelar os processos de

programação de uma maneira próxima à linguagem humana: tratando componentes de um
programa como um objeto com suas características e funcionalidades.

No cotidiano vivemos cercados por objetos de diversos tipos e formas. O contato com esses
objetos nos leva a identificar suas características físicas, sua forma, etc. Ao visualizarmos um
objeto qualquer, como um veículo por exemplo podemos reconhecer sua forma, modelo,
cor, ou seja suas características.

Outros veículos possuirão características diferentes, o que nos leva a entender que mesmo
objetos do mesmo tipo possuirão diferentes características. Associado com as características
do objeto existe outro fator: os procedimentos (ações) que podem ser realizados ou
analisados com ele. Usando ainda o exemplo do veículo este pode estar parado ou em
movimento, pode ainda aumentar ou diminuir a velocidade (acelerar ou frear).

A programação orientada a objetos tenta simular estes aspectos, trazendo para o

computador a realidade do dia-a-dia.
Definições envolvendo classes
Em Java, tudo é definido e organizado em classes (a própria linguagem é estruturada dessa
forma). Inclusive, existem autores que defendem ser correto chamar a orientação a objeto de
orientação a classes. As classes exercem diversos papéis em programas Java, a princípio
vamos nos ater a duas abordagens:

Classes de modelagem: são as que darão origem a objetos. Ou, ainda, são as que definem
novos (e personalizados) “tipos de dados”.

Classe Principal: terá, por enquanto, a finalidade de implementar o método main (principal).
Poderia ter qualquer nome, desde que respeitadas as regras de nomenclatura de classes. Será
chamada, então, de “Principal”, como referência ao método main.

Nossa primeira classe será a representação de um automóvel segundo os critérios da

orientação a objetos. Para isso, utilizaremos um diagrama de classe (UML), um critério que
valerá para os demais exemplos dessa aula.
Definições envolvendo classes
As classes de modelagem podem ser comparadas a moldes ou formas que definem as
características e os comportamentos dos objetos criados a partir delas. Vale traçar um
paralelo com o projeto de um automóvel. Os engenheiros definem as medidas, a
quantidade de portas, a potência do motor, a localização do estepe, dentre outras
descrições necessárias para a fabricação de um veículo.

Durante a elaboração do projeto, é óbvio que o automóvel ainda não existe. Porém,
quando for fabricado, todas as especificações previamente definidas no desenho terão de
ser seguidas à risca.

Os diferentes modelos desse mesmo veículo terão detalhes diferenciais, como cor da
lataria, tipo das rodas, material do banco, acessórios etc. Nada, entretanto, que altere as
características originais, como um todo.

O funcionamento básico do automóvel também foi definido no projeto. O motorista

poderá acelerar, frear, trocar marchas, manobrar etc. Essas ações, assim como a respectiva
resposta do carro (métodos), permitem uma outra analogia com nosso assunto.
Definições envolvendo classes
O motorista (que seria no nosso caso o programador) não precisa ter conhecimentos
profundos sobre mecânica para, por exemplo, acelerar o automóvel. Internamente, o
veículo possui um complexo mecanismo que aciona as partes responsáveis pela injeção
e pela combustão.

Esta, por sua vez, gera uma pressão sobre outras engrenagens do motor, impulsionando
as rodas e fazendo o carro se deslocar – processos também especificados no projeto.
Para o motorista, quando o objetivo é velocidade, basta saber que é preciso pisar no
pedal do acelerador e que quanto mais pressão for feita mais rápido andará o veículo.

Resumindo: para uso diário do automóvel (objeto) não é preciso conhecer detalhes de
como o funcionamento dos mecanismos foi definido no projeto (classe). Basta operá-los
(chamar os métodos, obedecendo à sua assinatura). Da mesma forma, o programador
não precisa saber, em detalhes, como a classe System, por exemplo, foi desenvolvida,
mas sim saber como utilizá-la para apresentar uma informação na tela.
Atributos e Métodos
 Atributos:

As informações (dados) que definem as características e

os valores pertinentes à classe e que serão armazenados
nos (futuros) objetos são chamadas de atributos.
Também são conhecidos como variáveis de instância.
Para não confundir com variáveis comuns, vamos  Atributos:
chamá-los sempre de atributos. Modelo: Camaro.
Cor: Amarelo.
 Métodos: Portas: 2.

Métodos são blocos de código que pertencem a uma

classe e têm por finalidade realizar tarefas. Geralmente,  Métodos:
correspondem a uma ação do objeto. Considerando-se o Ligar()
exemplo do automóvel, os métodos poderiam definir Acelerar()
processos como ligar, acelerar, frear etc. Frear()
Diagrama de classe
Na descrição das informações contidas no diagrama de classe, novos termos aparecerão.
Nesse momento, porém, o importante é perceber que o diagrama traz detalhes dos
atributos e métodos que compõem a classe. As tabelas a seguir descrevem os detalhes
contidos nos três compartimentos (nome, atributos e métodos) do diagrama de classe.
Por convenção, todo nome de classe
Automóvel começa com letra maiúscula.

- modelo: String O sinal de menos ( - ) indica a

- qtd_portas: int visibilidade do atributo. Nesse caso
- cor: String privado (private). Por convenção todos
- potencia_motor: float os nomes de atributos são escritos com
- velocidade: double letras minúsculas.

+ cadastrarCarro(modelo:String, qtd_portas:int, Depois é especificado o tipo de dado

cor:String, portencia_motor:float):void que será armazenado no atributo.
+ Ligar():void O sinal de mais ( + ) indica a visibilidade
+ Acelerar(valor: double): void do método, nesse caso público (public).
+ Frear(valor: double):void Por convenção o nome dos métodos é
+ Desligar():void escrito em letra minúscula.
Criando uma nova classe
É de nosso conhecimento que cada projeto criado com o NetBeans gera um arquivo com
a extensão .java, que na realidade representa a classe do programa.

A diferença entre um programa e uma classe é que no programa existe o método main
(public static void main String[ ] args) e as demais classes são as chamadas classes
externas, que servirão como uma espécie de “apoio” para a classe principal.

Até este momento estamos acostumados a trabalhar com uma única classe e criando
vários métodos que comunicam-se entre si.

A partir de agora criaremos diversas classes (arquivos .java) e faremos com que estas
troquem informações entre si. Um único projeto pode conter diversas classes.

A seguir temos um exemplo para melhor ilustrar o que foi dito:

Criando uma nova classe

Perceba que no projeto de nome Montadora existe uma classe de nome Montadora.java
que pertence ao pacote de nome montadora.

À direita da imagem percebe-se que o conteúdo desta possui o método principal public
static void main (String [ ] args), ou seja, o que o caracteriza como um programa JAVA e
não uma classe externa ou de apoio como visto anteriormente.

Vale ressaltar que, conforme já foi dito, quando o projeto for executado SEMPRE será
lida primeira a classe que contiver o método principal.
Criando uma nova classe
Para criar uma nova classe basta seguir o procedimento mostrado nas figuras abaixo:
Criando uma nova classe

Podemos notar 2 coisas importantes:

1 – Para esta nova classe criada (carro.java), diferentemente da classe principal

(Montadora.java) não existe a necessidade de se utilizar a primeira letra em maiúscula e
as demais em minúsculas.

2 – No código mostrado no lado direito da figura podemos notar a ausência de uma

classe principal (main), já que esta é uma classe externa ou de apoio.

Podemos ainda notar que as duas classes fazem parte do mesmo pacote (montadora).
Criando uma nova classe
Agora que criamos a classe externa carro.java vamos nos basear no diagrama UML
mostrado anteriormente para criarmos os atributos e métodos da classe.
O método cadastrarCarro recebe da classe principal
Estes são os atributos os parâmetros necessários para cadastrar o carro e
da classe, que por os atribui aos parâmetros da classe. Perceba que
convenção são todos do sempre que fizermos referência aos atributos
tipo private. devemos colocar antes a palavra this, que indica que
este atributo faz parte da classe. Ao final é mostrada
uma mensagem de confirmação do cadastro.

Utilizei nomes diferentes dos parâmetros do método

em relação aos atributos, mas não teria problema se
quisesse utilizar os mesmos nomes, já que o this
diferencia-os.
O método ligar() exibe uma mensagem na tela apenas.

O método acelerar() recebe um valor da classe principal e o incrementa no valor anterior do

atributo velocidade.

O método frear() recebe um valor da classe principal e o faz o inverso do método acelerar()

Idem ao método ligar().

Criando uma nova classe
O projeto do nosso carro (características, funcionamento etc.) já está definido. Vamos
agora “montá-lo”. Na saída vimos que apenas os métodos que
imprimem resultados na tela (System.out.println)
aparecem na saída. Caso quiséssemos mostrar o
que foi cadastrado deveríamos criar um método só
para isso.

Estes são as variáveis que serão passadas como parâmetros aos

métodos da classe carro.

Instanciação do objeto da classe carro. A partir deste momento, todos os atributos e métodos da
classe carro estão disponíveis para serem utilizados pelo objeto camaro. Note que não precisei
utilizar o import como costumamos fazer para utilizar os métodos da classe Scanner. Isto se
deve ao fato de as classes fazerem parte do mesmo projeto.

Os valores das variáveis foram passados ao método

Foi invocado o método ligar() da classe carro. cadastrarCarro da classe carro.

Foi passado o valor de aceleração ao método acelerar da classe carro..

Foi passado o valor de freno ao método frear da classe carro..

Foi invocado o método desligar() da classe carro.

Adicionando mais um método à classe
Vamos agora criar uma classe para mostrar os dados do cadastro do carro.
Este método (classe carro) simplesmente imprime os valores que dos
atributos.

Já na classe principal perceba que permanece a instanciação do objeto

feita anteriormente.

Antes de mostrarmos o cadastro do veículo corretamente devemos

primeiramente chamar o método cadastrarCarro passando os valores.

Após basta chamar o método mostrarCadastro para que sejam

impressas as informações.

Na saída temos o resultado do programa.

That's all Folks