Prat Java 01

PROGRAMAÇÃO JAVA ROTEIRO 01
BREVE INTRODUÇÃO AO JAVA E A ORIENTAÇÃO A OBJETOS
SUMÁRIO
1. Objetivo..........................................................................................................................................2
2. Base Teórica..................................................................................................................................2
2.1. O que é JAVA?........................................................................................................................2
2.2. Orientação a Objeto ................................................................................................................3
2.3. Para Desenvolver em Java no seu Equipamento ....................................................................3
3. Seqüência da Prática .....................................................................................................................5
3.1. Criando o Primeiro Programa ..................................................................................................5
3.2. Um Programa um Pouco mais Sofisticado...............................................................................6
4. Referência Recomendada..............................................................................................................8
5. Exercício Final ...............................................................................................................................8
Anexo A - Princípios de Orientação a Objetos ...................................................................................9
Objetivos ........................................................................................................................................9
Introdução - O mundo das idéias de Platão e Aristóteles ...............................................................9
Orientação a Objetos......................................................................................................................9
Abstração .....................................................................................................................................10
Objetos e Classes.....................................................................................................................10
Métodos e Atributos ..................................................................................................................11
Encapsulamento...........................................................................................................................11
Herança........................................................................................................................................13
Polimorfismo.................................................................................................................................15
Conclusão ....................................................................................................................................15
PRAT_JAVA_01.doc - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 1 / 15

Programação Java Roteiro 01
1. OBJETIVO
Apresentar uma breve introdução à linguagem Java utilizando o compilador da Sun e o IDE1
JGrasp.
2. BASE TEÓRICA
2.1. O que é JAVA?
Java é uma linguagem de programação orientada a objetos desenvolvida pela
Sun Microsystems. Modelada com base no C++, a linguagem Java foi projetada
para ser pequena, simples e portável a todas as plataformas e sistemas
operacionais, tanto o código fonte como os binários ("Write once, run
anywhere"2) - Figura 1. Esta portabilidade é obtida pelo fato da linguagem ser
interpretada, ou seja, o compilador gera um código independente de máquina
chamado byte-code. No momento da execução, este byte-code é interpretado
por uma máquina virtual instalado na máquina. Para portar Java para uma
arquitetura de hadware/sistema operacional específica, basta instalar a
respectiva máquina virtual (JVM).
Esta independência de plataforma é uma das razões pelas quais Java é interessante para
Internet, já que os acessos podem ser realizados a partir de computadores com hardware e
sistemas operacionais distintos. Além disso, Java tem sido adaptado para uso em dispositivos
distintos do computador, como os dispositivos móveis (por exemplo, celulares e agendas; neste
caso, existe o Java 2 Micro Edition - J2ME).
Figura 1. Filosofia da plataforma JAVA.
1
Integrated Develoment Environment. ou ambiente integrado de desenvolvimento.
2
"Escreva uma vez, execute em qualquer lugar (plataforma)".
PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 2 / 15

"Java é uma linguagem de programação dinâmica, simples, orientada a objetos, multi-tarefa,

com recuperação de memória automática, segura, robusta, de arquitetura neutra, portável, de
alta-performance". (Arthur van Hoff, autor do compilador Java)
2.2. Orientação a Objeto

Como dito anteriormente, o Java é orientado a objeto. Um programa Java é uma coleção de uma ou
mais classes que implementam objetos que trocam mensagens entre si para executar a tarefa a que
o programa se propôs.
No Anexo A - Princípios de Orientação a Objetos , há um texto introdutório para explicar o que
vem a ser a orientação a objetos. Após executar a seqüência desta prática, é altamente
recomendada a leitura deste anexo.
2.3. Para Desenvolver em Java no seu Equipamento

Será necessário instalar o compilador Java e um ambiente integrado de desenvolvimento (IDE).
Recomenda-se o compilador Java da Sun e o JGrasp (IDE), ambos gratuitos. O primeiro é padrão,
mas existem alguns outros IDEs disponíveis, como o próprio NetBeans, da Sun, o Eclipse, o
JCreator, Gel, etc. Mas para os primeiros passos, o JGrasp, além de ser mais "leve" para a
máquina, possui alguns aspectos no editor que são úteis para o aprendizado do iniciante, como o
CSD (Control Structure Diagram), ou diagrama de estruturas de controle (espécie de fluxograma),
que permite visualizar melhor a lógica do código, conforme pode ser visto na Figura 2.
Figura 2. CSD do ambiente JGrasp.
Os softwares devem ser baixados (e instalados nesta seqüência) dos seguintes sites:
• JavaTM 2 SDK, Standard Edition (J2SE SDK), version 1.3 (ou posterior):
http://java.sun.com/javase/downloads/index.jsp

• JGrasp 1.8.2 (ou posterior): http://www.jgrasp.org.

Instalando-se o J2SE SDK, basta fazer o download do arquivo indicado abaixo (o tutorial, em
inglês, é opcional, mas seria bom baixar). Durante o processo de instalação, em caso de
dúvida, mantenha as opções default (padrão). Terminado este processo, selecione a opção
Settings/Compiler Settings/Workspace, e na ficha Compiler certifique-se que a linguagem
escolhida é Java. Faça os ajustes que forem necessários.

3. SEQÜÊNCIA DA PRÁTICA
3.1. Criando o Primeiro Programa
Execute o programa JGrasp e a seqüência mostrada baixo para criar seu primeiro programa:
File → New → Java → <Digitar código> → Salvar → <Escolher Pasta> → <Definir Nome> → Save.
O código a ser digitado (mostrado na figura acima) está repetido abaixo
public class AloMundo {

public static void main(String args[]) {
// System.out.println(Msg): imprime Msg na tela console
System.out.println("Alô, Mundo!");
}
}
A estrutura de um programa Java, modo console (tipo "DOS"), terá sempre o mesmo formato
mostrado na Figura 3.
// Obrigatório: o arquivo salvo terá sempre o nome Classe_Principal.java

public class <Classe_Principal> {
// CÓDIGO deve ser colocado aqui;
}
}
// Opcional: outras classes (não públicas) podem ser colocadas aqui.

