Trabalho Tutela Java Jailton

JAILTON DE ARAUJO SANTOS
CC8P39 - Tutelado
RA: 986352-4
CONCEITOS DE ORIENTAÇÃO AO OBJETO E EXEMPLO DE

APLICAÇÃO NA LINGUAGEM JAVA
UNIVERSIDADE PAULISTA
SÃO PAULO
09/2012
JAILTON DE ARAUJO SANTOS
CC8P39 - Tutelado
RA: 986352-4
CONCEITOS DE ORIENTAÇÃO AO OBJETO E EXEMPLO DE

APLICAÇÃO NA LINGUAGEM JAVA
Trabalho referente à disciplina LPP
(laboratório de práticas de programação),
sob a orientação do professor Dênis
Ogura.
UNIVERSIDADE PAULISTA
SÃO PAULO
09/2012
RESUMO
Desde que os sistemas computacionais foram criados, o homem procura suprir suas
necessidades diárias através de ferramentas informatizadas, seja para escrever uma
simples carta, para se divertir nas horas de folga ou para solucionar os problemas e
funções mais complexas em seu trabalho. Assim sendo, sempre há a necessidade
de ter-se um software cada vez mais flexível, eficiente e acima de tudo bem
estruturado, baseando-se em boas práticas de modelagem e programação. Visando
suprir então tais necessidades surgiram os conceitos de Orientação ao Objeto, e
apoiado nestes conceitos foi desenvolvida a linguagem de programação Java. Desta
forma, foi possível desenvolver softwares cada vez mais eficientes, eficazes e
aderentes às necessidades das pessoas e corporações. Visando demonstrar então
a aplicabilidade dos conceitos de Orientação ao Objeto na linguagem de
programação Java, e seus aspectos gerais, foi desenvolvido um software de
exemplo para cadastro e gerenciamento de uma pequena rede hoteleira, chegando
à conclusão de que o Java utilizando práticas de programação orientada ao objeto
pode ser utilizado por programadores como uma alternativa para o desenvolvimento
de software.
Palavras-Chave: Orientação ao Objeto, Java, software

Índice de Figuras
Figura 1 - Exemplo de Herança Simples e Múltipla .............................................................. 15
Figura 2 - Demostração de Polimorfismo ............................................................................. 17
Figura 3 - Demonstração Polimorfismo por Sobrecarga de Métodos ................................... 17
Figura 4 - Tela Principal do Programa de Exemplo .............................................................. 20
Figura 5 - Tela de Cadastro das Filiais ................................................................................ 21
Figura 6 - Tela de Cadastro de Hóspedes ........................................................................... 22
Figura 7 - Tela de Cadastro do Movimento de Hóspedes .................................................... 23
Figura 8 - Configuração Básica Java ................................................................................... 26
Figura 9 - Exemplo de Aplicação Construída com Java EE ................................................. 27
Figura 10 - Exemplo de funcionamento da JVM................................................................... 29
Figura 11 - Funcionamento da JVM nos diversos ambientes ............................................... 29

Sumário
INTRODUÇÃO ...................................................................................................................................... 6
1. DEFINIÇÃO DE PROGRAMAÇÃO ORIENTADA AO OBJETO (POO) .............................. 8
2. CONCEITOS BÁSICOS DA ORIENTAÇÃO AO OBJETO .................................................... 9
2.1 Classes................................................................................................................................... 9
2.2 Objetos ................................................................................................................................. 11
2.3 Abstração ............................................................................................................................. 12
2.4 Encapsulamento ................................................................................................................. 13
2.5 Herança ................................................................................................................................ 14
2.6 Polimorfismo ........................................................................................................................ 16
3. ORIENTAÇÃO AO OBJETO (OO) APLICADO NA LINGUAGEM JAVA........................... 18
3.1 Exemplo de aplicação dos conceitos de OO ................................................................. 19
3.2 Utilização do Java como modelo de linguagem de programação .............................. 26
3.3 Java EE ................................................................................................................................ 27
3.4 Java Virtual Machine (JVM) .............................................................................................. 28
4. CONCLUSÃO ............................................................................................................................. 31
BIBLIOGRAFIA ................................................................................................................................... 32
ANEXOS .............................................................................................................................................. 33
6
INTRODUÇÃO
As linguagens de programação desde a criação dos computadores passam

por um processo evolutivo incessante, isto por que a cada dia que passa mais
recursos são requeridos aos softwares visando o atendimento das necessidades
humanas. Desta forma, pode-se citar ainda nos anos 40 quando os computadores
foram criados, que nem havia uma linguagem de programação específica, sendo
que para programar as tarefas a serem executadas era necessário ligar e desligar
chaves que simulavam operações binárias e assim calcular o que era solicitado.
Apesar de esta máquina ser um marco para a época, as necessidades

humanas falaram mais alto, fazendo com que diversos estudos fossem realizados a
fim de solucionar outros problemas mais complexos. Com isto o poder
computacional do hardware foi sendo cada vez mais incrementado permitindo com
que as diversas linguagens de programação fossem criadas.
Nesta linha então surge à linguagem de baixo nível Assembly, que por sua
vez serviu de base para a primeira linguagem de alto nível denominada Fortran. O
Fortran, entretanto só tornou mais amigável a maneira de se programar, uma vez
que seu estilo de programação é bem semelhante ao seu antecessor Assembly. Já
nos anos 60 graças à corrida espacial inicia-se a grande evolução tecnológica que
fez com que as linguagens de alto nível fossem cada vez mais eficientes, eficazes e
reutilizáveis. Desta maneira nasce a programação estruturada com a criação das
linguagens C e Pascal. Esta técnica de programação permitia que vários problemas
complexos fossem solucionados por programas cada vez mais simples e fáceis de
entender, uma vez que sua linguagem visava coincidir com a linguagem humana. O
grande problema desta técnica de programação era que conforme o tamanho do
projeto criado crescia, aumentava também seus custos de manutenção.
Desta forma então surge à ideia de ter-se um código escrito de maneira a

solucionar os problemas mais complexos, e que ao mesmo tempo pudesse ser
simples de manutenir, uma vez que para muitos destes projetos a técnica de
programação estruturada já não atendia as necessidades requeridas. Com isto
surge no final dos anos 60 o conceito de programação orientada ao objeto, através
da criação da linguagem Simula.
A programação orientada ao objeto (POO) aproveitou todas boas ideias da

programação estruturada, combinando-os com os conceitos de orientação ao objeto.
Isto fez com que os programas se tornassem cada vez mais complexos e ao mesmo
tempo simples de programar e manutenir, uma vez que tais problemas poderiam ser
decompostos em vários subgrupos mais simples relacionados. Estes subgrupos
seriam os objetos.
7
A partir daí diversas linguagens de programação sob este paradigma foram

criadas em todo o mundo, cada qual propondo suprir determinada necessidade
humana. Desde a consagrada Smalltalk criada pela Xerox no final da década de 70,
até as atuais Java, C# e Pyton.
Para apoiar então este novo paradigma de programação, surge em meados

dos anos 90 a linguagem de programação Java, causando uma grande revolução no
mercado de desenvolvimento de software da época. Vários fatores favoreceram para
que este cenário fosse criado, mas certamente um dos mais significativos foi o fato
da ferramenta favorecer a produção de softwares multiplataforma, algo impensável
através do uso de outras ferramentas concorrentes. Outro ponto na qual o Java se
diferenciou dos demais concorrentes, causando um grande fervor no mercado de
software foi o fato de tanto a linguagem quanto as diversas IDE’s serem totalmente
freeware. Desta forma, com o passar dos anos a ferramenta foi se consolidando
cada vez mais entre os desenvolvedores e a comunidade da computação, tornando-
se uma das mais importantes em seu segmento.
Percebendo-se então este cenário favorável ao desenvolvimento de softwares

baseados sob os conceitos de Orientação ao Objeto (OO), foi elaborado este estudo
que visa esclarecer alguns dos principais conceitos deste paradigma de
programação, fornecendo ao leitor uma ideia básica do que é este conceito de
programação. Para que isto fosse possível foi adotada a linguagem de programação
Java, por ser uma ferramenta muito popular entre os desenvolvedores de todo o
mundo, gratuita, de alta qualidade e acima de tudo por apoiar a programação
utilizando os conceitos da Orientação ao Objeto.
Desta forma o estudo foi organizado nas seguintes seções: o capítulo um traz
uma visão geral e básica do que é a programação Orienta ao Objeto, o capítulo dois
informa ao leitor quais são e como funcionam os princípios e conceitos básicos
desta técnica de programação. No capítulo três é demonstrado um exemplo de
aplicação dos conceitos de OO, descrevendo onde e como estes conceitos são
aplicados. Finalmente na última seção do trabalho são descritas as conclusões finais
sobre o estudo realizado.
8
1. DEFINIÇÃO DE PROGRAMAÇÃO ORIENTADA AO OBJETO

