Introdução à Orientação a Objetos em Java

Prévia do material em texto

Aula 03: Princípios da Orientação à Objetos 
 
Objetivos 
 
 
Introdução Classes e Objetos 
 
Todo sistema orientado à objetos pode ser definido como um conjunto de 
objetos que trocam mensagens entre si. Então, quando programamos em 
Java, que é uma linguagem de programação orientada à objetos, estamos 
escrevendo ou definindo um conjunto de objetos que trocam mensagens. 
Bom, mas o que é um Objeto? O que é uma classe? O que é mensagens? 
 
 
 
As classes definem a estrutura e o comportamento de um tipo de objeto. 
 
 
 Classe 
Uma classe é um tipo de modelo que define como são os objetos que 
pertencem a esta classe. É como se fosse um projeto que os objetos 
devem seguir para serem considerados como pertencentes à classe. Neste 
projeto estão definidos as características (que chamamos de atributos) 
e os comportamentos que representam as operações que os objetos 
dessa classe podem realizar (chamamos a isso de métodos). 
 
Exemplos de classes: 
Os animais podem ser classificados em classes, tais como mamíferos, 
aves, peixes, etc. Cada uma dessas classes tem suas características e 
comportamentos comuns, que poderiam ser relacionados (descritos) como 
atributos e métodos dessas classes. 
 
Exemplos de atributos: 
Uma classe pessoa, por exemplo, pode ter atributos como nome, 
endereço, identidade, ou seja, características (dados) específicas de cada 
pessoa. 
 
Exemplos de métodos: 
 Introduzir conceitos de Programação Orientada a Objetos (POO) 
 Aprender a criar classes 
 Aprender a instanciar objetos 
 
Uma classe peixe pode ter um método nadar, uma classe pessoa pode ter 
um método andar ou um método falar, pois estes são comportamentos 
(ações) típicos destas classes. 
 
 O que é um objeto? 
Como vimos, uma classe é uma representação de uma entidade do mundo 
real. Um objeto é uma ocorrência (chamamos a isso de uma instância) 
de uma determinada classe. 
 Exemplos de objetos: 
Matheus é um objeto da classe pessoa. Thor (o peixinho do Matheus) é um 
objeto da classe peixe. 
 
CLASSE OBJETOS CLASSE OBJETOS CLASSE OBJETOS 
 
Carro 
Meu Gol 
Seu Corsa 
Pálio dele 
 
Empregado 
João 
Ana 
Carlos 
 
Formulário 
Demissão 
Cadastro 
Vendas 
 
Abstração 
 Extrair tudo que for essencial e mais nada para o escopo do 
sistema; 
 É o processo de filtragem de detalhes sem importância do objeto 
real, para que apenas as características apropriadas que o 
descrevam e que tenham relevância para o sistema permaneçam; 
 Conceito aplicado à criação de software baseado em objetos, 
partindo do princípio que devemos considerar a essência de cada 
objeto e não pensar em todos os detalhes de implementação; 
 
 
 
 
Classes e Objetos em Java 
 
Definindo uma Classe em Java 
As classes em Java são definidas através do uso da palavra-chave class. 
 
Construindo uma classe: 
 
[modif] class NomeDaClasse { 
// corpo da classe... 
} 
 
A primeira linha é um comando que inicia a declaração da classe. Após a 
palavra-chave class, segue-se o nome da classe, que deve ser um 
identificador válido para a linguagem. O modificador modif é opcional; se 
presente, pode ser uma combinação de public e abstract ou final. A 
definição da classe propriamente dita está entre as chaves { e }, que 
delimitam blocos na linguagem Java. Este corpo da classe usualmente 
obedece à seguinte sequência de definição: 
 
1. As variáveis de classe (definidas como static), ordenadas segundo 
sua visibilidade: iniciando pelas public, seguidos pelas protected, pelas 
com visibilidade padrão (sem modificador) e finalmente pelas private. 
2. Os atributos (ou variáveis de instância) dos objetos dessa classe, 
seguindo a mesma ordenação segundo a visibilidade definida para as 
variáveis de classe. 
3. Os construtores de objetos dessa classe. 
4. Os métodos da classe, geralmente agrupados por funcionalidade. 
 
Antes de continuarmos com os elementos que compõe uma classe, faz-se 
necessário alguns esclarecimentos sobre encapsulamento. 
 