// Classes públicas são colocadas em arquivos separados.
Figura 3. Estrutura básica de um programa Java (modo console).

Uma vez digitado o programa, o próximo passo é construí-lo (Build) e executá-lo (Run), conforme
ilustrado abaixo: Build → Run → <Ver resultado>.
3.2. Um Programa um Pouco mais Sofisticado

O programa abaixo realiza a soma de dois números fornecidos através de parâmetros fornecidos na
linha de comando. Olhe com atenção os comentários explicando o código.
// Este programa lê dois números da linha de comando e

// realiza sua soma
public class Soma {
// Declara duas variáveis reais
double a,b;
// Converte os strings args[0] e args[1] (parâmetros da linha de
// comando) e os atribui às variáveis a e b
a = Float.parseFloat(args[0]);
b = Float.parseFloat(args[1]);
// Imprime os valores lidos
System.out.println("a: " + a);
System.out.println("b: " + b);
// Imprime a soma
System.out.println("a + b: " + (a + b));
}
}
Crie um novo arquivo e digite o programa acima (ou "copy/paste"). Para executá-lo, execute a
seqüência mostrada na figura abaixo: Build (menu) → <Marcar Run Arguments> → Build (ícone) →
<Digitar dois números separados por espaço> → Run → <Ver linha de comando> → <Ver
resultado>.

Para ver o CSD e colocar numeração nas linhas, clique nos ícones indicados abaixo.

4. REFERÊNCIA RECOMENDADA
Apostila "Introdução ao Java", de Peter Jandl Junior, baixada da Internet e disponibilizada no
Eureka, na pasta conteúdo (arquivo java.pdf). Este material tornou-se posteriormente um livro.
5. EXERCÍCIO FINAL
Antes, leia o Anexo A - Princípios de Orientação a Objetos com atenção. Pergunte ao professor em
caso de dúvida. Implemente o exemplo mostrado para a classe Lâmpada para ver como funciona.
Tomando como base os exemplos deste roteiro, inclusive os do anexo, monte um programa que
calcule a média aritmética de três números. Esses números, a, b e c, podem ser fornecidos pela
linha de comando (como no caso da classe Soma). Para calcular esta média crie uma classe
chamada MediaAritmetica cujo construtor receba a, b e c, definindo os atributos desta classe, e um
método que retorne a média calculada (veja o programa ComissaoVendedor, no Anexo A: Figura 8,
Figura 9 e Figura 10).
Desafio: altere o programa acima para que ele seja capaz de calcular a média ponderada de
três números, dados os pesos pA, pB, pC (pA + pB + pC = 100%).