(POO)
A Programação Orientada ao Objeto consiste em uma técnica que visualiza

os sistemas como se fosse uma coleção de vários objetos interligados, permitindo
assim que o sistema seja reutilizável e ao mesmo tempo extensível. Seu conceito
baseia-se na aplicação dos conceitos de abstração de dados, encapsulamento,
hierarquização, relacionamento, simultaneidade, classificação, persistência e
modularização.
O paradigma a ser solucionado com a Programação Orientada ao Objeto é o

de realizar uma representação fiel dos problemas da vida real através dos sistemas
computacionais. Esta técnica copia o que ocorre na vida real, onde vários objetos
diferentes interagem uns com os outros de maneira harmônica. Por exemplo,
analisam-se as seguintes problemáticas: “O cachorro bebe água” e “o peixe vive na
água”. Na natureza não existe uma água exclusiva para o cachorro beber e outra
para o peixe nadar. Neste exemplo a natureza pode dispor de um único objeto
“água” na qual o peixe nada e o cachorro bebe.
Em termos de programação então podem-se aplicar estes mesmos conceitos,

simplificando a solução de nossos problemas do cotidiano. Um exemplo seria a
criação de duas classes, a primeira denominada “Aluno” e a outra denominada
“Professor”. Ambas as classes pertencem a uma outra classe comum denominada
“Pessoa”. Então para criarem-se as classes “Aluno” e “Professor” não será
necessário criar as características de pessoa para cada um, podendo reutilizar
somente a classe “pessoa” comum para ambos.
Segundo (FARINELLI, 2007), pode-se definir a orientação ao objeto como

uma coleção de objetos que interagem de maneira organizada, e que possui como
grande diferencial frente a outros paradigmas de programação o conceito de
herança, na qual se pode facilmente estender as definições pré-existentes. Além
disto, deve-se considerar também o conceito de polimorfismo, que ainda conforme
(FARINELLI, 2007) garante que determinadas funcionalidades dos objetos sejam
selecionadas durante a execução.
9
2. CONCEITOS BÁSICOS DA ORIENTAÇÃO AO OBJETO
A programação orientada ao objeto baseia-se principalmente nos conceitos

da utilização de classes e seus respectivos objetos, que por sua vez servirão de
base para toda estrutura deste paradigma de programação. Então as diferentes
formas de se utilizar estas classes existentes no projeto, determinarão quais
características de orientação ao objeto serão utilizadas, tais como herança,
instância, encapsulamento, polimorfismo e abstração.
Resumidamente então, a OO consiste no conceito do envio de mensagens a

objetos, que por sua vez podem responder a um ou a “n” objetos diferentes e
simultâneos (Oracle, 2012). Ao final, com todas as respostas dos objetos atendidas
o programa chega a seu objetivo final que é a solução do problema proposto. Com
isto segundo (Oracle, 2012), conseguimos aumentar a produtividade e a qualidade
dos softwares, que mesmo se propondo a solucionar as problemáticas mais
complexas, ao mesmo tempo se tornam mais simples. Desta forma, a comunidade
acadêmica consegue criar um código reutilizável e simples de manutenir,
aumentando a eficiência, eficácia e qualidade dos sistemas criados, porém
diminuindo seus custos gerais.
Segue abaixo a descrição da estrutura dos objetos e das classes utilizadas

em uma linguagem de programação orientada ao objeto.
2.1 Classes
Conforme (RICARTE, 2001) classe é um conjunto de métodos e atributos,

sendo que tais características determinarão o funcionamento e modo de operação
desta classe. Desta forma, pode-se determinar que cada objeto criado consistirá em
uma instância de determinada classe.
Apesar de o nome desta técnica de programação remeter a Programação

orientada a objetos, na verdade o que é realizado é a criação de diversas classes, e
dentro destas classes pode-se utilizar seus diversos objetos disponíveis.
No exemplo citado anteriormente utilizando o objeto “carro”, pode-se possuir a