Encapsulamento 
Mecanismo utilizado em orientação a objetos para obter segurança, 
modularidade e autonomia dos objetos; 
Os atributos e métodos de um objeto podem ser escondidos de outros 
objetos por uma interface pública de métodos, de modo a impedir acessos 
indevidos. Para definir diferentes níveis de encapsulamento faz-se uso do 
conjunto de modificadores de acesso disponíveis no Java para os 
membros de classe, com mostrado na tabela. ( * acesso permitido ) 
 
Modificadores Mesma classe Mesmo pacote Subclasses Universo 
private * 
<sem modif> * * 
protected * * * 
public * * * * 
 
 
 
 
 
Atributos 
Representam as características de um objeto. A sintaxe utilizada para 
definir um atributo de um objeto é: 
 
[modificador] tipo nome [ = default]; 
 
Onde: 
 modificador é opcional, especificando a visibilidade diferente da 
padrão (public, protected ou private); 
 tipo deve ser um dos tipos primitivos da linguagem Java ou o nome 
de uma classe; 
 nome deve ser um identificador válido da linguagem Java; 
 valor default é opcional; se presente, especifica um valor inicial para 
a variável. 
 
Métodos 
Os métodos representam as funcionalidades que os objetos podem 
desempenhar. São essencialmente procedimentos que podem manipular 
atributos de objetos para os quais o método foi definido. Além dos 
atributos de objetos, métodos podem definir e manipular variáveis locais; 
também podem receber parâmetros por valor através da lista de 
argumentos. A forma genérica para a definição de um método em uma 
classe é: 
 
[modificador] <tipoDeRetorno> nome(argumentos) { 
corpo do método 
} 
Onde: 
 o modificador (opcional) é uma combinação de: public, protected ou 
private; abstract ou final; e static. 
 o tipoDeRetorno é um indicador do valor de retorno, sendo void se o 
método não tiver um valor de retorno; 
 o nome do método deve ser um identificador válido na linguagem 
Java; 
 os argumentos são representados por uma lista de parâmetros 
separados por vírgulas, onde para cada parâmetro é indicado 
primeiro o tipo e depois (separado por espaço) o nome. 
 
Uma boa prática de programação é manter a funcionalidade de um método 
simples, desempenhando uma única tarefa. O nome do método deve 
refletir de modo adequado a tarefa realizada. Se a funcionalidade do 
método for simples, será fácil encontrar um nome adequado para o 
método. 
 
Métodos de mesmo nome podem co-existir em uma mesma classe desde que a lista de argumentos 
seja distinta, usando o mecanismo de sobrecarga. 
 
Construtores são métodos especiais que possuem o mesmo nome da classe e não apresentam tipo de 
retorno. Podem estar declarados explicitamente ou simplesmente omitidos. 
 
 
Criando Objetos em Java 
Toda classe possui atributos e métodos. Em especial, toda classe tem um 
construtor, que é um método responsável pela instanciação do 
objeto. Este processo faz com que o objeto seja criado com as 
características desejadas. Para que um objeto exista em memória, ele 
precisa ter memória alocada, um endereço definido. O construtor é o 
responsável por isso. 
A criação de um objeto se dá através da aplicação do operador new. 
 
 ClasseNome objeto = new ClasseNome(); 
 
O método a direita do operador new é o construtor da classe ClasseNome. 
Podemos instanciar quantos objetos forem necessários. Contanto que 
guardemos a referência para o objeto em questão. A referência é como 
poderemos acessar aquele objeto. 
 
Caso um objeto não tenha mais nenhuma referência para ele, o coletor de lixo (garbage collector - 
GC) elimina o objeto, liberando a memória. 
 
Criando umprograma Java 
Um programa Java é uma coleção de objetos que são descritos por um 
conjunto de arquivos texto, onde são definidas as classes. Pelo menos uma 
destas classes é ―public‖ e contém o método main(), que possui esta 
forma específica: 
 
 public static void main(String [] args) { 
 // aqui o programador insere os comandos 
 } 
 
Como vimos nas aulas anteriores todos os programas feitos tinham esta 
estrutura. E o nome da classe era o nome do arquivo. Então, podemos 
concluir que uma classe em Java é construída dentro de um arquivo texto 
com o mesmo nome da classe e extensão .java. 
 
 javac Oi.java 
 java Oi 
 
Nos comando acima, o compilador Java compila o arquivo texto Oi.java, 
gerando o bytecode. A máquina virtual interpreta a classe Oi quando o 
comando java Oi é executado. 
Lembro que a classe que contém o método main() é chamada de classe 
principal. 
 
 
Exemplo: 
 