ANEXO A - PRINCÍPIOS DE ORIENTAÇÃO A OBJETOS

Autor: Pablo Santiago Sánchez (phackwer@bsdmail.org)
Neste texto (do autor acima) foram feitas algumas modificações e acrescentados mais alguns
trechos, bem como criadas e adicionadas algumas figuras e exemplos em Java para facilitar o
entendimento.
Professor
Objetivos
Este texto tem por objetivo apresentar os conceitos básicos para compreensão do que é a
metodologia de Orientação a Objetos, tão discutida hoje em dia, e utilizada em várias das mais
recentes tecnologias que tomaram o mercado, como C++, C#, Java, DOM, UML, etc.
Serão apresentados os conceitos nos quais elas se fundamentam, com alguns pequenos exemplos
na linguagem Java. Com isto, espera-se preparar o leitor para compreender melhor como fazer uso
destas ferramentas quando em desenvolvimento de sistemas.
Introdução - O mundo das idéias de Platão e Aristóteles
A Orientação a Objetos não é em nada uma novidade para a humanidade. Seus princípios datam
da Grécia antiga, ainda no berço da filosofia, com Platão e Aristóteles sendo seus mais ilustres
representantes e pensadores.
Para Platão existiam dois mundos: um material, mundo das formas ou físico, e um ideal, ou
mundo das idéias. Com esta classificação, Platão dizia que um cavalo só era um cavalo no mundo
real porque no mundo das idéias existia uma concepção perfeita de um cavalo. Outro cavalo só
poderia ser um cavalo porque também se encaixaria nesta concepção ideal de cavalo. Mesmo que
os cavalos tivessem atributos diferentes, como cor do pêlo, crina, tamanho, sexo, etc., eles ainda
seriam cavalos porque antes deles havia o conceito, no mundo das idéias, do que era um cavalo.
Assim, uma galinha é galinha porque existe a idéia de galinha, e apenas por isso. Sem a idéia de
galinha, ela não existiria.
Já Aristóteles, embora concordasse com seu mestre, Platão, de que havia um mundo das formas
e outro das idéias, discordava sobre a ordem em que se manifestavam: a idéia antes da forma
(matéria). Para Aristóteles, a galinha só existia no mundo das idéias porque alguns seres puderam
ser agrupados dentro de um conceito por possuírem atributos semelhantes, mesmo que não iguais.
Toda a galinha tem pena, toda a galinha tem asa, toda a galinha tem bico e duas patas. Mesmo
quando não possuísse totalmente estes atributos, ainda poderia ser uma galinha, por ser similar em
vários outros pontos. Ou seja, a galinha já era galinha antes da idéia de galinha.
A seguir é explicado o que é a orientação a objetos, e qual a sua relação com a discussão
filosófica deste item relativa a idéias versus matéria.
Orientação a Objetos
Este é um tópico que não pode ser explicado em simples palavras. A Orientação a Objetos é uma
metodologia na qual tudo em um sistema pode ser representado como um objeto criado a partir de
uma classe, que por sua vez é uma idealização de algo material. A Orientação a Objetos utiliza-se
para isso de quatro alicerces que a diferenciam de outras metodologias. São eles:
• Abstração
• Encapsulamento
• Herança
• Polimorfismo