classe “concessionária” que por sua vez traria consigo diversos objetos “carro”
previamente instanciados, cada um com seus próprios atributos diferenciando-os
entre si.
10
De acordo com (DALL'OGLIO, 2012), a principal diferença entre objetos e

classes é que classe é um modelo que contém diversos objetos com atributos
comuns, porém cada um com seu próprio valor, o que interfere no resultado de seus
métodos.
Porém pode ocorrer de diversas classes também possuírem características

comuns, fazendo com que uma classe englobe outra maior. Esta característica
fundamenta o conceito de subclasse e de superclasse. Continuando nos exemplos
anteriores, a subclasse “concessionária” poderia pertencer à superclasse
“montadora”. Este “efeito cascata” que vai sendo criado origina a chamada
“hierarquia de classes”.
Esta hierarquia de classes também gera o que se chama de classes

descendentes e ancestrais. Para exemplificar é possivel continuar utilizando os
exemplos anteriores, na qual a superclasse “montadora” é ancestral de
“concessionária”, que por sua vez possui vários descendentes, por exemplo, os
objetos “palio”, “fox”, e “corsa”.
Segundo (RICARTE, 2001), as classes realizam a descrição de como os

objetos devem ser, porém o que existe realmente são os objetos, já que é deles que
obtemos os resultados dos métodos.
Seguindo os conceitos do modelo de orientação ao objeto, surgem os

conceitos de instância e de classes abstratas.
 Instancia: É quando a classe gera um objeto, de forma a ser alocado

em memória servindo de modelo para criação de outros objetos. Isto
gera o conceito de que cada objeto nada mais é do que a instância de
uma classe. Utilizando o exemplo dos carros, cada modelo existente na
concessionária é uma instancia do objeto “carro”. A seguir segue um
exemplo de criação de uma instância de uma classe denominada
“Exercicio06a”:
Exercicio06a obj = new Exercicio06a();
Desmembrando esta linha de código, pode-se analisar a função de

cada função exercida. Segue abaixo esta descrição:
Exercicio06a  este comando indica qual classe será instanciada.
Obj  neste comando temos a indicação da criação do objeto.
new Exercicio06a();  neste comando há a indicação do método

construtor a ser chamado, seguido do caractere delimitador.
11
 Classe Abstrata (pura): É o tipo de classe na qual seus objetos nunca

são instanciados diretamente, sendo que para esta tarefa sempre é
utilizada uma subclasse descendente. Sua principal função é a de
definir os padrões de programação a ser aplicados, tais como a
nomenclatura e o tipo das variáveis a ser utilizadas.
Conforme (FARINELLI, 2007) o objetivo deste modo de

programar é de facilitar e criar um modelo de estruturação ao código. A
autora cita um exemplo de utilização desta técnica na qual temos uma
classe “pessoa” com seus diversos atributos, e a partir desta classe
temos as subclasses “funcionário” e “gerente”. Neste exemplo a classe
“pessoa” nunca terá um objeto instanciado diretamente, servindo
apenas de meio de unificação entre “funcionário” e “gerente”.
2.2 Objetos
Os objetos consistem na representação dos elementos da vida real. Porém

para solucionar determinado problema só serão considerados os objetos referentes
à determinada problemática. Desta maneira o Objeto pode ser definido como uma
entidade do mundo real representada para determinado ambiente (RICARTE, 2001).
Ainda segundo (RICARTE, 2001), os objetos podem ser definidos como

instâncias de classes com a função de carregar as informações dos objetos e sua
maneira correta de manipulação. Estas informações retidas servirão de base para a
realização das operações necessárias. É a partir dos objetos que ocorre todo o
processamento necessário nas linguagens escritas sob o conceito de orientação ao
objeto.
Os objetos então podem representar qualquer objeto comum da vida real,

abrangendo um objeto em si ou qualquer ser vivo, funções, eventos, ações ou
lugares representativos para determinado sistema a ser desenvolvido.
Cada objeto possui uma série de atributos que consistem no conjunto de

características intrínsecas a ele. Por exemplo, pode-se citar o objeto “carro” na qual
pode possuir os seguintes atributos:
 Marca
 Modelo
 Ano
 Potência
 Etc.
12
Além dos atributos, cada objeto também traz consigo uma série de ações
características, nas quais descrevem os métodos ou serviços de cada objeto. No
exemplo acima do carro os métodos disponíveis seriam:
 Andar
 Frear
 Buzinar
 Soltar Fumaça
 Etc.
Então conforme (CAELUM, 2012) em termos de Orientação ao objeto, os

atributos podem ser considerados as variáveis ou campos responsáveis pelo
armazenamento de valores, sendo que o estado do objeto será definido pela
combinação destes valores recebidos. Já os métodos seriam as funções do objeto
nas quais descrevem todas as ações na qual o mesmo pode ter. Os métodos então
possuem a capacidade de modificar o valor dos atributos de determinado objeto.
2.3 Abstração
Segundo (FERREIRA, 2012), o conceito literal de abstração consiste em

“separar um ou mais componentes de um todo, sendo que cada componente
somente pode existir dentro do contexto do todo”. Trazendo o conceito de abstração
para a programação orientada ao objeto, então pode-se afirmar que esta técnica faz
com que determinadas informações sejam ocultas do consumidor do método,
fazendo com que ele tenha representado somente o que precisar utilizar.
Desta forma conforme (SIERRA, 2007), o objetivo da abstração é de dividir

um problema de solução complexa em diversos problemas simples, de maneira que
quando todos estes problemas simples estiverem solucionados teremos a solução
do problema inicial complexo. Assim sendo, a abstração pode ser definida como a
propriedade de interpretação de uma determinada situação problema dividindo-a em
várias classes individuais, que quando colocadas em execução solucionarão a
problemática proposta, abstraindo então este problema para um código pronto a ser
executado ou interpretado.
(CARMO, 2012) afirma que é possivem determinar pesos as partes do

programa através da utilização da abstração, uma vez que é permitido ressaltar ou
desconsiderar determinadas partes do programa.
13
2.4 Encapsulamento
Como o próprio nome diz, o encapsulamento é uma maneira de se ocultar do

utilizador do método seu conteúdo, de forma a simplificar seu processo de análise.
Desta maneira somente é possível alterar os atributos dos objetos através da
utilização de seus métodos. Ao lado da abstração é um forte recurso da
Programação Orientada ao Objeto, sendo vastamente utilizado pelos
programadores.
Pode-se exemplificar o encapsulamento descrevendo-se a forma de se

instanciar diversas classes em um determinado projeto. Ao instanciarmos tal classe
todos seus métodos e atributos estarão encapsulados, bastando apenas ao
utilizador do método transmitir os parâmetros necessários a sua utilização. Desta
forma podemos instanciar a mesma classe ou método diversas vezes, criando
diversos objetos diferentes e individuais entre si. Assim sendo, mesmo possuindo a
mesma classe de origem uma alteração em um objeto não interfere em outro, uma
vez que cada instancia representa um encapsulamento diferente.
Segundo (RICARTE, 2001), a grande vantagem da utilização da

programação orientada ao objeto utilizando a técnica de encapsulamento frente as
técnicas de programação estruturadas antigas, é que assim é possivel fazer-se uso
de todos os recursos de determinado objeto sem conhecer sua estrutura interna.
Trazendo este exemplo pra vida real, pode-se exemplificar a capacidade de
encapsular da seguinte forma: quando se acelera um veículo o mesmo aumenta sua
velocidade, porém os meios na qual o veiculo utilizou para realizar esta operação
estão encapsulados, e o motorista não sabe o que aconteceu por tras de sua ação
de pisar no acelerador. Assim sendo, se houver diversos objetos “carro” instanciados
em memória, e todos estiverem utilizando o método “acelerar”, a quantidade de
velocidade atigida por cada objeto “carro” criado dependerá apenas da entrada do
parametro “intensidade no acelerador” passado como parametro para cada objeto.
Ainda conforme (RICARTE, 2001), outra grande vantagem do

encapsulamento é que é possivel realizar atualização interna nos objetos de forma
transparente ao usuário. Segundo o autor, isto melhora a reusabilidade e a
adequação do objeto as futuras inovações tecnológicas.
Com as informações encapsuladas o único ponto importante a ser obedecido

é o de ambas as partes conchecerem os dados comuns de interface a serem
enviados ou recebidos.
14
2.5 Herança
Assim como o próprio nome sugere, a Herança é algo que pode ser recebido
por doação ou por hereditariedade (FERREIRA, 2012). Em termos biológicos,
podemos exemplificar a herança na transmissão das propriedades genéticas de pai
para filho de geração em geração.
Já em termos de Programação Orientada ao Objeto, a herança se dá quando

temos uma classe que passa suas características e métodos para outras, que com
isto pode utilizá-la e expandi-la. Assim sendo construímos classes nas quais
herdaram características e métodos de outras classes, formando assim classes
herdeiras.
(RICARTE, 2001) conceitua herança como sendo uma importante técnica de

reutilização do código, já que com ela podemos fazer o compartilhamento de
métodos e atributos. Além disto, é possível criar-se classes filhas com as mesmas
características da classe pai, porém incluindo métodos e atributos novos e
característicos.
Segundo (CASTRO, 2012), “herança significa que todos os atributos e

métodos programados no ancestral já estarão automaticamente presentes em seus
descendentes sem a necessidade de reescrevê-los”.
Além de garantir uma maior produtividade, (CAELUM, 2012) afirma que a

herança também facilita a manutenção do código, uma vez que corrigido algo na
classe pai, automaticamente atualiza-se as classes filhas.
Podemos herdar classes de duas maneiras diferentes, são elas:
 Herança simples
Denomina-se herança simples quando se herda apenas características

apenas de uma superclasse. Como exemplo, pode ser citado uma
superclasse denominada “criança” e uma subclasse derivada dela
denominada “aluno”. Neste exemplo a subclasse aluno herda todas as
características apenas da superclasse criança, porém com a inclusão dos
métodos e atributos que diferenciarão o aluno da criança. Entretanto não há
impedimentos para que a classe criança gere qualquer outra subclasse.
Como exemplo pode-se citar esta mesma superclasse sendo herdada
também pela classe “Recém-nascido”.
15
 Herança Múltipla
Dá-se o nome de herança múltipla quando uma classe herda

características de mais de uma superclasse. Como exemplo de superclasse
podemos citar a situação das classes “professor” e “aluno”. Neste exemplo é
possível acontecer de um professor ser um aluno também, e desta forma ele
teria que ter os atributos e métodos que qualificam os alunos. Mas para que
isto seja possível é preciso criar uma nova classe chamada “professor-aluno”,
que por sua vez herdaria todas as características das superclasses
“professor” e “aluno”. No entanto, não há impedimento para que esta nova
classe possua métodos e atributos próprios que a diferencie das classes pai.
Esta técnica não se aplica a linguagem Java, porém outras linguagens
baseadas na orientação ao objeto fazem uso frequente deste recurso.
Classe 1
Classe 2 Classe 3 Classe 4
Classe 5
Figura 1 - Exemplo de Herança Simples e Múltipla
No exemplo acima se pode afirmar que as classes 2, 3 e 4 configuram

herança simples, uma vez que ambas são descendentes da classe 1. Porém
a classe 5 configura herança múltipla, uma vez que é descendente das
classes 2 e 3 simultaneamente, que por sua vez são descendentes da classe
1. Assim sendo a classe 5 herdou e possui características das classes 2,3 e
1.
16
2.6 Polimorfismo
De acordo com (FERREIRA, 2012), polimorfismo significa a

propriedade de algo poder possuir várias formas diferentes. Como exemplo
pode ser citado o animal camaleão na qual muda sua cor conforme a
situação do ambiente em que está inserido.
Conforme (SIERRA, 2007), sob o olhar da orientação ao objeto, o

polimorfismo é determinado pela capacidade do método ou classe
instanciada poder ser utilizada de uma maneira diferente da qual foi
construída originalmente.
Uma das maneiras de se aplicar o polimorfismo pode ser exemplificada

em um processo de sobrecarga de métodos, na qual se pode utilizar o
método de forma a realizar diversas ações diferentes, isto de acordo com os
parâmetros de entrada recebidos em sua chamada.
(FARINELLI, 2007) define polimorfismo como a capacidade de um

método que já foi definido ser redefinido no descendente, porém com um
comportamento diferente.
Para exemplificar polimorfismo podemos citar uma classe comum

denominada “gravar”. Esta classe pode ser utilizada ao mesmo tempo tanto
por um computador quanto por um celular. Apesar da instrução “gravar” ser a
mesma para os dois equipamentos, a maneira como esta ação é realizada
nos dois equipamentos é diferente, devido as caracteristicas intrinsicas de
cada um. Ou seja, cada equipamento irá redefinir o método de acordo com
suas características próprias.
Um exemplo de aplicação do polimorfismo pode se dar a partir do

exemplo descrito nas figuras abaixo:
17
Figura 2 - Demostração de Polimorfismo
Neste exemplo da figura 2, o método “cálculo” é utilizado de maneira diferente

respectivamente pelas classes “Adição” e “Subtração”, o que demonstra o uso do
polimorfismo da classe “OperacaoAritmetica”.
Já a figura 3 a seguir demonstra o uso do polimorfismo por sobrecarga de

métodos. Neste caso o método “exibeCalculo” está sendo sobrecarregado, ou seja,
está sendo chamado de duas formas diferentes, e assim o resultado final depende
diretamente dos parâmetros passados na sua chamada.
Figura 3 - Demonstração Polimorfismo por Sobrecarga de Métodos

18
3. ORIENTAÇÃO AO OBJETO (OO) APLICADO NA LINGUAGEM JAVA
Todos os conceitos anteriores apesar de serem muito proveitosos para a

programação, não conseguem realizar uma ligação forte entre as informações e o
comportamento gerado. Para isto faz-se uso da Programação Orientada ao Objeto,
que segundo (SIERRA, 2007) consegue unir de forma harmônica estes dois
conceitos.
Assim sendo, é necessária a utilização de um paradigma de programação

orientado ao objeto, que consiga utilizar com eficiência e eficácia cada um dos
conceitos estudados anteriormente.
Para isto existem diversas linguagens diferentes entre si, tais como o C#,
Pyton, C++, Smalltalk, e o Java, na qual será o paradigma de programação a ser
aplicado neste estudo.
Conceitualmente, a programação orientada a objetos consiste na concepção

de um sistema como um todo, composto por diversos objetos que interagem entre si.
De acordo com (RICARTE, 2001), a principal vantagem desta técnica de
programação é que uma mesma metodologia pode ser utilizada tanto na definição
do sistema quanto na sua implementação, ou seja, desde o inicio o sistema já pode
ser pensado para ser produzido sob este paradigma de programação.
Assim sendo, existem no mercado diversas metodologias de modelagem de

sistemas que oferecem suporte a programação orientada a objetos, sendo que a
UML é uma das mais importantes. Porém, se esta etapa não for realizada com o
cuidado e a atenção adequada não será a aplicação do modelo de orientação a
objetos que irá garantir a qualidade do software.
Desta forma, se todas as etapas do desenvolvimento do software forem

seguidas corretamente, conforme (BAPTISTA, 2009), obtém-se as seguintes
vantagens ao utilizarmos o modelo de programação orientada a objetos:
 Aumento da produtividade através da reutilização do código;
 Maior agilidade na manutenção, através da aplicação dos conceitos de

herança;
Porém, o modelo de programação orientada ao objeto trás um inconveniente

no quesito de multidesenvolvimento do software. Isso devido ao fato de que
alterações realizadas em uma determinada classe pode impactar em efeitos
colaterais em outras classes descendentes.
19
Para exemplificar a aplicação dos conceitos de OO na linguagem Java, o

estudo fará uso de um pequeno programa que realiza cadastros e controle de
movimentação de uma pequena rede de hotéis. A tela é composta de uma classe
principal e mais três classes auxiliares, de forma que o objeto criado pela classe
principal instancia e cria outros três objetos, cada um de uma classe auxiliar.
3.1 Exemplo de aplicação dos conceitos de OO
Para exemplificar a aplicação dos conceitos de OO na linguagem Java, foi

criado um pequeno programa cuja função é a de manter cadastro para uma pequena
rede de hotéis. Neste programa existem quatro classes, sendo uma responsável
pela execução da janela principal e as outras três responsáveis cada uma por uma
função específica.
Assim sendo, a janela principal tem o papel de abrir a interface para as

seguintes funções:
 Cadastro de Hotéis
 Cadastro de Hóspedes
 Cadastro da Movimentação
 Fechamento do sistema
A seguir temos imagens das telas do programa feito para exemplo:
 Tela principal do programa de exemplo
Esta é a tela principal do programa. Através de seus botões, as classes

principais do sistema são instanciadas. Cada classe ao ser executada abre outra
tela responsável por uma tarefa específica, tais como cadastrar hotéis, cadastrar
hóspedes, cadastrar a movimentação de clientes. Além da chamada destas
classes esta tela possui o último botão responsável pela saída e fechamento do
sistema.
A figura 4 a seguir demostra a tela principal do programa de exemplo.

20
Figura 4 - Tela Principal do Programa de Exemplo
 Tela de cadastro das filiais
Esta tela é responsável pelo cadastro das filiais da rede de hotéis. Nela
podemos encontrar alguns componentes herdados da classe Java “JFrame”, tais
como botões, labels, textfields e choice. Através desta tela o usuário pode realizar
funções básicas como inclusão de novos hotéis, exclusão de determinado hotel e a
alteração dos dados cadastrados. Além destas funções a tela conta com um botão
“sair” responsável pelo fechamento da tela.
A figura 5 a seguir mostra imagem da tela de cadastro de filiais.

21
Figura 5 - Tela de Cadastro das Filiais
 Tela de cadastro de Hóspedes
Esta tela permite ao usuário cadastrar novos hóspedes na qual se hospedarão

nos hotéis da rede. Assim como a anterior esta tela também conta com elementos
da classe java “JFrame”, como botões, labels, textfields e choice. Seu layout segue o
padrão da tela anterior, assim sendo, também conta com botões reservados para a
alteração, exclusão e inclusão de hóspedes.
Na figura 6 tem-se a imagem da tela de cadastro de hóspedes.

22
Figura 6 - Tela de Cadastro de Hóspedes
 Tela de registro da movimentação
Esta tela do sistema utilizado para exemplo possui a função de cadastro da

movimentação de hóspedes no hotel. Através dela o usuário registra informações do
hóspede, da unidade, datas de entrada e saída além do valor cobrado pela diária.
Seguindo o padrão de tela utilizado pelas demais telas, também herda a classe java
“JFrame”, utilizando os elementos button, label, textfield e choice. Ainda seguindo
este padrão a tela conta com as funcionalidades de inclusão, exclusão e alteração
de registro de movimentação de hóspedes, além do botão “sair” responsável pelo
fechamento da tela.
23
A figura 7 apresenta a imagem da tela de cadastro da movimentação de

hóspedes.
Figura 7 - Tela de Cadastro do Movimento de Hóspedes
No anexo 1 pode ser visualizado todo o código das classes utilizadas, porém
para efeito de demonstração dos conceitos de OO podemos retirar os seguintes
fragmentos do código.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
Neste trecho do código ocorre a descrição das classes Java a serem

importadas, ou seja, quais classes estarão disponíveis para utilização no programa.
24
public class Exercicio06 extends JFrame implements ActionListener

{
JButton B1, B2, B3, B4;
JLabel L1;
A chamada “extends JFrame” caracteriza herança simples da classe JFrame,

implementando a interface ActionListener. Como a classe exercicio herda as
características de JFrame, a própria classe é um painel.
public Exercicio06()
{
setTitle("MENU");
setSize(400,400);
setLocation(50,50);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Neste trecho do código temos a criação do método construtor da classe. Por

definição ele possui o mesmo nome da classe podendo ser chamado no momento
da criação da instância, com o intuito de reservar recursos necessários para a
operação do objeto criado.
B4.setFont(new Font("Arial", Font.BOLD, 22));

B4.setBackground(new Color(130,155,255));
getContentPane().setLayout(null);
getContentPane().add(L1);
getContentPane().add(B1);
}
Aqui é o momento na qual ocorre a criação do formulário, adicionando os

botões ao painel.
public static void main (String arg[])

{
new Exercicio06().show();
}
A chamada “new Exercicio06().show();” tem a função de criar a instância

objeto da classe “Exercicio06”. Neste momento o método show é invocado.
25
public void actionPerformed(ActionEvent e)

{
if (e.getSource() == B4)
Neste ponto é criado o método que verifica o clique dos botões. Sua função é
a de verificar qual botão foi pressionado.
else
{
obj.show();
}
else
{
Exercicio06b obj = new Exercicio06b();
obj.show();
}
else
{
Exercicio06c obj = new Exercicio06c();
obj.show();
}
Finalmente neste trecho temos o momento na qual são criados os objetos

correspondentes de cada classe auxiliar. A cada botão pressionado é criada uma
instância do objeto correspondente, de forma que cada uma destas instâncias
representa um encapsulamento próprio, ou seja, o código da classe instanciada esta
encapsulado no objeto criado. A cada novo objeto criado teremos um novo
encapsulamento.
No programa em estudo não foi utilizado o conceito de polimorfismo, porém

poderíamos exemplifica-lo realizando a seguinte alteração no código da classe
Exercicio06a, demonstrada no anexo 2:
try
{
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
connection = DriverManager.getConnection ( "jdbc:odbc:hotel", "", "");
JOptionPane.showMessageDialog(null, "conexão com sucesso");
JOptionPane.showMessageDialog(null, "conexão com sucesso", 1, 0);
Neste caso o mesmo método JOptionPane pode ser chamado (executado) de

duas formas diferentes, ou seja, sua forma de execução será determinada pela
maneira na qual os parâmetros de entrada foram informados.
26
Finalmente, a propriedade de “abstração” pode ser demonstrada quando a

partir da aplicação de um código escrito em Java, conseguimos criar um objeto que
consegue solucionar um problema da vida real. No caso do estudo em questão a
abstração da situação problema é feita através das classes relacionadas no projeto.
3.2 Utilização do Java como modelo de linguagem de programação
O Java é uma linguagem de programação criada pela Sun Microsystem em

meados dos anos 90, na qual deste o início foi projetada para ser multiplataforma e
baseada nos conceitos da programação orientada ao objeto. Seu modo de
concepção foi baseado na linguagem C++, porém a plataforma Java já foi pensada
tanto para construção de softwares aplicativos, quanto para a construção de applets
para ambientes Web.
Para que um ambiente com aplicativos em java opere, segundo (COSTA,

2009) é necessário a seguinte configuração descrita na figura 8:
Figura 8 - Configuração Básica Java (COSTA, 2009)
Esta configuração é permitida através da instalação do Java Development Kit

(JDK), que nada mais é do que um ambiente preparado para o desenvolvimento de
aplicações ou applets, já com as ferramentas de desenvolvimento e os elementos
básicos da plataforma preparados.
De acordo com (SIERRA, 2007), a utilização dos conceitos de orientação ao

objeto, tais como instância, herança, encapsulamento e modularização fizeram a
linguagem Java ser considerada bastante confiável e alta qualidade, com isto pode-
se afirmar que o Java é uma linguagem robusta.
27
3.3 Java EE
O Java EE consiste na plataforma de desenvolvimento utilizada na linguagem

de programaçãoJava. Segundo (MORAES, 2010), ela que suporta o
desenvolvimento da aplicação realizada neste paradigma de programação,
consistindo em um robusto conjunto de serviços middleware com a função de
facilitar o desenvolvimento de aplicações.
Ainda conforme (MORAES, 2010), seu uso pode garantir muitas vantagens ao
projeto, tais como inexistência de software cliente para instalar, acesso
universalmente fácil além de abordagem comum para a interface com o usuário.
Uma aplicação construída com o Java EE possui vários componentes

intercomunicáveis, sendo que cada um possui sua função específica no projeto. A
figura 9 a seguir demonstra um exemplo de utilização destes componentes,
descritos em camadas.
Figura 9 - Exemplo de Aplicação Construída com Java EE (MORAES, 2010)
Segundo o autor, este modelo em camadas é aplicado para que possa ser
utilizado o padrão MVC (Model View Controller). Com isto pode-se dividir
responsabilidades e diminuir a complexidade em aplicações Web. Além disto, o
MVC permite separar interface, regra de negócio e o controle do fluxo, de forma que
cada um destes realizará suas tarefas separadamente.
28
Assim sendo, conforme (MORAES, 2010) o Java EE consiste em um conjunto

de especificações, na qual o projeto é submetido, sendo bastante aplicado no
desenvolvimento de softwares para o ambiente corporativo. Desta maneira o projeto
desenvolvido sob este padrão classifica-se como compatível com Java EE.
3.4 Java Virtual Machine (JVM)
Conforme (COSTA, 2009), o Java Virtual Machine (JVM) consiste em uma

máquina virtual, na qual compila as classes fonte em Java executando-as no usuário
final. Com isto é possível que a mesma classe possa ser executada nas arquiteturas
mais diversas, bastando somente termos a versão de JVM compatível ao sistema
hospedeiro.
Sua distribuição é feita através do Java Runtime Envoirment (JRE), onde além
do JVM é fornecido um conjunto de bibliotecas padrão para implementação da
interface java (API). (Oracle, 2012)
Conforme (CAELUM, 2012), as funções básicas da JVM são as seguintes:
 Transportar seguramente as classes de objetos, protegendo assim o

sistema contra invasões externas;
 Fazer a verificação das classes recebidas (bytecodes) verificando se as

mesmas estão aderentes às especificações da JVM;
 Realizar o processo de interpretação do código para a plataforma a ser

utilizada.
O funcionamento da JVM pode ser resumida da seguinte maneira:
Quando um programa é feito em Java, no momento em que é compilado são

criados os Bytecodes na qual serão interpretados pela JVM. Estes Bytecodes são os
mesmos independentemente do sistema operacional na qual o mesmo será
executado. Caberá então a JVM interpretá-lo de forma na qual o sistema operacional
hospedeiro possa executá-lo. Em termos de programação java estes Bytecodes
consistem nos arquivos .class criados durante a programação java.
As figuras 10 e 11 a seguir demonstram o funcionamento da JVM.

29
Figura 10 - Exemplo de funcionamento da JVM (COSTA, 2009)
Figura 11 - Funcionamento da JVM nos diversos ambientes (COSTA, 2009)
Conforme (BAPTISTA, 2009), a JVM consiste em uma máquina de pilha que

trabalha de forma a utilizar esta estrutura para armazenar de forma temporária os
resultados intermediários. Assim sendo pode-se definir um simples conjunto de
instruções fácil de ser interpretado em várias arquiteturas.
30
Ainda segundo (BAPTISTA, 2009), a JVM contém um coletor de “lixo”

(garbage collector) automático, com o fim de otimizar o uso da memória de
aplicações java. Sua execução é realizada de forma automática e transparente para
o programador. Seu funcionamento se resume na retirada de objetos da memória
quando não existir mais referencias para o mesmo. Porém a forma como tal tarefa
será feita dependerá do algoritmo implementado na JVM.
Os problemas com relação a utilização de memória em aplicações Java

podem aparecer quando o objeto possui muitas variáveis de instancias iniciadas no
método construtor e pouco utilizadas pelo resto do código. Desta forma segundo o
autor uma boa atuação deste coletor poderá ser fundamental para a performance da
aplicação Java.
31
4. CONCLUSÃO
A linguagem de programação Java fundamentada nos conceitos de

orientação ao objeto causou uma grande revolução nos hábitos dos programadores
e analistas em todo o mundo. Antes dela, os softwares eram produzidos únicamente
para determinada plataforma, entretanto o Java possibilitou desenvolver softwares
portáveis na medida em que se adaptavam à plataforma na qual estivessem
instalados, graças a aplicação do Java Virtual Machine (JVM). Com isto permitiu-se
ter a mesma versão de software instalado tanto em um equipamento portátil, em um
PC ou em um robusto servidor.
Além desta contribuição, deve-se que considerar o fato de a ferramenta ser

totalmente freeware, o que facilita sua aplicação tanto no campo corporativo quanto
em dispositivos eletrônicos em geral, ao passo que reduz o custo dos mesmos. Já
pensando em termos de softwares aplicativos, a linguagem Java como ferramenta
de desenvolvimento torna-se uma opção a mais para o desenvolvedor, uma vez que
além do fator custo, sua aplicação pode ser justificada pelo fato de que o Java sendo
desenvolvido sobre os princípios da orientação a objetos pode garantir um ganho de
produtividade em relação a técnicas de programação estruturada tradicionais,
principalmente pelo fato de seu código ser amplamente reutilizável. Isto também
pode contribuir para que haja uma redução nos custos de manutenção futuros.
É claro que no mercado temos diversas alternativas ao Java, algumas até

mais robustas, mas não se pode desconsiderar o custo destas soluções, na qual
impacta diretamente no custo final do projeto. Assim sendo, pensando em termos de
um mercado consumidor cada vez mais competitivo e exigente, o uso de uma
ferramenta freeware deve ser sempre levada em consideração.
Desta maneira, pode-se concluir que o Java como linguagem de programação

associada ao uso dos conceitos de orientação ao objeto torna-se uma alternativa a
mais aos desenvolvedores de software, podendo lhes proporcionar resultados
satisfatórios, e de grande contribuição tanto para a comunidade da computação,
quanto para a população em geral, que consegue desta forma usufruir de todos os
benefícios de utilizar um software construído com uma das tecnologias de
desenvolvimento mais atuais.
32
BIBLIOGRAFIA
BAPTISTA, L. (11 de 04 de 2009). Acesso em 30 de 09 de 2012, disponível em
WorldPress: http://adscesumar2008.files.wordpress.com/2009/04/java-virtual-
machine.pdf
CAELUM. (20 de 09 de 2012). Caelum Ensino e Educação. Acesso em 20 de 09 de

2012, disponível em Caelum Ensino e Educação:
http://www.caelum.com.br/download/caelum-java-objetos-fj11.pdf
CARMO, D. D. (21 de 09 de 2012). Softech Network. Acesso em 21 de 09 de 2012,

disponível em Softech Network:
http://www.softechnetwork.com.br/java/CursoOO.pdf
CASTRO, M. (20 de 09 de 2012). Solis/Univates. Acesso em 20 de 09 de 2012,

disponível em Solis/Univates:
http://www.jack.eti.br/www/arquivos/apostilas/java/logicapoo.pdf
COSTA, I. (02 de 2009). Apostila Java Básica. Apostila Java Básica. São Paulo, São
Paulo, Brasil.
DALL'OGLIO, P. (18 de 09 de 2012). Novatec Editora. Acesso em 18 de 09 de 2012,

disponível em www.novatec.com.br:
http://www.novateceditora.com.br/livros/phpobj/capitulo9788575221372.pdf
DEITEL, H. M. (2003). Java, como programar. Porto Alegre: Bookman.
FARINELLI, F. (26 de 05 de 2007). Instituto Federal de educação ciência e

tecnologia. Acesso em 10 de 09 de 2012, disponível em Instituto Federal de
educação ciência e tecnologia:
http://www.riopomba.ifsudestemg.edu.br/dcc/dcc/materiais/1662272077_POO
.pdf
FERREIRA, A. B. (2012). Dicionário Aurélio. Rio de Janeiro: Editora Nova Fronteira.
MORAES, M. G. (2010). Proposta de um Protótipo em JavaEE para Controle de RH.

Acesso em 30 de 09 de 2012, disponível em UniRitter:
http://www.uniritter.edu.br/graduacao/informatica/sistemas/downloads/tcc2k10
/maquelin_2010_2.pdf
Oracle. (2012). Oracle. Acesso em 30 de 09 de 2012, disponível em Oracle:

www.oracle.com
RICARTE, I. L. (26 de 06 de 2001). Departament of computer engennering and

Industrial Automation. Acesso em 10 de 09 de 2012, disponível em Unicamp:
http://www.dca.fee.unicamp.br/cursos/PooJava/Aulas/poojava.pdf
SIERRA, K. (2007). Use a cabeça Java. São Paulo: Alta Books.

33
ANEXOS
Códigos das classes utilizadas no software de exemplo de utilização da OO

em Java.
Anexo 1 – Classe principal

package exercicios;
//Classe: Exercicio06.java
//EXERCICIO PARA CADASTRO DE HOTEIS
//Data: Setembro/2012
import java.awt.*;
public class Exercicio06 extends JFrame implements ActionListener

{
JButton B1, B2, B3, B4;
JLabel L1;
public Exercicio06()
{
setTitle("MENU");
setSize(400,400);
setLocation(50,50);
L1 = new JLabel("HOTÉIS HILTON BRASIL");

L1.setLocation(70,20);
L1.setSize(490,25);
L1.setFont(new Font("Arial", Font.BOLD, 22));
B1 = new JButton("Cadastro de Hotéis");

B1.setSize(285,50);
B1.setLocation(50,60);
B1.addActionListener(this);
B2 = new JButton("Cadastro de Hóspedes");

B2.setSize(285,50);
B3 = new JButton("Cadastro da Movimentação");

B3.setSize(285,50);
B4 = new JButton("Sair");
34
B4.setSize(285,50);
}

{
new Exercicio06().show();
}

{
System.exit(0);
else
{
obj.show();
}
else
{
Exercicio06b obj = new Exercicio06b();
obj.show();
}
else
{
Exercicio06c obj = new Exercicio06c();
obj.show();
}
}
35
Anexo 2 – Classe de cadastro de hotéis
package exercicios;
//Classe: Exercicio06a.java
//Manipulação dos Dados dos Hotéis
import javax.swing.event.*;
import java.awt.*;
import java.sql.*;
import java.util.*;
import javax.swing.JOptionPane;
import java.sql.*;
import java.util.*;
public class Exercicio06a extends JFrame implements ActionListener,

ListSelectionListener, ItemListener
{
private static Connection connection;
JButton B1, B2, B22, B3, B4;
JTextField END, NOME, GER, EMP, ID;
JLabel L1, L2, L3, L4, L5,L6, L7;
Choice ANO, MES, DIA;
public Exercicio06a()
{
setTitle("HOTÉIS");
setSize(500,500);
setLocation(80,50);
L1 = new JLabel("CADASTRO DAS FILIAIS");

L1.setSize(490,30);
L2 = new JLabel("Nome da Filial:");

L2.setSize(100,20);
NOME = new JTextField("");

NOME.setSize(300,25);
NOME.setLocation(130,70);
L3 = new JLabel("Endereço:");
L3.setSize(100,20);
END = new JTextField("");

END.setSize(300,25);
END.setLocation(130,120);
L4 = new JLabel("Gerente:");
L4.setSize(100,20);
36
GER = new JTextField("");

GER.setSize(300,25);
GER.setLocation(130,170);
L5 = new JLabel("Inauguração (Dia/Mes/Ano):");

L5.setSize(170,20);
DIA = new Choice();

DIA.setLocation(200,220);
DIA.setSize(40,25);
DIA.addItem("01");DIA.addItem("02");DIA.addItem("03");DIA.addItem("04");
DIA.addItem("29");DIA.addItem("30");DIA.addItem("31");
MES = new Choice();

MES.setLocation(250,220);
MES.setSize(40,25);
MES.addItem("01");MES.addItem("02");MES.addItem("03");MES.addItem("04");
ANO = new Choice();

ANO.setLocation(300,220);
ANO.setSize(70,25);
ANO.addItem("1970");ANO.addItem("1971");ANO.addItem("1972");ANO.addItem("19
74");
78");
82");
86");
90");
94");
98");
02");
06");
10");
14");
18");
22");
26");
30");
37
34");
38");
42");
46");
50");
54");
L6 = new JLabel("Nr. Empregados:");

L6.setSize(100,20);
EMP = new JTextField("");

EMP.setSize(50,25);
EMP.setLocation(130,270);
L7 = new JLabel("Id Hotel:");

L7.setSize(100,20);
ID = new JTextField("");
ID.setSize(50,25);
ID.setLocation(130,320);
B1 = new JButton("Incluir");
B1.setSize(90,40);
B2 = new JButton("Excluir");
B2.setSize(90,40);
B2.setVisible(true);
B22 = new JButton("Excluir!!");

B22.setSize(90,40);
B22.setBackground(Color.yellow);
B22.setVisible(false);
B3 = new JButton("Alterar");
B3.setSize(90,40);
38
B4.setSize(90,40);
B4.setBackground(Color.white);
getContentPane().add(L1);getContentPane().add(L2);getContentPane().add(L3);
getContentPane().add(END);getContentPane().add(NOME);getContentPane().add(I
D);
getContentPane().add(GER);getContentPane().add(EMP);
getContentPane().add(DIA);getContentPane().add(MES);getContentPane().add(AN
O);
getContentPane().add(B1);getContentPane().add(B2);getContentPane().add(B22)
;
getContentPane().add(B3);getContentPane().add(B4);
public static void FazConexao()

{
System.out.println("Vai fazer a conexão");
try
{
connection = DriverManager.getConnection (
"jdbc:odbc:hotel", "", "");
System.out.println("conexão com sucesso");
}
catch ( ClassNotFoundException cnfex )
{
System.err.println("FALHA NA CONEXÃO DO BANCO DE DADOS" );
cnfex.printStackTrace();
System.exit( 1 );
}
catch ( SQLException sqlex )
{
System.err.println( "BANCO DE DADOS NÃO DISPONIVEL" );
sqlex.printStackTrace( );
}
}

{
Connection con = connection;
dispose();
else
if(e.getSource() == B1)
39
{
try
{
Statement st = con.createStatement();
st.executeUpdate("INSERT INTO HOTEL VALUES
('"+ID.getText()+"','"+ NOME.getText()+"', '"+ END.getText()+"', '"+
GER.getText()+"', '"+ ANO.getSelectedItem()+"-"+ MES.getSelectedItem()+"-"+
DIA.getSelectedItem()+"', '"+ EMP.getText()+"');");
NOME.setText("");
END.setText("");
GER.setText("");
EMP.setText("");
ID.setText("");
}
catch (SQLException sqlex)

{
System.out.println("erro sql "+ sqlex);
sqlex.printStackTrace();
}
}
else
{
try
{
String sid = ID.getText();
int idi = Integer.parseInt(sid);
String prec;
ResultSet res = st.executeQuery("SELECT * FROM HOTEL
WHERE Id_hotel = "+ idi);
if(res.next())
{
NOME.setText(res.getString("Nome"));
END.setText(res.getString("End"));
GER.setText(res.getString("Ger"));
EMP.setText(res.getString("Nr_emp"));
}
}
{
}
}
else
{
try
{
st.executeUpdate("DELETE FROM HOTEL WHERE Id_hotel =
"+ idi);
NOME.setText("");
END.setText("");
GER.setText("");
40
EMP.setText("");
ID.setText("");
}
{
}
}
else
try
{
st.executeUpdate("UPDATE HOTEL SET
Id_hotel='"+ID.getText()+"', Nome='"+ NOME.getText()+"', End='"+
END.getText()+"', Ger='"+ GER.getText()+"', Dt_inaug='"+
ANO.getSelectedItem()+"-"+ MES.getSelectedItem()+"-"+
DIA.getSelectedItem()+"', Nr_emp= '"+ EMP.getText()+"' WHERE
Id_hotel="+idi);
NOME.setText("");
END.setText("");
GER.setText("");
EMP.setText("");
ID.setText("");
}

{
}
}

{
FazConexao();
new Exercicio06a().show();
}
}
41
Anexo 3 – Classe para cadastro de hóspedes
package exercicios;
//Classe: Exercicio06b.java
//Manipulação dos Dados dos Hóspedes
import java.awt.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Exercicio06b extends JFrame implements ActionListener,

{
private static Connection connection;
JTextField END, NOME, RG, CPF, TEL, PROF;
JLabel L1, L2, L3, L4, L5, L6, L7, L8, L9, L10;
Choice ANO, MES, DIA, SEXO, EST_CIVIL;
public Exercicio06b()
{
setTitle("HÓSPEDES");
setSize(500,600);
setLocation(80,50);
L1 = new JLabel("CADASTRO DOS HÓSPEDES");

L1.setSize(490,30);
L2 = new JLabel("Nome: ");

L2.setSize(100,20);

L3 = new JLabel("Endereço:");
L3.setSize(100,20);
END = new JTextField("");

END.setSize(300,25);
END.setLocation(130,120);
L4 = new JLabel("RG:");
42
L4.setSize(100,20);
RG = new JTextField("");
RG.setSize(300,25);
RG.setLocation(130,170);
L5 = new JLabel("CPF:");
L5.setSize(100,20);
CPF = new JTextField("");

CPF.setSize(300,25);
CPF.setLocation(130,220);
L6 = new JLabel("Data de Nasc. (Dia/Mes/Ano):");

L6.setSize(170,20);
DIA = new Choice();

DIA.setSize(40,25);
MES = new Choice();

MES.setSize(40,25);
ANO = new Choice();

ANO.setSize(70,25);
74");
78");
82");
86");
90");
94");
98");
43
02");
06");
10");
14");
18");
22");
26");
30");
34");
38");
42");
46");
50");
54");
L7 = new JLabel("Nr. Telefone:");

L7.setSize(100,20);
TEL = new JTextField("");

TEL.setSize(130,25);
TEL.setLocation(130,320);
L8 = new JLabel("Profissão:");
L8.setSize(100,20);
PROF = new JTextField("");

PROF.setSize(250,25);
PROF.setLocation(130,370);
L9 = new JLabel("Sexo: ");

44
L9.setSize(50,20);
SEXO = new Choice();

SEXO.setLocation(100,420);
SEXO.setSize(100,25);
SEXO.addItem("Masculino");SEXO.addItem("Feminino");SEXO.addItem("Gay");
L10 = new JLabel("Estado Civil:");

L10.setSize(80,20);
EST_CIVIL = new Choice();

EST_CIVIL.setLocation(335,420);
EST_CIVIL.setSize(100,25);
EST_CIVIL.addItem("Solteiro");EST_CIVIL.addItem("Casado");EST_CIVIL.addItem
("Viuvo");
EST_CIVIL.addItem("Enrolado");
B1.setSize(90,40);
B2.setSize(90,40);

B22.setSize(90,40);
B3.setSize(90,40);
B4.setSize(90,40);
45
getContentPane().add(END);getContentPane().add(NOME);getContentPane().add(P
ROF);
getContentPane().add(RG);getContentPane().add(CPF);getContentPane().add(TEL
);
O);
getContentPane().add(SEXO);getContentPane().add(EST_CIVIL);
;
}
public static void FazConexao()
{
System.out.println("Vai fazer a conexão");
try
{
connection = DriverManager.getConnection (
"jdbc:odbc:hotel", "", "");
System.out.println("conexão com sucesso");
}
catch ( ClassNotFoundException cnfex )
{
System.err.println("FALHA NA CONEXÃO DO BANCO DE DADOS" );
cnfex.printStackTrace();
System.exit( 1 );
}
catch ( SQLException sqlex )
{
System.err.println( "BANCO DE DADOS NÃO DISPONIVEL" );
sqlex.printStackTrace( );
}
}

{
Connection con = connection;
dispose();
else
{
46
try
{
st.executeUpdate("INSERT INTO HOSPEDE VALUES
('"+NOME.getText()+"','"+ END.getText()+"', '"+ RG.getText()+"', '"+
CPF.getText()+"', '"+ ANO.getSelectedItem()+"-"+ MES.getSelectedItem()+"-"+
DIA.getSelectedItem()+"', '"+ TEL.getText()+"','"+ PROF.getText()+"','"+
SEXO.getSelectedItem()+"','"+EST_CIVIL.getSelectedItem()+"');");
NOME.setText("");
END.setText("");
RG.setText("");
CPF.setText("");
TEL.setText("");
PROF.setText("");

{
}
}
else
{
try
{
String sid = CPF.getText();
String prec;
ResultSet res = st.executeQuery("SELECT * FROM HOSPEDE
WHERE Cpf = "+ idi);
if(res.next())
{
NOME.setText(res.getString("Nome"));
END.setText(res.getString("End"));
RG.setText(res.getString("Rg"));
TEL.setText(res.getString("Fone"));
PROF.setText(res.getString("Profissao"));
}
}
{
}
}
else
{
try
{
st.executeUpdate("DELETE FROM HOSPEDE WHERE CPF = "+
idi);
47
NOME.setText("");
END.setText("");
RG.setText("");
CPF.setText("");
TEL.setText("");
PROF.setText("");
}
{
}
}
else
try
{
st.executeUpdate("UPDATE HOSPEDE SET
Nome='"+NOME.getText()+"', End='"+ END.getText()+"', Rg='"+
RG.getText()+"', Cpf='"+ CPF.getText()+"', Dt_nasc='"+
ANO.getSelectedItem()+"-"+ MES.getSelectedItem()+"-"+
DIA.getSelectedItem()+"', Fone= '"+ TEL.getText()+"',
Profissao='"+PROF.getText()+"', Sexo='"+SEXO.getSelectedItem()+"',
Est_civil='"+EST_CIVIL.getSelectedItem()+"' WHERE Cpf="+idi);
NOME.setText("");
END.setText("");
RG.setText("");
CPF.setText("");
TEL.setText("");
PROF.setText("");
}

{
}
}

{
FazConexao();
new Exercicio06b().show();
}
}
48
Anexo 4 – Classe para cadastro e controle da movimentação

package exercicios;
//Classe: Exercicio06c.java
//Movimentacao de Hospedes
//Data: Novembro/2009
import java.awt.*;
public class Exercicio06c extends JFrame implements ActionListener,

{
JTextField CPF, NOME, DIARIA;
JLabel L1, L2, L3, L4, L5, L6;
Choice ANO, MES, DIA, ANO1, MES1, DIA1;
public Exercicio06c()
{
setTitle("MOVIMENTAÇÃO");
setSize(500,500);
setLocation(80,50);
L1 = new JLabel("MOVIMENTAÇÃO DE HÓSPEDES");

L1.setSize(490,30);
L2 = new JLabel("Nome do Hotel:");

L2.setSize(100,20);

L3 = new JLabel("CPF Hóspede:");

L3.setSize(100,20);
CPF = new JTextField("");

CPF.setSize(300,25);
CPF.setLocation(130,120);
L4 = new JLabel("Dt. Entrada: (Dia/Mes/Ano):");

L4.setSize(170,20);
DIA = new Choice();

DIA.setSize(40,25);
49
MES = new Choice();

MES.setSize(40,25);
ANO = new Choice();

ANO.setSize(70,25);
74");
78");
82");
86");
90");
94");
98");
02");
06");
10");
14");
18");
22");
26");
30");
50
34");
38");
42");
46");
50");
54");
L5 = new JLabel("Dt. Saída: (Dia/Mes/Ano):");

L5.setSize(170,20);
DIA1 = new Choice();

DIA1.setLocation(200,220);
DIA1.setSize(40,25);
DIA1.addItem("01");DIA1.addItem("02");DIA1.addItem("03");DIA1.addItem("04")
;
;
;
;
;
;
;
DIA1.addItem("29");DIA1.addItem("30");DIA1.addItem("31");
MES1 = new Choice();

MES1.setLocation(250,220);
MES1.setSize(40,25);
MES1.addItem("01");MES1.addItem("02");MES1.addItem("03");MES1.addItem("04")
;
;
;
51
ANO1 = new Choice();

ANO1.setLocation(300,220);
ANO1.setSize(70,25);
ANO1.addItem("1970");ANO1.addItem("1971");ANO1.addItem("1972");ANO1.addItem
("1974");
("1978");
("1982");
("1986");
("1990");
("1994");
("1998");
("2002");
("2006");
("2010");
("2014");
("2018");
("2022");
("2026");
("2030");
("2034");
("2038");
("2042");
("2046");
52
("2050");
("2054");
L6 = new JLabel("Valor da Diária:");

L6.setSize(100,20);
DIARIA = new JTextField("");

DIARIA.setSize(70,25);
DIARIA.setLocation(130,270);
B1.setSize(90,40);
B2.setSize(90,40);

B22.setSize(90,40);
B3.setSize(90,40);
B4.setSize(90,40);
53
getContentPane().add(CPF);getContentPane().add(NOME);
getContentPane().add(DIARIA);
O);
getContentPane().add(DIA1);getContentPane().add(MES1);getContentPane().add(
ANO1);
;
}
{
new Exercicio06c().show();
}

{
dispose();
}
}
54

Trabalho Tutela Java Jailton

Enviado por

Dados do documento

Descrição:

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?

Descrição:

Direitos autorais:

Formatos disponíveis

Trabalho Tutela Java Jailton

Enviado por

Descrição:

Direitos autorais:

Formatos disponíveis

JAILTON DE ARAUJO SANTOS

CONCEITOS DE ORIENTAÇÃO AO OBJETO E EXEMPLO DE

CONCEITOS DE ORIENTAÇÃO AO OBJETO E EXEMPLO DE

Palavras-Chave: Orientação ao Objeto, Java, software

Figura 1 - Exemplo de Herança Simples e Múltipla .............................................................. 15

Figura 2 - Demostração de Polimorfismo ............................................................................. 17

Figura 3 - Demonstração Polimorfismo por Sobrecarga de Métodos ................................... 17

Figura 4 - Tela Principal do Programa de Exemplo .............................................................. 20

Figura 5 - Tela de Cadastro das Filiais ................................................................................ 21

Figura 6 - Tela de Cadastro de Hóspedes ........................................................................... 22

Figura 7 - Tela de Cadastro do Movimento de Hóspedes .................................................... 23

Figura 8 - Configuração Básica Java ................................................................................... 26

Figura 9 - Exemplo de Aplicação Construída com Java EE ................................................. 27

Figura 10 - Exemplo de funcionamento da JVM................................................................... 29

Figura 11 - Funcionamento da JVM nos diversos ambientes ............................................... 29

1. DEFINIÇÃO DE PROGRAMAÇÃO ORIENTADA AO OBJETO (POO) .............................. 8

2. CONCEITOS BÁSICOS DA ORIENTAÇÃO AO OBJETO .................................................... 9

2.2 Objetos ................................................................................................................................. 11

2.3 Abstração ............................................................................................................................. 12

2.4 Encapsulamento ................................................................................................................. 13

2.5 Herança ................................................................................................................................ 14

2.6 Polimorfismo ........................................................................................................................ 16

3. ORIENTAÇÃO AO OBJETO (OO) APLICADO NA LINGUAGEM JAVA........................... 18

3.1 Exemplo de aplicação dos conceitos de OO ................................................................. 19

3.2 Utilização do Java como modelo de linguagem de programação .............................. 26

3.3 Java EE ................................................................................................................................ 27

3.4 Java Virtual Machine (JVM) .............................................................................................. 28

As linguagens de programação desde a criação dos computadores passam

Apesar de esta máquina ser um marco para a época, as necessidades

Desta forma então surge à ideia de ter-se um código escrito de maneira a

A programação orientada ao objeto (POO) aproveitou todas boas ideias da

A partir daí diversas linguagens de programação sob este paradigma foram

Para apoiar então este novo paradigma de programação, surge em meados

Percebendo-se então este cenário favorável ao desenvolvimento de softwares

1. DEFINIÇÃO DE PROGRAMAÇÃO ORIENTADA AO OBJETO

A Programação Orientada ao Objeto consiste em uma técnica que visualiza

O paradigma a ser solucionado com a Programação Orientada ao Objeto é o

Em termos de programação então podem-se aplicar estes mesmos conceitos,

Segundo (FARINELLI, 2007), pode-se definir a orientação ao objeto como

2. CONCEITOS BÁSICOS DA ORIENTAÇÃO AO OBJETO

A programação orientada ao objeto baseia-se principalmente nos conceitos

Resumidamente então, a OO consiste no conceito do envio de mensagens a

Segue abaixo a descrição da estrutura dos objetos e das classes utilizadas

Conforme (RICARTE, 2001) classe é um conjunto de métodos e atributos,

Apesar de o nome desta técnica de programação remeter a Programação

No exemplo citado anteriormente utilizando o objeto “carro”, pode-se possuir a

De acordo com (DALL'OGLIO, 2012), a principal diferença entre objetos e

Porém pode ocorrer de diversas classes também possuírem características

Esta hierarquia de classes também gera o que se chama de classes

Segundo (RICARTE, 2001), as classes realizam a descrição de como os

Seguindo os conceitos do modelo de orientação ao objeto, surgem os

 Instancia: É quando a classe gera um objeto, de forma a ser alocado

Exercicio06a obj = new Exercicio06a();

Desmembrando esta linha de código, pode-se analisar a função de

Exercicio06a  este comando indica qual classe será instanciada.

Obj  neste comando temos a indicação da criação do objeto.

new Exercicio06a();  neste comando há a indicação do método

 Classe Abstrata (pura): É o tipo de classe na qual seus objetos nunca

Conforme (FARINELLI, 2007) o objetivo deste modo de

Os objetos consistem na representação dos elementos da vida real. Porém

Ainda segundo (RICARTE, 2001), os objetos podem ser definidos como