public class Ponto2D { 
 
private int x; 
private int y; 
 
public Ponto2D(int a, int b) { 
x = a; 
y = b; 
} 
 
public double distancia(Ponto2D p) { 
double distX = p.x - x; 
double distY = p.y - y; 
return Math.sqrt(distX*distX + distY*distY); 
} 
} 
 
Neste exemplo, definimos a classe Ponto2D com dois atributos e dois 
métodos. Os atributos são, x e y enquanto os métodos são: 
Ponto2D – Construtor 
distancia – método que calcula a distância entre o ponto e um outro dado. 
 
Um objeto dessa classe tem dois atributos privativos que definem as 
coordenadas do ponto bidimensional, x e y — nesse caso, as coordenadas 
são valores inteiros. 
A classe tem um construtor que recebe dois argumentos, a e b, que 
definem as coordenadas do ponto criado. Finalmente, a classe define um 
método público para calcular a distância entre o ponto que invocou o 
método e outro ponto especificado como o argumento p. A expressão de 
retorno ilustra ainda a utilização de um método estático da classe Math do 
pacote java.lang para o cômputo da raiz quadrada. 
 
 
 
 Interface de classe 
Como vimos, podemos ter carro como sendo uma classe. As características 
ou atributos poderiam ser a cor, o modelo, a potência do motor e assim 
sucessivamente. Os comportamentos ou funcionalidades, poderiam ser 
ligar e desligar, abrir e fechar a porta, acelerar e frear, e outras ações 
(operações) que fossem consideradas úteis para descrever um carro. 
Os atributos e métodos da classe carro constituem o que chamamos de 
interface dessa classe com o mundo externo. Um objeto da classe carro só 
será acessível por outro objeto através de seus métodos, de forma que a 
interface da classe carro deve definir todos os comportamentos desejáveis a 
um objeto desta classe. 
Uma vez que tenhamos definido a interface da classe carro e que tenhamos 
um objeto dessa classe, como fazer para que ele execute a operação ligar? 
Devemos enviar uma mensagem para esse carro (ligue!) e ele executará a 
operação. Nós (externamente ao objeto) é que pedimos ao objeto para que 
execute essa operação, sem precisar saber como o carro faz para ligar (que 
tipo de algoritmo ele usa para isso). O mesmo ocorre se quisermos saber a 
cor do carro. Simplesmente perguntamos (qual é a sua cor?) e o carro 
responde (naturalmente precisaríamos ter criado um método que 
respondesse a isso). Onde e como ele armazena a informação da cor não é 
relevante. Apenas sabemos que ele é capaz de armazenar seus atributos e 
informá-los quando necessitarmos deles. 
O fato dos objetos esconderem sua forma de funcionamento é um conceito 
importante em OO, e está ligado à existência da interface. Somente a classe 
carro conhece a forma de funcionamento (implementação) de seus métodos. 
É o que chamamos de encapsulamento. Ou seja, conhecemos as 
características e as funcionalidades de um carro, mas não sabemos (nem 
precisamos saber) quais técnicas e processos os projetistas utilizaram para a 
construção do projeto, ou seja, para implementar a forma de funcionamento 
de seus métodos. Ou seja, a forma de fazer está encapsulada nos métodos 
do projeto e é de exclusiva responsabilidade do projetista. 
 Representação do problema - UML 
Para estudarmos a Programação Orientada a Objetos (POO), é necessário 
que entendamos a Modelagem Orientada a Objetos (MOO). Essa técnica 
representa as estruturas através de uma linguagem padrão, conhecida como 
UML (Unified Modeling Language), usada para a criação de modelos que 
representam os problemas do mundo real. A UML classifica os ―objetos‖ 
envolvidos no domínio do problema e define as formas como os mesmos se 
relacionam. Não é o nosso foco uma abordagem profunda dos conceitos e 
ferramentas da UML. Utilizaremos apenas os principais elementos da MOO, 
que são necessários para dar andamento à POO. Para implementação 
utilizaremos a linguagem Java. 
Na UML as classes são representadas na forma 
de caixas com, no máximo, três 
compartimentos. O primeiro deles contém o 
nome da classe (sempre no singular e com a 
primeira letra em maiúsculo), o segundo contém 
 