Abstração
A abstração é a capacidade de definir situações complexas com termos simples. Ou, em outras
palavras, abstrair (tirar, considerar) apenas aquilo que interessa no contexto considerado. Ou
idealizar aquilo que interessa sobre a matéria.
Um exemplo prático disto é a própria galinha citada anteriormente. O termo galinha define um ser
ovíparo, com penas, bico, que cacareja, acasala-se com um galo, tem filhotes, sua carne pode ser
comida assada, grelhada, cozida ou frita, etc. Todos estes elementos podem ser visualizados
utilizando-se apenas o termo galinha. A este processo chamamos de abstração. Vamos ver melhor
o significado da abstração quando compreendermos os termos classe, objeto, métodos e atributos
expostos abaixo.
Objetos e Classes
O que é um objeto? É qualquer coisa que exista no mundo real, que seja visível ou palpável, e que
possua um conceito no mundo das idéias, que é o que lhe dá a forma primária, diria Platão. Já
Aristóteles diria que é qualquer coisa no mundo real que possa ser agrupado dentro de um conceito
criado a partir da observação de atributos comuns.
Quem está correto? Os dois.
Os dois? Pois é, tanto Aristóteles quanto Platão estão corretos.
No mundo da Orientação a Objetos, um objeto nada mais é que uma instância de uma classe.
Mas o que é uma classe então?
O agrupamento de Objetos dentro de um conceito comum é o que se chama de classe. Um
objeto tem que ser de uma classe. Exemplo: uma cadeira com rodinhas está dentro da classe
cadeira, e tem como atributo o fato de seus pés estarem apoiados sobre rodas. Mas ainda assim, é
uma cadeira.
No mundo da Orientação a Objetos, um objeto só pode existir se houver uma classe que o defina
(visão de Platão). Mas essa classe surge da observação do mundo real e do agrupamento de
Objetos que tenham características (atributos) comuns (visão de Aristóteles). Aristóteles seria como
o analista de sistemas que define como seria a classe de um objeto, enquanto Platão seria o
programador fazendo uso dessas Classes já existentes para criar Objetos. E conforme o contexto
em questão, ou problema sendo resolvido, as classes conterão os atributos relevantes a este
contexto ou problema considerado, como na Figura 4, onde apenas o nome e sexo da pessoa, seus
atributos (ver próximo item), foram abstraídos para formar a classe e seus objetos.
Figura 4. A classe Pessoa tem apenas dois atributos, suficientes para o contexto em questão.

Métodos e Atributos
Um objeto não é nada sem métodos para manipulá-lo e atributos para defini-lo como único, mesmo
que exista outro com os mesmos atributos. Os métodos são todas as funções embutidas na classe
e que são utilizadas em cada objeto criado.
Seja uma classe chamada Carro. O que define um Carro? Ele tem marca, modelo, motor com
potência X, o qual pode ser a álcool ou gasolina (ou os dois), tem quatro rodas mais um estepe,
pelo menos duas portas para passageiros, um porta-malas, cor, retrovisor, câmbio manual ou
automático, etc. É um Carro com seus respectivos atributos.
Mas do que adianta saber como é um Carro e eu não poder fazer nada com ele? É aí que
entram os métodos. Quais são os métodos para manipular um carro? Pode-se ligá-lo. Pode-se
acelerá-lo, engatar uma marcha e mexer o volante para a esquerda e para a direita, guiando-se o
carro em uma direção definida com velocidade Y. Assim, o Carro tem métodos com os quais é
possível manipulá-lo e dar uma utilidade real ao mesmo.
Sabendo-se o que define um Carro e como manipulá-lo, tudo que é preciso é uma instância
específica para determinar um objeto do tipo Carro, exclusivo. Assim, vai-se a uma loja e compra-se
o carro com os atributos desejados, manipulando-o de acordo com os métodos oferecidos no
modelo comprado.
A Figura 5 mostra um exemplo mais simples: a classe
Lâmpada. O único atributo, Acesa, indica se ela está ligada ou
não. Sua situação só pode ser alterada através de dois
métodos: Liga e Desliga. Através deste dois métodos é possível
enviar mensagens para o objeto Lâmpada, fazendo com que ele
acenda ou apague. Estes dois métodos estariam associados,
por exemplo, a um botão liga/desliga (interruptor).
Figura 5. Instância da classe (objeto) Lâmpada e sua manipulação.
Na Figura 6 é mostrado um programa Java que manipula uma Lâmpada conforme a definição
mostrada acima. Notar que o atributo Acesa está marcado como privado (private). Isto o torna um
atributo encapsulado (ver próximo item).
Encapsulamento
Para saber o que é encapsulamento, deve-se responder primeiro: o que é uma cápsula? Uma
cápsula é um contêiner que, em seu interior, existem diversos itens, os quais não estão acessíveis
diretamente, a não ser que a cápsula seja aberta. Abrir a cápsula significaria ter acesso a seu
conteúdo e ter oportunidade de manipulá-lo. Um exemplo seria um radio ou uma televisão. A
cápsula seria seu invólucro. Mas para utilizar um rádio ou televisão, não é preciso abri-los, mas
apenas realizar a comunicação com eles (enviar mensagens) através de seus controle e botões
(métodos). Abrir e mexer no conteúdo destes aparelhos poderia ocasionar danos irreversíveis, o
que não é desejável, nem necessário. Enfim, basta saber que a cápsula contém dentro dela tudo

que ela precisa para executar o fim ao qual se propõem, sem que se tenha que saber exatamente
como ela funciona.
Encapsulamento pode ser definido, então, como a tarefa de tornar um objeto o mais auto-
suficiente possível, ocultando do usuário (programador) como isto é feito, e quais os atributos e
métodos estão envolvidos. Apenas se sabe que o objeto funciona.
Certos atributos, e até mesmo certos métodos, não podem e nem devem ser acessados
diretamente pelo usuário. Vários atributos só podem ser acessados, lidos e alterados através de
métodos criados para tal (como os métodos da classe Lâmpada: só através deles tem-se acesso ao
atributo acesa). Esses métodos garantem que o que está sendo feito com o atributo é uma ação
válida, e que não irá danificar o funcionamento do objeto. Como já dito, até mesmo métodos podem
ser acessíveis apenas através de outros métodos, sejam por ser parte de um todo maior e só
funcionarem como métodos de apoio a outras ações, seja porque é necessária uma validação antes
de executá-los, avaliando se o objeto se encontra em estado condizente com o método chamado
(Para que pisar no freio se o carro está parado? Para que acelerar se ele não está engatado?).
public class TestaLampada {

Lampada Lamp = new Lampada(); // Cria Lamp (poderia ser Lampada1)
System.out.println("Lampada criada.\nacesa=" + Lamp.Sit);//Mostra situação
Lamp.liga(); // Mensagem: liga Lampada lamp
System.out.println("Lampada ligada.\nacesa=" + Lamp.Sit);//Mostra situação
Lamp.desliga(); // Mensagem: desliga Lampada lamp
System.out.println("Lampada desligada.\nacesa=" + Lamp.Sit);//Mostra sit.
}
}
public class Lampada {
// Quando é criada, acesa=false
private boolean acesa; // Atributo
public void liga() { // Método Resultado (Console)
acesa = true; // Liga
}
public void desliga() { // Método
acesa = false; // Desliga
}
public boolean sit() { // Método
sit = acesa; // Retorna situação
}
}
Figura 6. Objeto Lâmpada e sua manipulação em um programa JAVA (modo console).
Voltando ao exemplo do Carro, tome-se o método acelerar. O acelerador pode ser pressionado,
ou pisado, para acelerar o carro. Ao pisar no acelerador, a bomba de combustível joga mais
gasolina dentro da câmara de combustão, o que aumenta o giro do motor, deslocando o veículo.
Agora imagine se alguém tivesse de colocar a gasolina diretamente com a mão cada vez que se
quisesse acelerar o carro? O que aconteceria? Na melhor das hipóteses, este alguém sairia
chamuscado.
O encapsulamento serve, então, para determinar que certos atributos e métodos do objeto
instanciado não poderão ser acessados diretamente pelo usuário do sistema sem antes haver uma
validação da ação, e garantir que o objeto seja auto-suficiente, contendo tudo que seja necessário
para manipulá-lo.
Com isso em vista, os métodos e atributos podem ser públicos (acelerar, dirigir, etc), privados
(jogar combustível na câmara de combustão) e protegidos. Este último conceito será abordado na
próxima seção apenas.