a lista de atributos e o terceiro contém a lista de 
operações. Veja a classe carro: 
A UML (e o Java) sugere que todos os nomes de atributos e métodos se 
iniciem com letra minúscula. Na classe Carro foram criados três atributos: 
dois do tipo String, marca e cor e o terceiro, motorEstado, é um booleano 
que indica se o motor está desligado ou ligado. 
Além dos atributos da classe, queremos também criar métodos que 
contenham as operações que objeto poderá realizar. Um carro pode fazer 
muitas coisas, mas, para manter a simplicidade, vamos criar inicialmente 
apenas três métodos: 
O primeiro é o método ligaMotor, que muda o estado do motor para ligado, 
isto é, para true e depois exibe uma mensagem de aviso. 
O segundo é o método desligaMotor, que muda o estado do motor para 
desligado, isto é, para false e depois exibe uma mensagem de aviso. 
O terceiro método, mostraAtributos, exibe os valores dos atributos de um 
objeto ou instância da classe Carro. 
Exemplo: 
 
class Carro { 
 String marca; 
 String cor; 
 boolean motorEstado; 
 
 void ligaMotor() { 
 motorEstado = true; 
 System.out.println("O motor foi ligado."); 
 } 
 void desligaMotor() { 
 motorEstado = false; 
 System.out.println("O motor foi desligado."); 
 } 
 void mostraAtributos() { 
 System.out.println("O carro tem a cor " + 
 cor + "e eh da marca " + marca); 
 if (motorEstado == true) 
 System.out.println("O motor jah estah ligado."); 
 else { 
 System.out.println("O motor estah desligado."); 
 } 
 } 
} 
 
Bem, até agora, no exemplo, criamos apenas a classe Carro. Precisamos 
criar também um objeto dessa classe. Em Java, uma das maneira de fazer 
isso é adicionar o método main() à classe Carro e nele instanciando 
efetivamente um objeto da classe Carro (comando new). 
public static void main (String args[]) { 
 Carro meuCarro = new Carro(); // instancia o objeto 
 meuCarro.marca = "Palio"; // inicia o atributo marca 
 meuCarro.cor = "azul"; // inicia o atributo cor 
 System.out.println("Mostrando os atributos:"); 
 meuCarro.mostraAtributos(); //mensagem para o objeto 
 
 System.out.println("---------"); 
 System.out.println("Ligando o motor..."); 
 meuCarro.ligaMotor(); //mensagem para ligar o carro 
 System.out.println("Mostrando os atributos:"); 
 meuCarro.mostraAtributos(); 
 
 System.out.println("---------"); 
 System.out.println("Desligando o motor..."); 
 meuCarro.desligaMotor(); 
 System.out.println("Mostrando os atributos:"); 
 meuCarro.mostraAtributos(); 
} 
Após a execução a tela de saída deve exibir algo como: Exercíos 
1. Crie o objeto outroCarro da classe carro com a marca Gol e a cor prata. 
2. Insira um novo atributo rotacaoMotor e inicie-o com zero. O método ligaMotor 
deve atualizar esse atributo para 1000 e o método desligaMotor deve atualizá-
lo para zero. 
3. Crie um novo método acelerar que some 100 ao valor corrente do atributo 
rotacaoMotor. Crie também o desacelerar, que subtraia 100. 
4. A partir do arquivo criado, desmembre-o em dois. O arquivo já existente, de 
nome Carro, só com a classe Carro sem o método main. E outro arquivo, 
denominado Principal, só com o método main (este novo arquivo deve definir 
uma nova classe – a classe Principal). 
5. Crie uma classe Quadrado que tenha um atributo lado e métodos para informar 
a área e o perímetro. Escreva uma outra classe Principal para testar essa 
classe. 
6. Escreva uma classe Calculadora que tenha dois atributos inteiros (inicie-os com 
os valores 6 e 3) e métodos para calcular as quatro operações matemáticas e 
imprimir os quatro resultados. Escreva uma outra classe Principal para testar 
essa classe. 
7. Escreva uma classe que possua um atributo chamado raio (inicie-o com o valor 
1) e métodos para calcular o diâmetro, a circunferência e a área de um círculo. 
Utilize o valor 3,14159 para PI 
Utilize as fórmulas abaixo para os seus cálculos: 
Diâmetro = 2 x raio 
Circunferência = 2 x PI x raio 
Área = PI x raio x raio 
 
Observação: Você também pode usar a constante Math.PI predefinida para 
o valor de PI, que apresenta um valor mais preciso. A Classe Math é 
definida no pacote Java.lang, que não precisa ser importada no seu 
programa. 
Ex.: double varPI = Math.PI;