Herança
Uma classe pode derivar-se em várias outras, ou pode ser derivada de uma outra classe, conhecida
também como superclasse. Essa derivação é chamada de Herança. Quando uma classe é gerada a
partir de outra, todos os atributos e métodos da superclasse são criados também na nova classe. A
nova classe (ou classe-filha) poderá então implementar novos atributos e métodos, bem como
alterar os existentes. Um exemplo claro de superclasse que gerou uma nova classe seria a
Superclasse Meio de Transporte que gerou a classe-filha Carro.
A herança pode ocorrer também quando uma classe é criada a partir de duas outras existentes.
Neste caso, tem-se a herança múltipla. Um exemplo real seria a Classe Avião misturada à Classe
Barco, que geraria uma nova Classe Hidro-Avião (nem todas as linguagens suportam a herança
múltipla).
Na Figura 7 temos um exemplo de Herança. O vendedor (classe Vendedor) possui como
atributos o nome e o seu faturamento (fat). O método comissão calcula, como sugere, a comissão
do vendedor, ao passo que o método porc retorna a porcentagem fixa do faturamento usada no
cálculo da comissão. O vendedor especial (Classe VendedorSP) também é um vendedor, mas
possui um atributo a mais, que é a porcentagem variável (pc), e o método porc é implementado de
forma distinta, pois a porcentagem não é fixa. Assim sendo, o vendedor especial terá um atributo e
um método reimplementado, e o restante será igual ao do vendedor.
Figura 7. O Vendedor especial (VendedorSP) é uma classe derivada de vendedor.
A Figura 8 e a Figura 9 trazem as duas classes implementadas em Java. Para testar o

funcionamento destas classes, pode-se utilizar o programa da Figura 10, digitando-se após ele o
código das duas classes: Vendedor e VendedorSP.

// Vendedor Padrão
class Vendedor {
// Atributos da classe
String nome;
double fat;
// Construtor
public Vendedor(String n, double f) {
nome = n; // Nome do vendedor
fat = f; // Faturamento de suas vendas
}
// Este método utiliza o método porc() conforme o tipo do objeto que
// o evoca. Se for evocado por um objeto tipo Vendedor, será usado o
// método porc() aqui definido. Se for evocado por um objeto VendedorSP,
// utilizará o método porc definido na classe VendedorSP, se lá existir.
public double comissao() {
return fat*(1 + porc());
}
// Método protegido: visível apenas na classe e nas
// classes derivadas. Retorna a porcentagem de comissão.
protected double porc() {
return 0.1;
}
}
Figura 8. Classe Vendedor em Java.
// Vendedor Especial - Comissão variável

// Classe Derivada da Superclasse Vendedor
class VendedorSP extends Vendedor {
double pc; // Variável exclusiva desta classe
public VendedorSP(String n, double f, double p) {
super(n,f); // Chama o construtor de Vendedor
pc = p; // Define a porcentagem de comissão.
}
// Este é um método virtual (padrão do Java). Será usado pelo
// método comissão (definido na classe Vendedor) apenas se este
// método for evocado a partir de um objeto tipo VendedorSP.
protected double porc() {
return pc;
}
}
Figura 9. Classe VendedorSP em Java.

// Classe para teste das classes Vendededor e VendedorSP.

public class ComissaoVendedor {
// Cria objetos e os inicializa através dos construtores (c/ parâm.).
Vendedor v1 = new Vendedor("Joao", 1000.0);
VendedorSP v2 = new VendedorSP("Valerio", 1000.0, 0.5);
// Como a variável de classe nome não é privada,
// tem-se acesso pelo objeto (mas isso não é recomendável).
// A comissão é calculada pelo método publico virtual
// (sensível ao contexto: sabe quando é vendedor normal ou especial).
// A comissão de ambos os vendedores é impressa.
System.out.println("Comissão do " + v1.nome + ": " + v1.comissao());
System.out.println("Comissão do " + v2.nome + ": " + v2.comissao());
}
}
Figura 10. Classe para teste das classes Vendedor e VendedorSP.
Voltando agora aos métodos e atributos protegidos da seção anterior, o que são eles? Um
método ou atributo é protegido quando ele é privado a todas as outras Classes, exceto às Classes
filhas de uma Superclasse. Na Figura 8 e a Figura 9 o método porc() é protegido, pois só é utilizado
pela classe e superclasse Vendedor e VendedorSP, respectivamente.
Polimorfismo
Este é um dos itens mais confusos de se explicar, sendo mais facilmente absorvido se utilizarmos a
analogia da Superclasse Meio de Transporte.
Um Meio de Transporte pode ser dirigido. Todo o Meio de Transporte possui um método para
dirigir. E ele sempre exige um motorista (argumento passado ao método). Porém, a forma como
este método é executado em cada uma das classes derivadas de Meio de Transporte torna-o um
método polimórfico (com várias formas). Lembre-se da Herança, que faz com que uma classe
derivada contenha os mesmos métodos de uma Superclasse. Um Carro não é dirigido da mesma
forma que uma Moto, que por sua vez não é dirigida da mesma forma que uma Carroça. Mas todos
são Meios de Transporte, e todos possuem este mesmo método.
Isto é Polimorfismo: a capacidade de um mesmo método manifestar-se em Objetos diferentes
com a mesma lista de parâmetros, mas que, quando chamadas, executam tarefas de maneiras
diferentes conforme o contexto. Foi isto exatamente o que ocorreu quando do cálculo da comissão
dos vendedores na classe ComissaoVendedor (programa teste) da Figura 10. Ao solicitar o cálculo
da comissão do vendedor v1 (classe Vendedor), o método comissão utilizou o método (protegido)
porc() da classe Vendedor, ao passo que, no cálculo da comissão do vendedor v2 (classe
VendedorSP), o método comissão utilizou o método da classe VendedorSP.
Conclusão
Embora esta tenha sido uma visão bem geral da Orientação a Objetos, pudemos perceber que esta
metodologia veio para preencher um vazio existente na modelagem e concepção de sistemas. O
objetivo de um sistema computacional é sempre tentar resolver problemas do mundo real. E qual
melhor maneira de fazer isso do que abstrair os Objetos envolvidos no negócio e verificar a forma
como estes interagem entre eles para criar um sistema?
Para muitos, a Orientação a Objetos é a melhor forma para resolver problemas do cotidiano
tendo em mente o funcionamento das relações entre Entidades e Objetos do mundo real, por se
embasar em princípios já estudados a fundo pelo homem desde muito antes da era da informação.
Uma das maiores vantagens da Orientação a Objetos está na capacidade de se chegar a um
ponto tal de abstração que uma classe pode ser utilizada para gerar qualquer classe de um sistema,
economizando bastante o tempo de programação e manutenção, algo que ocorre com um pouco
mais de trabalho em outras metodologias.

Prat Java 01

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Prat Java 01

Enviado por

Direitos autorais:

Formatos disponíveis

PROGRAMAÇÃO JAVA ROTEIRO 01

BREVE INTRODUÇÃO AO JAVA E A ORIENTAÇÃO A OBJETOS

PRAT_JAVA_01.doc - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 1 / 15

Figura 1. Filosofia da plataforma JAVA.

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 2 / 15

"Java é uma linguagem de programação dinâmica, simples, orientada a objetos, multi-tarefa,

2.2. Orientação a Objeto

2.3. Para Desenvolver em Java no seu Equipamento

Figura 2. CSD do ambiente JGrasp.

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 3 / 15

• JGrasp 1.8.2 (ou posterior): http://www.jgrasp.org.

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 4 / 15

O código a ser digitado (mostrado na figura acima) está repetido abaixo

public class AloMundo {

// Obrigatório: o arquivo salvo terá sempre o nome Classe_Principal.java

// Opcional: outras classes (não públicas) podem ser colocadas aqui.

Figura 3. Estrutura básica de um programa Java (modo console).

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 5 / 15

3.2. Um Programa um Pouco mais Sofisticado

// Este programa lê dois números da linha de comando e

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 6 / 15

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 7 / 15

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 8 / 15

ANEXO A - PRINCÍPIOS DE ORIENTAÇÃO A OBJETOS

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 9 / 15

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 10 / 15

Figura 5. Instância da classe (objeto) Lâmpada e sua manipulação.

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 11 / 15

public class TestaLampada {

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 12 / 15

Figura 7. O Vendedor especial (VendedorSP) é uma classe derivada de vendedor.

A Figura 8 e a Figura 9 trazem as duas classes implementadas em Java. Para testar o

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 13 / 15

// Vendedor Especial - Comissão variável

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 14 / 15

// Classe para teste das classes Vendededor e VendedorSP.

PRAT_JAVA_01.DOC - 23/2/2007 6:31 Prof. Dalton Vinicius Kozak 15 / 15

Você também pode gostar