Informatica Programacao Orientada A Objetos Java 2019

Escola Estadual de Educação Profissional [EEEP] Ensino Médio Integrado à Educação Profissional
Disciplina:
Programação Orientada a Objetos / Java
=====================================================================
Apostila destinada ao Curso Técnico de Nível Médio em Informática das Escolas Estaduais de
Educação Profissional – EEEP
Equipe de Elaboração - 2012

Adriano Gomes da Silva
Cíntia Reis de Oliveira
Evandilce do Carmo Pereira
Fernanda Vieira Ribeiro
Francisco Aislan da Silva Freitas
João Paulo de Oliveira Lima
Juliana Maria Jales Barbosa
Liane Coe Girão Cartaxo
Mirna Geyla Lopes Brandão
Moribe Gomes de Alcântara
Niltemberg Oliveira Carvalho
Paulo Ricardo do Nascimento Lima
Renanh Gonçalves de Araújo
Renato William Rodrigues de Souza
Valbert Oliveira Costa
Colaboradores
Maria Analice de Araújo Albuquerque
Maria Danielle Araújo Mota
Sara Maria Rodrigues Ferreira Feitosa
Atualização – 2018
Paulo Ricardo do Nascimento Lima
=====================================================================
Informática – Programação Orientada a Objetos / Java
1
SUMÁRIO
APRESENTAÇÃO ....................................................................................................................................... 5
1.0 Introdução a Sistemas ........................................................................................................................ 6
1.1 Modelagem de Sistemas ..................................................................................................................... 7
1.2 Dado, Conhecimento e Informação. .................................................................................................... 8
1.3 O que é um sistema .............................................................................................................................. 9
1.4 Como construir um Sistema de informação baseado em computador ................................................. 11
1.5 O papel do Analista de Sistemas......................................................................................................... 12
1.6 Fases do desenvolvimento de sistemas ............................................................................................. 13
2.0 Requisitos.............................................................................................................................................. 17
2.1 Análise de Requisitos ........................................................................................................................ 19
2.1.1 Requisitos Funcionais ................................................................................................................ 19
2.1.2 Requisitos não Funcionais ......................................................................................................... 19
2.1.3 Requisitos do usuário ................................................................................................................. 19
2.1.4 Requisitos do sistema ................................................................................................................. 20
2.1.5 Especificação de Software ......................................................................................................... 20
3.0 História e evolução da UML .................................................................................................................. 21
3.1 Diagramas Estruturais da UML ....................................................................................................... 23
3.1.1 Diagrama de Classe.................................................................................................................... 23
3.1.2 Diagrama de Objeto ................................................................................................................... 24
3.1.3 Diagrama de Componentes ........................................................................................................ 25
3.1.4 Diagrama de Implantação .......................................................................................................... 26
3.1.5 Diagrama de Pacotes .................................................................................................................. 27
3.2 Diagramas Comportamentais da UML ........................................................................................... 27
3.2.1 Diagrama de Caso de Uso ........................................................................................................... 28
3.2.2 Diagrama de Sequência .............................................................................................................. 29
3.2.3 Diagrama de Estados .................................................................................................................. 30
3.2.4 Diagrama de Atividades ............................................................................................................. 30
3.3 Relacionamentos em UML ................................................................................................................ 31
3.3.1 Relacionamento de Dependência................................................................................................ 31
3.3.2 Relacionamento de Associação .................................................................................................. 32
3.3.3 Relacionamento de Generalização .............................................................................................. 33
4.1 Histórico da Linguagem .................................................................................................................... 35
4.2 Uso da linguagem no mercado atualmente (especificação das tecnologias). ................................... 36
4.3 Principais características da linguagem de programação java .......................................................... 37
4.4 Ambientes e ferramentas de desenvolvimento com Java .................................................................. 42
4.5 Meu primeiro programa em java....................................................................................................... 43
4.6 Comentários em Java: ....................................................................................................................... 45
4.7 Compilando meu primeiro programa em Java .................................................................................. 45
4.8 Erros comuns em programas java ..................................................................................................... 47
4.9 NetBeans ........................................................................................................................................... 48
4.10 Visão de outras IDEs para o desenvolvimento com Java................................................................ 48
4.11 Identificadores e palavras-chaves................................................................................................. 50
4.12 Operadores em Java: ....................................................................................................................... 55
4.13 Operadores aritméticos. .................................................................................................................. 62
5.0 Controle de fluxo em Java .................................................................................................................... 70
5.1 Utilizar código que use instruções if ................................................................................................. 70
2
5.2 Expressões válidas para instruções switch e case. ............................................................................ 74

5.3 Loops e iteradores (usando os loops for, while e do while). ............................................................. 77
5.4 Loop for aprimorado (para arrays). ................................................................................................... 80
5.5 Uso de break, continue e return. ....................................................................................................... 81
6.0 Tipos de Variáveis, Constantes e Casting ............................................................................................. 84
6.1 O que é uma variável: ....................................................................................................................... 84
6.2 Variáveis estáticas: ............................................................................................................................ 85
6.3 Constantes ......................................................................................................................................... 86
6.4 Conversão ou Cast (explícita e implícita das variáveis de tipos primitivos). ................................... 87
6.5 Atribuindo uma variável de referência à outra. ................................................................................. 89
7.0 POO com Java....................................................................................................................................... 91
7.1 Introdução ......................................................................................................................................... 91
7.2 Construindo uma Classe. .................................................................................................................. 93
7.3 Encapsulamento. ............................................................................................................................... 94
7.4 Retorno .............................................................................................................................................. 94
7.5 Estanciando (Construindo um Objeto).............................................................................................. 95
7.6 Variáveis Estáticas ............................................................................................................................ 96
7.7 Métodos Estáticos ............................................................................................................................. 97
8.0 Herança e Interface ............................................................................................................................... 98
8.1 Introdução ......................................................................................................................................... 98
8.2 Herança ............................................................................................................................................. 98
8.3 Object: A superclasse cósmica do Java ............................................................................................. 99
8.3.1 Classe Abstrata ......................................................................................................................... 104
8.4 Interface .......................................................................................................................................... 107
9.0 Herança (Polimorfismo)...................................................................................................................... 109
9.1 Introdução ....................................................................................................................................... 109
9.2 SobreEscrita .................................................................................................................................... 109
10.0 Tratamento de Exceções ................................................................................................................... 112
10.1 Capturando uma exceção usando o bloco (try e catch)................................................................. 112
11.0 Criando Diagrama UML ................................................................................................................... 117
Introdução ............................................................................................................................................. 117
12.0 Fila e Pilha ........................................................................................................................................ 121
12.1 Fila ................................................................................................................................................ 121
12.2 Pilha .............................................................................................................................................. 123
13.0 Coleções: List e Map ........................................................................................................................ 126
13.1 Collection List ou Coleção Lista................................................................................................... 127
13.2 Collection Map ou Coleção Mapa ................................................................................................ 136
13.3 HashMap ....................................................................................................................................... 136
14.0 Interface Gráfica com usuário - GUI ................................................................................................ 142
14.1 Bibliotecas AWT e SWING .......................................................................................................... 143
14.2 JFrame ........................................................................................................................................... 143
14.3 Criando uma classe com propriedades JFrame ............................................................................. 145
14.4 JLabel ............................................................................................................................................ 147
14.5 JButton .......................................................................................................................................... 149
14.6 JTextField ...................................................................................................................................... 150
14.6 Icon ............................................................................................................................................... 151
14.7 Editando fonte com o setFont()..................................................................................................... 153
14.8 JMenuBar, JMenu e JMenuItem ................................................................................................... 153
3
14.9 JCheckBox .................................................................................................................................... 155

14.10 JRadioButton............................................................................................................................... 157
15.0 Gerenciadores de Layout .................................................................................................................. 160
15.1 BorderLayout ................................................................................................................................ 160
15.2 BoxLayout..................................................................................................................................... 161
15.3 FlowLayout ................................................................................................................................... 163
15.4 GridLayout .................................................................................................................................... 164
15.5 GridBabLayout ............................................................................................................................. 165
16.0 Eventos (Listeners) ........................................................................................................................... 167
16.1 FocusListener ................................................................................................................................ 169
16.2 KeyListener ................................................................................................................................... 171
16.3 MouseListener............................................................................................................................... 172

4
APRESENTAÇÃO
A disciplina de POO/Java faz parte do eixo de programação Java para Desktop e segue um fio condutor
iniciado pela Lógica de Programação e será seguida pela disciplina de Banco de Dados, e posteriormente
por Laboratório de Software.
A Programação Orientado a Objeto constitui em um conjunto de regras de programação. Estudamos

anteriormente como programar de forma estruturada, iniciávamos a execução do código e finalizando
todos os processos na mesma página. Com a Programação Orientada a Objetos podemos usar algoritmos
já feitos por alguém, ou criar novos algoritmos interagindo com os que já foram desenvolvidos por
alguém com objetivo de resolver problemas mais complexos gerando um novo produto final. Vamos fazer
uma comparação no o dia a dia para entendermos melhor.
O principal objetivo deste manual é apresentar para o aluno uma alternativa para o processo de
desenvolvimento de software orientado a objetos, embora existam outros processos, outros padrões, em
fim, outras alternativas que, certamente, eles irão se deparar no mundo do trabalho. Esta experiência o
fará entender a importância do processo de desenvolvimento de software para termos produtos eficiente e
eficaz.
Sendo assim, temos a apresentação da UML, ferramenta de documentação de projetos de software mais
usada pelo mercado atualmente. Descrevemos alguns itens complementares da linguagem Java que não
foram abordados no manual de Lógica de Programação, mas julgamos importantes. Em seguida teremos
os conceitos de Orientação a Objetos. Por fim iremos implementar modelos usando Java.swing, como a
essa altura os conceitos de banco de dados ainda não foram aprendidos, usaremos uma simulação do
banco baseada em vetores de objetos.
Este material teve como grande contribuição e referência para alguns capítulos o material do projeto
MEDIOTEC – SEDUC, como apostilas do módulo II e III, em uma verificação e adaptação do material,
por ser um material muito importante e de altíssima qualidade, aproximando bastante a experiência à
pratica do técnico em informática na área de desenvolvimento para web.
Outras referências de pesquisa e adaptação, foram de matérias de sites e artigos confiáveis da internet.

5
1.0 Introdução a Sistemas

Programação Orientado a Objeto constitui em um conjunto de regras de programação. Estudamos
todos os processos na mesma página. Com a Programação Orientada a Objetos podemos usar algoritmos
já feitos por alguém, ou criar novos algoritmos interagindo com os que já foram desenvolvidos por
alguém com objetivo de resolver problemas mais complexos gerando um novo produto final. Vamos fazer
uma comparação no dia a dia para entendermos melhor.
A Programação orientado a objeto é uma metodologia que os programadores utilizam com objetivo de
atingir alguns requisitos importantes na construção de um bom programa ou site como:
• Organizar o código: Com o nosso código dividido, podemos facilmente dar manutenção ou encontrar
algum erro mais facilidade.
• Reutilização do código: Não precisamos reescrever todo o código, quando necessitamos dele
novamente.
• Manter Padrões: Utilização de um mesmo padrão conceitual durante todo o processo de criação do

6
código.
Até o final do curso iremos aprender e trabalhar nessa metodologia. Então, bastante atenção nesse e nos
próximos capítulos.
1.1 Modelagem de Sistemas
Modelar é:
 Representar de forma gráfica ou textual partes reais ou imaginárias do sistema.
 Por no papel a concepção que se tem de como funcionará o sistema concebido.
 Documentar de forma gráfica ou em texto um sistema existente (engenharia reversa).
Por que é importante modelar?
Se observarmos tudo que será construído primeiro passa por uma fase de modelagem, isso ocorre em
todas as áreas. Exemplo: um engenheiro primeiro constrói a planta de uma casa e só então começa a
construção do imóvel. A planta o guiará durante toda a construção.
Em desenvolvimento de sistema não é diferente primeiro o analista deve estruturar toda a modelagem do
sistema, conversando com o usuário, colhendo informações e requisitos do sistema, depois ele deve
desenhar o sistema para realizar essa fase ele precisará de uma linguagem padrão para desenhar o sistema,
essa linguagem deve ser conhecida por todos da área, pois assim qualquer pessoa que trabalhe com
desenvolvimento de sistemas pode dar andamento ao projeto. A última fase da modelagem é a aprovação
do projeto, após isso passamos para etapa de construção do software. Note que assim como a planta da
casa para o engenheiro o guiará durante toda a construção do imóvel, para a equipe que desenvolve o
software a modelagem do sistema será importante em todas as fases de desenvolvimento.
Inicialmente, vamos definir alguns conceitos básicos para posteriormente assimilarmos o conteúdo de
Análise de sistemas.
O que é dado?
“Dados são itens referentes a uma descrição primária de objetos, eventos, atividades e transações que são
gravados, classificados e armazenados, mas não chegam a ser organizados de forma a transmitir algum
significado específico” (Turban, McLean e Wetherbe, 004, pg. 63).
7
O que é uma informação?
“Informação é todo conjunto de dados organizados de forma a terem sentido e valor para seu destinatário.
Este interpreta o significado, tira conclusões e faz deduções a partir deles. Os dados processados por um
programa aplicativo têm uso mais específico e maior valor agregado do que aqueles simplesmente
recuperados de um banco de dados. Esse aplicativo pode ser um sistema de gerenciamento de estoques,
um sistema de matrículas online de uma universidade, ou um sistema de Internet para compra e venda de
ações”. (Turban, McLean e Wetherbe, 2004, pg. 63).
O que é conhecimento?
“Conhecimento consiste de dados e informações organizados e processados para transmitir compreensão,

experiência, aprendizado acumulado e técnica, quando se aplicam a determinado problema ou atividade.
Os dados processados para extrair deduções críticas e para refletir experiência e perícia anteriores
fornecem a quem os recebe conhecimento organizacional, de alto valor potencial”. (Turban, McLean e
Wetherbe, 2004, pg. 63).
1.2 Dado, Conhecimento e Informação.
Observe nas imagens abaixo a distinção entre Dados, Informações e Conhecimento:
Resultado do processo cognitivo, iniciado por um novo estímulo

qualquer. Informação valiosa da mente humana. Inclui reflexão,
síntese e contexto. Frequentemente tácito. De difícil estruturação,
captura em máquinas e transferências.
Capítulo 8 -
São dados dotados de relevância e propósito. Requer
unidade de análise. Exige consenso em relação ao
Tratamento
significado e é necessária a mediação humana.
deobservações
Simples Exceçõessobre o estado do
mundo. Facilmente estruturado, obtido por
máquina e

8
DADO INFORMAÇÃO CONHECIMENTO

Simples observações sobre o Dados dotados de relevância e Informação valiosa da mente
estado do mundo propósito humana. Inclui reflexão,
síntese, contexto.
Facilmente estruturado Requer unidade de análise De difícil estruturação
Facilmente obtido por máquinas Exige consenso em relação ao De difícil captura em máquinas
significado
Frequentemente quantificado Exige necessariamente a Frequentemente tácito
mediação humana
Facilmente transferível De difícil transferência
EXEMPLO
Através dos conceitos acima, já podemos ter uma ideia do significado de dados, informações e
conhecimentos para um Sistema de Informação. Vamos analisar um exemplo:
Milena é aluna de uma EEEP. Assim como todos os demais, possui um boletim com notas de diversas
disciplinas. Essas notas nada mais são do que números que de alguma forma foram friamente calculados,
gerados e impressos em um papel através de uma programação. As notas ali contidas são nada mais do
que dados.
Se analisarmos seu boletim, podemos observar que todas as suas notas são boas, pois estão bem acima da
média. Contextualizando esses dados, obtemos uma informação: Milena é uma ótima aluna.
Indo mais além, analisando o seu comportamento, temos que ela é uma aluna proativa em sala de aula,
administra bem o seu tempo, utiliza as aulas de estudo para de fato estudar e pratica a TESE como sua
filosofia de vida. Contextualizando essas informações chegamos a um conhecimento sobre a pessoa de
Milena.
1.3 O que é um sistema
Para termos uma real compreensão do que é um Sistema de Informação, faz-se necessário anteriormente
entender o que é um Sistema. Nesse sentido, é válida a definição apontada no site Wikipédia, em junho de
9
2012: “Sistema (do grego sietemiun) é um conjunto de elementos interconectados, de modo a formar um
todo organizado. É uma definição que acontece em várias disciplinas, como biologia, medicina,
informática, etc. Vindo do grego o termo “sistema” significa “combinar”, “ajustar”, “formar um
conjunto”.
Segundo Chiavenato (1999) e Oliveira (2002), o sistema apresenta os seguintes componentes:
 Objetivos: é a finalidade para o qual o sistema foi criado;
 Entradas do Sistema: é o que inicia o sistema, traz a informação para a operação do sistema;
 Processamento: fenômeno que realiza as mudanças, é o mecanismo que converte as entradas em

saídas;
 Saídas do Sistema: são os resultados do processamento.
 Retroalimentação ou feed back do sistema: é a informação gerada pelo sistema que informa sobre
o comportamento do mesmo;
 Ambiente: é o meio que envolve externamente o sistema.
De posse da definição podemos definir o Sistema de Informação ou simplesmente SI, como sendo um
conjunto organizado de dados, cujo elemento principal é a informação. Sua função principal é o
armazenamento, tratamento e fornecimento de informação que de forma organizada servem de apoio a
funções ou processos de uma empresa, por exemplo. Um SI não necessita, necessariamente, ser
computadorizado. As fichas organizadas dos alunos em uma academia de musculação formam, por
exemplo, um sistema de informações.
Os sistemas de Informação podem ser divididos em subsistemas e, em muitos modelos aparecem dois
deles, sendo um com processos, pessoas, documentos e informações, enquanto o outro apresenta os meios
automatizados como, por exemplo, as máquinas, redes de comunicação e computadores. Ao primeiro
chamamos de subsistema social e o segundo denomina-se subsistema automatizado. Do apresentado até
aqui fica fácil perceber que o Sistema de Informações é conteúdo bastante amplo, já que inclui pessoas,
dados, processos, programas (softwares), maquinários (hardware), etc.
Todos os aspectos que envolvem o Sistema possuem importância significativa, já que funcionam como
uma verdadeira engrenagem, ou seja, uma fase depende da outra, uma peça ajuda a outra, enfim, todos se
complementam. Assim, hardware, software, fator humano e qualidade das informações, são igualmente
10
válidos para o funcionamento com excelência.
Tomemos por exemplo uma lanchonete que buscou implantar um Sistema de Informação com o intuito de
garantir maior agilidade no atendimento dos clientes. Para tanto pensou em um cardápio fixo, comprou
computadores eficazes e alocou código de barras nas embalagens. Aparentemente esta medidas poderiam
sim agilizar o atendimento, porém, se os colaboradores não forem capacitados para utilizar as
ferramentas, certamente ao invés de garantir maior agilidade no atendimento, pode até mesmo causar
maior embaraço.
Os sistemas de informação são poderosas ferramentas e, nesta concepção apresentam diversas aplicações
e benefícios, dentre eles podemos citar: organizar/incrementar a produtividade; fortalecer estratégias de
marketing; formatar a qualificação dos colaboradores; estabelecer rotinas de controle de produtos
(entrada e saída – preços – lucros, etc.).
1.4 Como construir um Sistema de informação baseado em computador
Dizemos que um Sistema de informação é baseado em computador quando ele realiza parte - ou mesmo
todas – as tarefas desejadas por meio da computação. Para que um sistema de informação obtenha
sucesso na realização de suas rotinas, é preciso que se entenda todos os processos e procedimentos
relacionados à tarefa a ser executada. Ou seja, é indispensável que se tenha um convívio direto com os
problemas e soluções diárias naquele contexto em que o sistema será implantado, pois esse conhecimento
profundo é o que vai dar embasamento para o desenvolvimento de um Sistema de Informação que seja
realmente eficiente.
Em posse de um objetivo, qual seja planejar e desenvolver a construção de um Sistema de Informação

eficiente para determinada situação, devemos analisar outros fatores decisivos nesse processo. O
ambiente no qual o sistema será implantado é um deles, e pode influenciar de forma direta ou indireta no
funcionamento de um sistema.
Por exemplo, poderemos obter resultados completamente diferentes ao implantar um sistema on-line em
uma cidade capital de estado, onde o acesso à internet é incorporado ao cotidiano dos supostos usuários, e
em uma pequena cidade do interior onde o acesso à rede ainda é um privilégio restrito a poucos. Nesse
caso, o fator internet é determinante para o sucesso ou insucesso do Sistema de Informação.

11
Outro fator que influencia de forma direta o desenvolvimento do sistema são os chamados recursos de
sistema, que são os recursos indispensáveis à construção de um Sistema de Informação. São exemplos
deles: dinheiro, máquinas, pessoas capacitadas, ambiente físico, papéis, etc.
Além dos fatores citados, outro a ser considerado é a análise dos dados relevantes para o Sistema de
Informação. Tais dados devem ser cuidadosamente examinados, ponderados e utilizados de forma
consistente, a fim de gerarem informações que de fato sejam úteis aos usuários. Um sistema que
considera a entrada de dados inconsistentes em seu funcionamento, como data em branco ou preços com
valores nulos, certamente não chegará a uma saída interessante.
Mas, afinal, a quem compete este trabalho?
1.5 O papel do Analista de Sistemas
O profissional da Tecnologia da Informação responsável por todo este trabalho é o Analista de Sistemas.
Ele é, na prática, um solucionador de problemas e exerce uma função bastante complexa, que é
concretizar em um software todo um sistema de informação.
Um bom analista de sistemas tem como principais características:
 Conhecimento teórico e prático de computação;
 Ampla visão organizacional e empresarial;
 Bom senso na tomada de decisões;
 Bom relacionamento interpessoal para lidar com todos envolvidos no projeto;

12
“É muito difícil criar produtos usando grupos foco. Muitas vezes, as pessoas
não sabem o que elas querem até que você mostre a elas.”
Steve Jobs
1.6 Fases do desenvolvimento de sistemas
Já sabemos o que é um sistema de informação, quais seus fatores principais e quem é o responsável por
desenvolvê-lo. Vamos agora entender como se dá todo esse processo, desde o início da ideia até a
conclusão de seus trabalhos.
Como vimos, a construção de um software é um processo complexo e para que se obtenha sucesso, seu
desenvolvimento deve seguir uma exigente metodologia de trabalho. Vejamos cada uma das fases desse
processo:
CONCEPÇÃO DO SISTEMA
É uma fase de descobertas. Requer que todos os envolvidos – desenvolvedores e usuários - mantenham
postura colaborativa para que os requisitos levantados sejam o mais próximo possível da realidade.
Baseado nessas informações, o analista de sistemas consegue fazer um diagnóstico da situação e uma
previsão de ações.
ESTUDO DA VIABILIDADE
Após a apropriação do contexto na fase anterior, é feito um estudo para avaliar se o projeto é ou não
viável de ser implementado, do ponto de vista organizacional, tecnológico e financeiro. A decisão da
continuidade ou não do projeto cabe aos analistas e aos gestores da organização que será beneficiada.
Nessa fase, são analisados os seguintes questionamentos:
 O sistema poderá contribuir de fato para realização dos objetivos previstos?
 O sistema poderá ser implementando, apesar de restrições de cunho tecnológico, organizacional e

temporais?
 Existe outro modo eficiente de realização dessas tarefas sem a necessidade de criação desse
13
sistema?
 O sistema atual realmente pode resolver os problemas não solucionados pelos anteriores?
 É possível sua integração a sistemas já em funcionamento?
Caso os responsáveis optem pela continuidade do projeto, o mesmo será submetido à fase seguinte. Caso
contrário, o ciclo termina aqui.
PROCESSO DE ANÁLISE
Essa etapa consiste em realizar um levantamento de dados e de fatos, a fim de entender o que realmente
precisa ser feito para solucionar o problema. O contato entre analista de sistemas e usuários deve se
estreitar nesse momento, pois é preciso um entendimento detalhado e técnico por parte do analista. Caso
já exista algum sistema em funcionamento, este é o momento em que o analista se apropria de maiores
detalhes do mesmo.
Deverá ser criado um modelo lógico do sistema, constituído, entre outros, do diagrama de fluxo de dados,
dicionário de dados e principais algoritmos.
Até o término dessa fase, já devem ser de conhecimento do analista os objetivos principais do sistema em
questão, quais setores da empresa serão impactados pelo sistema, como este deverá funcionar, qual será o
fluxo de dados, quais serão os arquivos utilizados e a forma como serão atualizados, qual setor será
responsável pela população do sistema, qual o prazo para que esses dados sejam processados e
apresentado algum resultado aos usuários.
PROJETO DO SISTEMA
Nesse momento, o analista propõe soluções para o problema baseado em conclusões das fases anteriores.
Para cada alternativa sugerida, apresenta-se aos gestores da organização um diagrama de fluxo de dados,
para que seja feita uma escolha baseada em custos e benefícios. O modelo lógico foi sendo transformado
em modelo físico.
Ao final da fase, já deverá estar definido pelo analista um relatório contendo qual tipo de banco de dados
será adotado pelo sistema, os arquivos que serão utilizados, a definição dos arquivos de dados e seus
layouts, relatórios a serem emitidos e os tipos de dispositivos de armazenamento de dados.

14
PROJETO DETALHADO
Tomada a decisão, é hora de dar início a implementação do sistema. O analista de sistemas já sabe o que
deve ser feito, tecnicamente, para dar inicio a esse processo.
Nesse momento, os relatos dos usuários ainda podem ser de grande valia para a condução do sistema. O
analista de sistemas deve definir quais programas irão compor o sistema, e produzir as especificações
referentes a cada um deles, especificações essas que serão posteriormente entregues e codificadas pelos
programadores.
Exemplos de especificações definidas nesta fase:
 Aprimoramento do fluxo de dados da alternativa escolhida;
 Identificação do banco de dados ou arquivos a serem utilizados;
 Detalhamento de arquivos de dados e seus layouts;
 Criação de layouts de relatórios a serem emitidos pelo sistema;
 Especificação de todos os programas que irão compor o sistema;
 Revisão na estimativa de custos;
 Preparação da documentação inicial do sistema;
 Definição dos tipos de dispositivo de armazenamento;
 Elaboração de um plano de testes;
IMPLEMENTAÇÃO
A fase de implementação é quando de fato o programa começa ser construído na plataforma escolhida,
tendo como base as especificações produzidas. É, de todas, a fase mais cara.
Os programas que se referem ao gerenciamento do sistema em geral deverão ser os primeiros a serem
construídos, e só após, os demais.
Inicia-se, após a finalização dos programas, os testes. Todo o sistema deve ser testado exaustivamente
antes de ser posto em funcionamento. Ainda nesta fase, os erros detectados na homologação (testes) são
corrigidos e testados novamente.

15
Uma vez sem erros, a equipe deve dedicar-se a escrever os manuais do usuário, um tutorial contendo
todas as informações necessárias para seu funcionamento.
IMPLANTAÇÃO E MANUTENÇÃO
Finalmente, chegamos à implantação e manutenção, última fase da criação de um sistema. Implantar

significa colocar o sistema em fase de operação, ou seja, realizar as instalações necessárias para o uso do
sistema no local predefinido. Uma vez implantado, os usuários deverão ser treinados a operar
corretamente o sistema.
Ao ser submetido ao uso real, o sistema ainda poderá apresentar alguma falha, portando a equipe de
analista e programadores ainda pode realizar ajustes.
Agora, é apenas manter em pleno funcionamento, desenvolvendo pequenas melhorias e adequações

quando necessário.
TESTES
Diversas atividades de testes são executadas a fim de se validar o produto de software, testando cada
funcionalidade de cada módulo, buscando, levando em consideração a especificação feita na fase de
projeto. Onde o principal resultado é o relatório de testes, que contém as informações relevantes sobre
erros encontrados no sistema, e seu comportamento em vários aspectos. Ao final dessa atividade, os
diversos módulos do sistema são integrados, resultando no produto de software.

16
2.0 Requisitos
Os requisitos de um sistema são os elementos que a equipe de desenvolvimento precisa conhecer para que
o software seja desenvolvido. São as necessidades que deverão ser atendidas pelo sistema de informação
que será proposto. Em posse dessas informações, o analista tem propriedade para propor soluções,
especificar e desenvolver um sistema de informação. Segundo Sewbok, “Um requisito de software é uma
propriedade que deve ser implementada para resolver um problema do mundo real”.
Acontece que tomar conhecimento desses requisitos é uma tarefa que, na prática, não é tão simples como
parece. Muitas vezes os próprios gestores e usuários não conseguem expressar claramente seus objetivos.
Por desconhecerem os procedimentos técnicos que regem um Sistema de Informação, muitas vezes eles
ocultam informações de extrema importância, fundamentais para o planejamento da solução.
Nesse ponto, a atuação do analista de sistemas é decisiva para o sucesso ou não do trabalho. Dificilmente
todas essas informações irão estar reunidas em uma pessoa só, portando o analista tem que conversar com
pessoas de todos os setores que irão utilizar o sistema, pois precisa ter uma visão de todas as
funcionalidades que irá implementar. É preciso conhecer a dinâmica de trabalho de cada envolvido. Por
exemplo, dificilmente o gerente de vendas de uma empresa saberá com precisão como o almoxarifado
controla a saída de produtos, ou como exatamente a cozinha mantém o controle sobre seu estoque,
portando, é atribuição do analista capturar esse processo pessoalmente.
LEVANTAMENTO DE REQUISITOS
Como vimos, o analista de sistemas é o responsável intermediar e identificar os requisitos. Para isso, ele
dispõe de algumas técnicas que o auxiliam a estreitar as relações com os usuários, visando obter dos
clientes o máximo de informações úteis. Entre as técnicas utilizadas para este processo, podemos
destacar, entre outras, as seguintes:
ENTREVISTA
É uma das formas mais eficientes de se obter as informações desejadas. Não existe uma fórmula ou
receita certa para a sua condução, mas, para obter um melhor resultado, o analista deve atuar de forma
racional e metódica, com certa flexibilidade, porém, sem improvisações desnecessárias.

17
O analista deve ter manter na entrevista um clima amistoso, deixando o entrevistado à vontade. Ele deve
entender que a entrevista não é um julgamento, pois se por algum motivo se sentir acanhado, poderá não
prezar pela veracidade das informações.
Outros fatores importantes em uma entrevista são: bom relacionamento interpessoal do entrevistador,
habilidade ao se comunicar e humildade.
PESQUISA
Embora a entrevista seja uma técnica altamente eficaz, não deve ser a única fonte de levantamento de
requisitos. Outra forma de se obter dados interessantes é a pesquisa. O analista poderá analisar
documentos e relatórios gerados em diversos setores, além de arquivos, e baseado neles tirar outras
conclusões, que podem vir a somar com o resultado já obtido na entrevista.
QUESTIONÁRIO
Quando o sistema envolve um número muito grande de usuários, a aplicação de questionários é uma boa
estratégia de pesquisa. Com perguntas sucintas, objetivas e sem dubiedade, é possível observar o padrão
de respostas e dele retirar pertinentes conclusões.
REUNIÕES
São encontros com a participação de alguns usuários envolvidos, para discussões em grupo. Deve ser
conduzida de forma hábil pelo mediador, mantendo sempre o foco, qual seja a discussão sobre as rotinas
da organização para uma maior percepção dos requisitos por parte do analista.
OBSERVAÇÕES
Mesmo utilizando técnicas como entrevista ou reunião, algumas informações podem passar
despercebidas. Observar o comportamento e o ambiente de trabalho dos usuários pode ser uma técnica
eficaz para perceber alguma dessas informações que porventura não foi levada em consideração em outro
momento.

18
2.1 Análise de Requisitos
2.1.1 Requisitos Funcionais
Requisitos funcionais são aqueles que descrevem funcionalidades que o sistema deve ter para atender às
expectativas dos usuários. Por exemplo:
 O software deverá calcular a média de notas dos alunos;
 O software deverá enviar, a cada semestre, um email para os pais com o boletim de seus filhos em
anexo;
 O software deverá emitir relatório de compras quinzenalmente;
 O software deverá alertar ao chefe do restaurante quando o estoque estiver abaixo do estabelecido.
2.1.2 Requisitos não Funcionais
Já os requisitos não funcionais são aqueles que descrevem as características do sistema, como
usabilidade, desempenho, confiabilidade, custo, etc. São exemplos de requisitos não funcionais:
 O acesso às funcionalidades de gestão deve ser restrito aos diretores da empresa;
 Se o tempo de resposta ultrapassar 30 segundos, redirecionar para página de erro;
 O software deverá ser desenvolvido para sistema operacional Linux;
 O prazo de entrega do sistema ao cliente deve ser de 2 anos.
2.1.3 Requisitos do usuário
Requisitos de usuário são declarações escritas, em linguagem natural, das funcionalidades que o sistema
oferece. No documento, deve constar basicamente a descrição dos requisitos funcionais, requisitos não
funcionais, devendo conter inclusive as restrições operacionais do sistema. Este material destina-se ao
cliente, portanto deve ser escrito em linguagem clara e compreensível, além de conter tabelas e
diagramas, visto que os usuários não possuem conhecimentos técnicos em desenvolvimento de sistemas.
A quem interessa:
19
 Gerentes de clientes
 Usuários finais do sistema
 Engenheiros do cliente
 Gerentes do fornecedor
 Arquitetos do sistema
2.1.4 Requisitos do sistema
Consiste em um documento estruturado, que estabelece detalhes das funcionalidades e restrições do

sistema. Pode ser elaborado como forma de contrato entre o cliente e contratante.
A quem interessa:
 Usuários finais do sistema
 Engenheiros da organização cliente
 Arquitetos do sistema
 Desenvolvedores de software
2.1.5 Especificação de Software
É um documento que consiste em uma minuciosa descrição do sistema, que vem a servir como base para
a implementação do mesmo. As especificações de software são destinadas aos próprios desenvolvedores.
A quem interessa:
 Engenheiros da organização cliente
 Arquitetos do Sistema
 Engenheiros de Software

20
3.0 História e evolução da UML
A UML é uma linguagem para modelagem de softwares, ela é utilizada no processo de definição do
software, na análise e estruturação de como o programa será implementado. Ela permite que os
desenvolvedores de software possam modelar seus programas de forma unificada, isso quer dizer que
qualquer pessoa que entenda UML poderá entender a especificação de um software. O Objetivo da UML
é descrever “o que fazer”, “como fazer”, “quando fazer” e “porque deve ser feito”.
Para modelar os sistemas a UML possui um conjunto de diagramas que devem ser utilizados em
combinação para obter todas as visões do sistema.
A UML é utilizada para modelar sistemas escritos no padrão orientado a objetos, portanto para todas as
definições existentes na orientação a objetos haverá um diagrama correspondente. Exemplo: Uma classe,
um objetos, a comunicação dos objetos e etc.
Na criação da UML estão envolvidos três personagens: Jim Rumbaugh, Grady Booch e, Ivar Jacobson.
Jim Rumbaugh e Grady Booch combinaram dois métodos populares de modelagem orientada a objeto:
Booch e OMT (Object Modeling Language), mas tarde, IvarJacobson, o criador do método Objectory
uniu-se aos dois para a concepção da primeira versão da linguagem UML (Unified Modeling Language).
Em 1997 a UML foi adotada como padrão pela OMG (Object Management Group). Que é uma
organização internacional que aprova padrões abertos para aplicações orientadas a objetos.

21
Em 1995 ocorre a união de vários métodos de modelagem como OOSE, BOOCH, OMT e outros.
 Em 1996 surge a UML 0.9
 Em 1997 surge a UML 1.0 que no mesmo ano evoluiu para a UML 1.1. Nesse ano a OMG que é
uma organização mundial de padrões orientados a objetos reconhece a UML.
 Em 2001 a UML passa por revisões e é lançado a UML 1.4
 Em 2002 a UML é reestruturada e da origem a UML 2.0.
A UML divide seus diagramas em Estruturais e Comportamentais, como demonstrado pela Figura 5. No
sentido horário, a partir do Diagrama de Caso de Uso, até o Diagrama de Interação, temos os diagramas
Comportamentais. Os demais são os Diagramas Estruturais.
Aqui vamos estudar apenas alguns diagramas, em toda a apostila você irá encontrar exemplos com
codificação em Java e seu respectivo diagrama. Então é muito importante que entendam os diagramas
estudados e saiba reconhecê-los.

22
3.1 Diagramas Estruturais da UML
Usados para visualizar, especificar, construir e documentar aspectos estáticos de um sistema.
3.1.1 Diagrama de Classe
Este diagrama é fundamental e é o mais utilizado na UML, serve de apoio aos outros diagramas. O
Diagrama de Classe mostra o conjunto de classes com seus atributos e métodos e os relacionamentos
entre classes. Em todo sistema baseado na orientação a objetos as um dos princípios fundamentais são as
classes que definem o sistema.
Representa uma coleção de classes e seus inter-relacionamentos.

23
3.1.2 Diagrama de Objeto
O diagrama de objeto está relacionado com o diagrama de classes e, é praticamente um complemento

dele. Fornece uma visão dos valores armazenados pelos objetos de um diagrama de classe em um
determinado momento da execução do processo do software. São muito úteis para exemplificar
relacionamentos complexos entre objetos em determinado momento
Observe na imagem abaixo que o objeto da classe cliente guarda os valores armazenados pelo objeto no
momento atual da execução.
Representa um retrato, em tempo de execução, dos objetos do software e seus inter-

relacionamentos.

24
3.1.3 Diagrama de Componentes
Está associado à linguagem de programação e tem por finalidade indicar os componentes do software e
seus relacionamentos.
Um componente é elemento externo de software que compõe programa que estamos implementando, é
como um código externo que é reaproveitado. Esse componente pode ser substituído por outro
componente, como, por exemplo: executáveis, bibliotecas, tabelas, pastas e documentos.
Na figura abaixo temos um exemplo de diagrama de componente, perceba comunicação entre

componentes executáveis, bibliotecas (DLL), arquivos XML, imagens, tabelas e arquivos de texto. Tudo
isso é considerado um componente do software.
Representa uma coleção de componentes de software e seus inter-relacionamentos.

25
3.1.4 Diagrama de Implantação
Diagrama de Implantação é usado para mostrar a organização do hardware e a ligação do software aos
dispositivos físicos, Como processador, impressora, memória, disco; é necessário para que o engenheiro
de software especifique a plataforma em que o sistema é executado.
O diagrama de implantação ao lado demonstra a plataforma física que o software será implantado.

26
3.1.5 Diagrama de Pacotes

Representa os pacotes que o sistema está divido, demonstrando a interação lógica entre as partes.
Observe a comunicação entre os pacotes de parte do sistema.
Representa uma coleção de outros elementos de modelagem e diagramas.
3.2 Diagramas Comportamentais da UML
Usados para visualizar, especificar, construir e documentar aspectos dinâmicos de um sistema.

27
3.2.1 Diagrama de Caso de Uso
É o diagrama comportamental mais utilizado na modelagem de sistemas, ele representa uma

funcionalidade do sistema.
O diagrama de caso de uso ajuda a definir a sequência de ações executadas por um ou mais atores e pelo
próprio sistema para produzir resultados para um ou mais atores. Seu foco é identificar os objetivos do
usuário, em vez das funções do sistema através da análise de como o ator, de forma externa, interage com
as funcionalidades do sistema. Cada caso de uso no diagrama deve ter um documento correspondente
determinando o seu comportamento.
Para identificar os atores do diagrama o analista deve primeiro identificar as áreas da empresa que serão
afetadas pelo software. Existem algumas perguntas básicas que podem ajudar a descobrir os atores.
 Que órgãos, empresas ou pessoas utilizarão o sistema?
 Existem outros sistemas que irão se comunicar com o sistema que será construído?
 Alguém deve ser informado de alguma ocorrência do sistema.

28
3.2.2 Diagrama de Sequência
Descreve a ordem temporal em que as mensagens são trocadas entre os objetos.
A função desse diagrama é estabelecer como os objetos interagem e seus relacionamentos dentro de um
contexto.
A leitura desse diagrama é feito em duas dimensões: horizontal, onde estão representados os objetos, e
vertical que representa a linha do tempo. A interação entre os objetos é feita através de mensagens,
representas através de linhas sólidas direcionadas, partindo o objeto solicitando para o solicitado.
Cada objeto, representado no diagrama por um retângulo contendo seu nome, corresponde à uma coluna.
Cada objeto possui uma linha tracejada vertical, que indica o seu tempo de vida.
A linha de vida de um objeto tem a função de:
 Apresentam o tempo de vida dos objetos
 Pode apresentar a ativação ou a desativação dos objetos
 Indicam que os objetos estão executando algo
 Indica chamada de método do próprio objeto

29
 Podem representar a criação e a destruição de objetos
3.2.3 Diagrama de Estados
Procura acompanhar as mudanças sofridas por um objeto dentro de um processo no sistema, dando ênfase
aos estados dos objetos e as transições entre os estados. Costuma ser empregado para modelar os aspectos
dinâmicos do sistema e possui o seu comportamento orientado por eventos, onde cada evento gera um
novo estado no diagrama.
Temos um diagrama de estado genérico, com o único estado, representado na Figura - Diagrama de estado.
Observando a imagem identificamos o estado (como o objeto está naquele momento) representado por
um retângulo com bordas arredondadas, as transições (mudança de estado do objeto) representadas por
linhas orientadas por setas, ponto inicial (onde o objeto nasce) representado por um círculo totalmente
hachurado e o ponto final (onde o objeto morre) representado por um círculo parcialmente hachurado.
3.2.4 Diagrama de Atividades

Descreve os passos a serem percorridos para a conclusão de uma atividade.
O diagrama de atividade da ênfase as fluxo de controle de uma atividade para outra e identifica as
atividades existentes no sistema. A descrição dos elementos diagramas de atividades encontra-se na figura

30
abaixo:
O diagrama inicia com o círculo hachurado e o primeiro estado é solicitação do código do cliente, em
seguida verifica se o cliente já existe, nesse momento cai em uma tomada de decisão, se o cliente já
existe, informa para o usuário mostrando uma mensagem na tela e termina a atividade. Se não solicita os
dados do novo cliente, salva os dados e termina a atividade.
3.3 Relacionamentos em UML
Em UML, os relacionamentos são conexões entre itens. Ou seja, temos relacionamentos em vários
diagramas da UML, como relacionamento entre classes e relacionamento entre atores e casos de uso.
Em UML existem 3 tipos de relacionamento:
 Dependência
 Generalização
 Associação
3.3.1 Relacionamento de Dependência
É um relacionamento de utilização, ou seja, um item é dependente do outro, dessa forma alteração de um

31
item pode afetar o outro. Por exemplo, o relacionamento de dependência entre classes indica que os
objetos de uma classe usam funcionalidades dos objetos de outra classe.
 Representado por uma reta tracejada entre duas classes
 Uma seta na extremidade indica o dependente
 Tipo menos comum de relacionamento
 Identifica uma ligação fraca entre objetos de duas classes
3.3.2 Relacionamento de Associação
É um relacionamento estrutural que especifica a associação de objetos, classes e casos de uso.
 Nome: pode ser utilizado para descrever a natureza do relacionamento. Pode-se atribuir direção
para o nome, fornecendo um triângulo de orientação que aponta a direção como nome deve ser
lido
 Cardinalidade: a quantidade de objetos que podem ser conectados pela associação.
 Descreve um vínculo entre duas classes Chamado Associação Binária.
 Determina que as instâncias de uma classe estão de alguma forma ligadas às instâncias da outra
classe.
Na leitura do diagrama acima dizemos que um cliente pode ser de nenhum ou muitos DVD’s, já um DVD
pode ser composto de um ou muitos clientes.
32
3.3.3 Relacionamento de Generalização
A generalização é um relacionamento de herança, ou seja, existe uma superclasse (classe pai) e uma
subclasse (classe filha).
A classe filha herda característica da classe pai e pode também possuir suas próprias características, dessa
forma as subclasses compartilham a estrutura e comportamento das superclasses
Generalizações são relacionamentos “é-umtipo-de, ou seja, só é possível dizer que existe um

relacionamento de generalização quando a subclasse é um tipo da superclasse.
Vejamos como é possível identificar se existe um relacionamento de Generalização entre duas classes.
Imagine a classe Veiculo e avião. Então devemos fazer a pergunta: avião é um tipo de veiculo?
Resposta: SIM, então significa que avião é uma subclasse de veiculo.

33
No exemplo acima a classe cliente é a superclasse e Pessoa Física e Pessoa Jurídica são suas subclasses.
Note que as subclasses possuem características próprias além de herdar as características da sua
superclasse.
A Generalização pode ainda ser demonstrada de duas formas

34
4.0 O que é a Linguagem Java?
Bem vindos ao futuro! Java não é somente uma linguagem de programação, mas também uma tecnologia
que tem como objetivo construir programas que possam ser utilizados em qualquer plataforma ou
computador, com o mínimo possível de dependência com um sistema operacional ou ambiente de
desenvolvimento.
Java possui uma sintaxe extremamente similar à do C++, e com diversas características herdadas
de outras linguagens, como Smalltalk e Modula-3. É antes de tudo é uma boa linguagem, simples, com
um ambiente de execução de alta qualidade e uma vasta biblioteca de classes disponíveis. Essa
combinação é que torna Java uma proposta irresistível para tantos programadores. Além de contar c
om as seguintes características: totalmente orientada a objetos, fortemente tipada, independente de
arquitetura, robusta, segura, portável, bem estruturada, suporta programação distribuída, multithreaded e
conta com garbage collection.
4.1 Histórico da Linguagem
Em 1991, na empresa Sun MicroSystems , foi iniciado o Green Project, o berço do Java uma linguagem
de programação orientada a objetos. Os mentores do projeto eram Patrick Naughton, Mike Sheridan,
e James Gosling. O objetivo do projeto não era a criação de uma nova linguagem de programação, mas
antecipar e planejar a “próxima onda” do mundo digital. Eles acreditavam que em algum tempo haveria
uma convergência dos computadores com os equipamentos e eletrodomésticos comumente usados pelas
pessoas no seu dia a dia.
James Gosling especificou uma nova linguagem de programação para o seu novo projeto e decidiu batizá-
la de “Oak”, que quer dizer carvalho, uma
árvore que ele podia observar quando olhava pela sua janela. O próximo passo era encontrar um mercado
para o *7. A equipe achava que uma boa ideia seria controlar televisões e vídeo por demanda com o
35
equipamento. Eles construíram um demo chamado MovieWood, mas infelizmente era muito cedo para
que o vídeo por demanda bem como as empresas de TV a cabo pudessem viabilizar o negócio. A ideia
que o *7 tentava vender, hoje já é realidade em programas interativos e também na televisão digital.
Permitir ao telespectador interagir com a emissora e com a programação em
uma grande rede a cabos, era algo muito visionário e estava muito longe do que as empresas de TV a
cabo tinham capacidade de entender e comprar.
O protótipo se chamava *7 (leia-se “StarSeven”),um controle remoto com uma interface gráfica
touchscreen. Para o *7 foi criado um mascote, hoje amplamente conhecido no mundo Java, o Duke. O
trabalho do Duke no *7 era ser um guia virtual ajudando e ensinando o usuário a utilizar o equipamento.
O *7 tinha a habilidade de controlar diversos dispositivos e aplicações.
A ideia certa, na época errada. A sorte é que o bom da Internet aconteceu, e rapidamente uma grande rede
interativa estava se estabelecendo. Era este tipo de rede interativa que a equipe do *7 estava tentando
vender para as em presas de TV a cabo. E, da noite para o dia, não era mais necessário construir a
infraestrutura para a rede, em um golpe de sorte, ela simplesmente estava lá. Gosling foi incumbido de
adaptar o Oak para a Internet e em janeiro 1995 foi lançada uma nova ver são do Oak que foi rebatizada
para Java. A tecnologia Java tinha sido projetada para se mover por meio das redes de
dispositivos heterogêneos, redes como a Internet. Agora aplicações poderiam ser executadas dentro dos
Browsers nos Applets Java e tudo seria disponibilizado pela Internet instantaneamente. Foi o estático
HTML dos Browsers que promoveu a rápida disseminação da dinâmica tecnologia Java. A velocidade dos
acontecimentos seguintes foi assustadora, o número de usuários cresceu rapidamente, grandes p layers,
como a IBM anunciaram suporte para a tecnologia Java.
4.2 Uso da linguagem no mercado atualmente (especificação das

tecnologias).
Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais rapidamente do que
qualquer outra linguagem de programação na história da computação. Em 2003 Java atingiu a marca de 4
milhões de desenvolvedores em todo mundo. Java continuou e continua crescendo e hoje é com certeza
um padrão para o mercado oferecendo qualidade, performance e segurança ainda sem nenhum
competidor a altura. Atualmente Java é a escolha para construir sistemas robustos, confiáveis e
distribuídos,rodando desde grandes servidores,por isso tornou -se popular pelo seu uso na Internet e hoje
possui seu ambiente de execução presente em web browsers, mainframes, SOs, celulares, palmtops e
36
cartões inteligentes,entre outros dispositivos.
4.3 Principais características da linguagem de programação java
ORIENTAÇÃO A OBJETOS: Java é uma linguagem orientada a objetos que segue a linha purista
iniciada por Smalltalk que é considerada puramente O.O e que tudo nesta são objetos. Com a exceção dos
tipos primitivos da linguagem (char, int, float, etc.), a maior parte dos elementos de um programa Java
são objetos.
No que rege esse paradigma, o projeto orientado a objetos é uma técnica de programação que se
concentra nos dados (= objetos) e nas interfaces para este objeto. O código é organizado em classes, que
podem estabelecer relacionamentos de herança simples entre si, somente a herança simples é permitida
em Java. Há uma forma de "simular" herança múltipla em Java com o uso de interfaces.
SIMPLICIDADE: Java, é muito parecida com C++, mas muito mais simples. Java não possui
sobrecarga de operadores, structs, unions, aritmética de ponteiros, herança múltipla,arquivos.h, diretivas
de pré-processamento e a memória alocada dinamicamente é gerenciada pela própria linguagem que usa
algoritmos de garbage collection para desalocar regiões de memória que não estão mais em uso. Outro
aspecto da simplicidade do Java é o tamanho pequeno. Um dos objetivos do Java é permitir a
construção de software que possa rodar independentemente em qualquer máquina de pequeno porte. O
tamanho do interpretador básico e do suporte a classes é de cerca de 40K bytes; adicionando as
bibliotecas básicas padrão e o suporte a linhas de execução
(essencialmente um microkenel auto-contido), têm-se outros 175 K.
SEGURA: Java foi elaborada para ser usada em ambientes de rede distribuída, por isso permite a
construção de sistemas l ivres de vírus e intrusões. A presença de coleta automática de lixo, evita erros
comuns que os programadores cometem quando são obrigados a gerenciar diretamente a memória (C,
C++, Pascal).
A eliminação do uso de ponteiros, em favor do uso de vetores, objetos e outras estruturas substitutivas
traz benefícios em termos de segurança. O programador é proibido de obter acesso à memória que não
pertence ao seu programa, além de não ter chances de cometer erros comuns tais como “reference
aliasing” e uso indevid o de aritmética de ponteiros. Estas medidas são particularmente úteis quando
pensarmos em aplicações comerciais desenvolvidas para a internet.
ROBUSTA: Java foi elaborada para a produção de programas que devam ser confiáveis em vários
sentido. Java põe bastante ênfase na verificação
rápida de possíveis problemas, na verificação dinâmica posterior (em tempo de execução), e em eliminar

37
situações propensas a erros. A principal diferença entre Java e C/C++ é que Java possui um modelo de
ponteiros que elimina a possibilidade de sobrescrever a memória e corromper dados.
PROCESSAMENTO DISTRIBUÍDO: A linguagem de programação Java possui uma extensa
biblioteca de rotinas para lidar com protocolos TCP/IP, como HTTP e FTP. As aplicações Java podem
abrir e acessar objetos através da rede via URLs, com a mesma facilidade com que acessa um
sistema de arquivos local.
MULTITHREADING: Múltiplas linhas de execução. Em Java é uma surpresa agradável e fácil.

Linhas de execução em Java podem também beneficiar -se de sistemas multiprocessadores se o sistema
operacional de base o fizer. O lado ruim é que as implementações de linhas de execução nas plataformas
mais importantes diferem radicalmente, e o Java não faz nenhum esforço para ser neutro em relação às
plataformas nesse aspecto. Somente o código para chamar o multhreading permanece o mesmo para todas
as máquinas.
EXCEÇÕES: Todo programador em geral está bastante acostumado com o computador "travando" por
causa de um erro em um programa. Em C++, por exemplo, a simples tentativa de abertura de um arquivo
inexistente pode obrigar ao programador a reiniciar o computador. Programas Java, contudo, não "dão
pau" no computador, já que a máquina virtual Java faz uma verificação em tempo de execução quanto aos
acessos de memória, abertura de arquivos e uma série de eventos que podem gerar uma "travada" em
outras linguagens, mas que geram exceções em programas Java. Em geral, ao escrever programas
Java utilizando-se de herança de classes predefinidas, força -se em geral ao programador escrever
algumas rotinas de tratamento de exceção, um trabalho que, se de início pode parecer forçado, irá poupar
o programador de bastante dor de cabeça no futuro.
GARBAGE COLLECTOR: Em Java, os programadores não necessitam
preocupar-se com o gerenciamento de memória como em C++. Em C++, todo bloco de memória alocado
dinamicamente (com new, malloc ou função similar) deveria ser liberado quando não fosse mais usado
38
(com free, delete e parentes próximos). Isso acarretava diversos problemas mesmo ao programador mais
experiente, que tinha que manter sempre um controle das áreas de memória alocadas para poder liberá -
las em seguida. Java, ao contrário, utiliza-se de um conceito já explorado pela linguagem Smalltalk, que é
o de garbage collection (coleta de lixo). Sua função é a de varrer a memória de tempos em tempos,
liberando
automaticamente os blocos que não estão sendo utilizados. Se por um lado isso pode deixar o aplicativo
um pouco mais lento, por manter uma thread paralela que dura todo o tempo de execução do programa,
evita problemas como referências perdidas e avisos de falta de memória quando sabe-se que há megas e
megas disponíveis na máquina.
COMPILADA E INTERPRETADA: Uma das características de Java que a tornou ideal para seu uso
na elaboração de aplicativos distribuídos foi a sua independência de plataforma. Isso porque o compilador
gera um formato de arquivo de objetos neutro em relação a arquitetura, o código compilado é executável
em vários processadores, desde que haja a presença do sistema em tempo de execução Java. O
compilador Java consegue isso gerando instruções bytecode que não tem nada a ver com uma arquitetura
computacional específica. Ao contrário eles são elaborados para ser de fácil interpretação em qualquer
máquina e de fácil tradução para código de máquina nativo imediatamente.
MÁQUINA VIRTUAL: É uma máquina imaginária que é implementada através de um software
emulador em uma máquina real.

39
A JVM provê especificações de plataforma de hardware na qual se compila todo código de tecnologia
Java. Essas especificações permitem que o software Java seja uma plataforma independente, pois a
compilação é feita por uma máquina genérica conhecida como JVM.
PORTÁVEL: Ao contrário do C e C++ que não existem aspectos da especificação
que sejam dependentes da implementação. Os tamanhos dos tipos de dados primitivos são
especificados,bem como o comportamento da aritmética neles. Por exemplo, em Java um int é
sempre um número inteiro de 32 bits, enquanto que em C/C++, int pode significar um inteiro de 16 bits
ou um inteiro de 32 bits. Com o tamanho fixo para tipos numéricos elimina-se a causa de grandes dores
de cabeça relacionadas à portabilidade. A portabilidade em Java é atingida através da utilização de
bytecodes. Bytecode é um formato de código intermediário entre o código fonte, o texto
que o programador consegue manipular, e o código de máquina, que o computador consegue executar.
Na plataforma Java, o bytecode é interpretado por uma máquina virtual Java. A portabilidade do
código Java é obtida à medida que máquinas virtuais Java estão disponíveis para diferentes plataformas.
Assim, o código Java que foi compilado em uma máquina pode ser executado em qualquer máquina
virtual Java, independentemente de qual seja o sistema operacional ou o processador que executa o
código.

40
JAVA E A INTERNET: Os programas Java que rodam em páginas web são chamados applets.
Para usar applets, você precisa de um navegador web habilitado para Java, o qual executará os bytecodes
para você. Em particular servidores de aplicação podem usar as capacidades de monitoramento da
máquina virtual Java para realizar o equilíbrio automático de carga, controle de conexões a banco de
dados, sincronização de objetos, desligamento e reinicialização seguros, além de outros serviços
necessários para aplicações escaláveis de serviços, mas que são notoriamente difíceis de implementar
corretamente. Em Java, é possível escrever aplicações completas, inclusive acessando bancos de dados
relacionais independentemente do servidor web, bem como é possível implementar os níveis de interface
com o usuário e de lógica do negocio, utilizando um servidor de banco de dados para implementar o nível
de acesso aos dados.
DISTRIBUIÇÃO DA TECNOLOGIA JAVA: O J2SE (Java 2 Standard Edition) ou Java SE é uma

ferramenta de desenvolvimento para a plataforma Java. Ela contém todo o ambiente necessário
para a criação e execução de aplicações Java, incluindo a máquina virtual Java (JVM), o compilador Java,
as APIs do Java e o utras ferramentas utilitárias.
JME, Java Plataforma, Micro Edition (Java ME), ainda conhecida por J2ME, é uma tecnologia que
41
possibilita o desenvolvimento de software para sistemas e aplicações embarcadas, ou seja, toda aquela
que roda em um dispositivo de propósito específico, desempenhando alguma tarefa que seja útil para o
dispositivo. É a plataforma Java para dispositivos compactos, como telemóveis, PDAs, controles remotos,
e outra gama de dispositivos.
Java EE (ou J2EE, ou Java 2 Enterprise Edition, ou em português Java Edição Empresarial) é uma
plataforma de programação de computadores que faz parte da plataforma Java. O JEE (Java Enterprise
Edition) é a plataforma Java voltada para redes, internet, intranets e afins. Assim, ela contém bibliotecas
especialmente desenvolvidas para o acesso a servidores, a sistemas de e-mail, a banco de dados, etc. Por
essas características, o JEE foi desenvolvido para suportar uma grande quantidade de usuários
simultâneos. A plataforma JEE contém uma série de especificaç ões, cada uma com funcionalidades
distintas. Que são:
 JDBC (Java Database Connectivity), utilizado no acesso a banco de dados.
 JSP (Java Server Pages),um tipo de servidor Web. Os servidores web são as aplicações que
permitem a você acessar um site na internet.
 Servlets, para o desenvolvimento de aplicações Web,isto é,esse recurso "estende" o funcionamento
dos servidores web, permitindo a geração de conteúdo dinâmico nos sites.
4.4 Ambientes e ferramentas de desenvolvimento com Java

A tecnologia Java fornece como ambiente de desenvolvimento um grande conjunto de ferramentas
que engloba: um compilador, um interpretador, um gerador de documentação, ferramenta de
empacotamento de classes de arquivos e outros.
INSTALAÇÃO DO JDK OU SDK E JRE E SUAS CONFIGURAÇÕES
A Sun a empresa proprietária do Java que atualmente pertence a empresa (Oracle). Ela
disponibiliza, basicamente, duas versões de sua máquina virtual: o JRE (Java Runtime Environment) e
JDK (Java Development Kit). O JRE contém a máquina virtual que permite rodar programas feitos na
linguagem Java em uma máquina. O JDK, por sua vez,é um pacote para desenvolvedores programarem
suas aplicações em Java, possuindo vários utilitários, inclusive compilador e bibliotecas. Uma das versões
mais usadas do Java foi a 1.4.x, que possuía inclusive um visual um pouco (para ser modesto) rústico.
Mais para frente a Sun lançou a versão 1.5.0, com várias melhorias em termos de programação e um
visual um pouco melhor. Foi lançado em dezembro do de 2006 o Java 1.6.0, conhecido também como
Java 6, que trouxe, finalmente, uma integração total com o desktop em termos visuais, e várias melhorias
também para quem é programador.
42
Mustang é o nome dado para a nova versão 6 de Java, que saiu no final do ano passado. Entre as
novidades mais conhecidas estão o suporte a linguagens de script, melhores ferramentas para o
monitoramento de aplicações Java e mais integração com o sistema operacional. Mas o qual é realmente a
diferença entre o JDK e Java SDK? : O kit de desenvolvimento para Java (Sofware Development Kit).
Trata-se de um conjunto de softwares para programadores em Java que você não precisa instalar se sua
intenção for apenas usar os programas feitos em Java. Para rodar os programas em Java basta
instalar o JRE (Java Runtime Environment).
4.5 Meu primeiro programa em java
Como Java é uma linguagem que é primeiramente compilada e em seguida interpretada. Para
compilar e executar um programa escrito nessa linguagem devemos o primeiro construir o arquivo como
o código fonte, que deve ter como extensão .java. Que no caso do exemplo o arquivo foi chamado de
HelloWorld.java. Em seguida, o código fonte é compilado e um programa fonte em bytecodes
(HelloWorld.class) é gerado. Durante a compilação, há uma checagem de erros do código fonte. O código
fonte em bytecodes só será gerado se nenhum erro tiver sido detectado. Por fim, qualquer dispositivo que
execute Java será capaz de interpretar este novo arquivo fonte e executar a aplicação. Os bytecodes são
lidos e executados (ou seja, interpretados) pela Máquina Virtual Java (JVM – Java Virtual Machine) em
um computador, em um celular, etc., além de serem independentes de plataforma.
A geração dos bytecodes ou, para o exemplo, do arquivo HelloWorld.class é feita a partir da execução do
comando javacHelloWorld.java. Então, o próximo passo é fazer com que a JVM execute o arquivo
HelloWorld.java, através do comando java HelloWorld.class . Dessa maneira, a JVM traduz o código
compilado para uma linguagem que a máquina entenda e o programa é executado, por isto os programas
em Java podem executar em qualquer plataforma de hardware ou software que possua uma versão da
JVM. A Máquina Virtual Java é definida como uma máquina imaginária implementada através da
emulação em um software executado em uma máquina real. Ela possui uma arquitetura que permite
garantir segurança. Quando um programa Java é executado, seus bytecodes são verificados pela JVM
para que estejam de acordo com os seus requisitos de segurança, impedindo a execução de código com
alguma irregularidade. Assim, códigos-fonte com instruções que acessem áreas restritas da memória ou
até mesmo recursos do hardware não são executados pela JVM.

43
A palavra public indica que a classe terá um nível de acesso público, ou seja, que ela será acessível por
qualquer classe. A palavra class indica que uma classe está sendo declarada e seu nome é HelloWorld. A {
delimita o limite inicial da classe.
A palavra public já foi descrita, portanto permite que o método seja acessado publicamente. A palavra
static será descrita posteriormente. O lugar onde fica a palavra void é onde se deve indicar o tipo de
retorno do método. Neste caso, não retorna nenhu m valor, dessa maneira o método é declarado como
void.
O conjunto String[] args presentes entre ( ) são os argumentos do método. Neste exemplo, o método
possui um único argumento (um vetor de Strings denominado args. A { delimita o limite inicial do
método.
A terceira linha consiste no conteúdo do método principal, formado apenas por um comando, ou uma
instrução que é composta de uma ou mais linhas terminadas por ponto e vírgula. Exemplo:
O System.out.println é usado para exibir algo na saída padrão, por padrão, na linha de comando. Será
exibido o que tiver entre (“”), no caso, Hello world. No final deste comando, tem-se um; que o finaliza.
Por fim, há duas “fecha chaves” } } , que delimitam o fim do método e da classe, respectivamente.
Blocos de código: Um bloco é formado por uma ou mais instruções agrupadas entre chaves indicando
que formam uma só unidade. Blocos podem ser organizados em estruturas aninhadas
Indefinidamente. Qualquer quantidade de espaços em branco é permitida. Um exemplo de bloco código
mostrado ao lado ilustra perfeitamente como são organizadas as estruturas de blocos.

44
4.6 Comentários em Java:

Comentários são notas escritas pelo programador para fins de documentação. Estas notas não fazem parte
do programa e não afetam o fluxo de controle . Java suporta três tipos de comentários: comentário de
linha estilo C++,comentário de bloco estilo C e um comentário estilo Javadoc (utilizado compor a
documentação do programa).
Comentário de linha: Comentários com estilo em C++ se iniciam por "//". Todo e qualquer texto
colocado após as // é ignorado pelo compilador e tratado como comentário. Por exemplo:
Comentário de bloco: Comentários com estilo em C, também chamados de comentários multi-linhas, se

iniciam com /* e terminam com */. Todo o texto posto entre os dois delimitadores é tratado como
comentário. Diferente do comentário estilo C++, este pode se expandir para várias linhas. Por exemplo:
Comentário estilo Javadoc: Este comentário é utilizado na geração da documentação em HTML dos
programas escritos em Java. Para se criar um comentário em estilo Javadoc deve se iniciar o comentário
com /** e terminá-lo com */. Assim como os comentários estilo C, este também pode conter várias
linhas. Este comentário também pode conter certas tags que dão mais informações à documentação. Por
exemplo:
4.7 Compilando meu primeiro programa em Java
1°- Passo: Para compilarmos o nosso primeiro programa em Java utilizamos o seguinte comando javac
45
seguindo do nome da classe (ponto).java.
2°- Passo: Para executarmos o nosso primeiro programa em Java utilizamos o seguinte comando Java,
seguido do nome da classe.
Nesse segundo exemplo vamos usar um editor de texto qualquer para editor o código-fonte do nosso
segundo exemplo e vamos compilar usando terminal (Konsole) do sistema operacional.
Compilando nosso 2° exemplo com o comando → javac:
Executando nosso 2° exemplo com o comando → java:
Obs.: Cuidados importantes a serem tomados:

 Se o javac reclamar que não acha a classe HelloWorld.java, é porquê você não está no diretório
correto ou salvou o arquivo em outro lugar.
 Se o javac reclamar de algum erro no fonte, é porque você digitou algo errado. Não troque letras
maiúsculas por minúsculas e vice -versa, em nenhuma parte do código!
 Finalmente, ANTES de chamar o seu instrutor para ele inserir um ; ou fechar uma chave no seu
código, revise mais uma vez o seu código completamente.
DICAS PARA RESOLUÇÃO DE PROBLEMAS EM PROGRAMAS JAVA

46
 Se digitar o programa na mão, certifique-se de prestar atenção as letras maiúsculas e minúsculas.

Em particular um nome de classe por exemplo.
 Se receber uma mensagem como “Bad command or file name” ou “javac command not found”,
volte e verifique novamente a sua instalação, em particular a configuração do caminho de
execução.
 O compilador requer um nome de arquivo (Teste.java) por exemplo. Quando você rodar o
programa, você especifica um nome de classe (Teste) sem a extensão .java nem .class.
 Se o compilador javac relatar um erro “connot read”: “Teste.java” , você deve ve rificar se esse
arquivo está presente no diretório.
 Se houver erros demais em seu programa todas as mensagens de erros voarão pela sua tela muito
rapidamente. O compilador envia as mensagens de erro para a saída padrão, então, é um pouco
complicado capturá -las se elas ocuparem mais espaço do que a janela pode exibir.
4.8 Erros comuns em programas java
ERROS EM JAVA:
Durante o desenvolvimento de programas, é muito comum que ocorram erros, em Java pode ser em dois
domínios: tempo de compilação e tempo de execução.
ERRO EM TEMPO DE COMPILAÇÃO:
 Erros ocorridos durante a fase de compilação ocorrem quando se executa o
javac, e são fáceis de corrigir. Há dois tipos:
 Erros de processamento do arquivo (parsing): ponto e vírgula faltando, parênteses, aspas, chaves
ou colchetes descasados. Identifica apenas o arquivo e a linha onde o erro pode ter iniciado. Um
erro causa vários outros e nem sempre a mensagem é precisa.
 Erros de compilação do código, realizada depois do parsing: além da linha e do arquivo,
identificam a classe e método. Geralmente as mensagens são bastante elucidativas.
ERRO EM TEMPO DE EXECUÇÃO:
Erros que ocorrem durante o tempo de execução (runtime) ocorrem quando se executa o interpretador
java, e são muito mais difíceis de localizar e consertar.
 Exception in thread "main": NoClassDefFoundError: Classe: a classe "Classe" não foi encontrada
no CLASSPATH.
 Exception in thread "main": NoSuchMethodError: main: o sistema tentou chamar main() mas não
o encontrou.
47
 ArrayIndexOutOfBoundsException: programa tento u acessar vetor além dos limites definidos,ou

negativo.
 NullPointerException: referência para objeto é nula,ou variável de um tipo objeto foi declarada
mas não inicializada.
4.9 NetBeans
O termo IDE sigla para (Integrated Development Environment). O NetBeans

I DE é um ambiente de desenvolvimento integrado e está disponível para Windows, Mac, Linux e Solaris.
O projeto NetBeans consiste em um IDE de código-fonte aberto e uma plataforma de aplicações que
permitem que os desenvolvedores criem rapidamente aplicativos web, corporativos, desktop e aplicações
móveis utilizando a plataforma Java,bem como JavaFX,
PHP, JavaScript e Ajax Ruby e Ruby on Rails , Groovy e Grails, e C / C + +. O projeto do NetBeans é
apoiado por uma vibrante comunidade de desenvolvedores e ofe rece uma extensa documentação e
treinamento de recursos, bem como uma diversificada seleção de terceiros plugins.
IDE 6.9 introduz o JavaFX, Compositor uma ferramenta visual para construção de layout visual JavaFX
aplicativos, interface gráfica semelhante ao construtor de GUI Swing para aplicações Java. SE
NetBeans Outros destaques incluem OSGi Plataforma de interoperabilidade para aplicações NetBeans
e apoio para o desenvolvimento de bundles OSGi com Maven, o apoio à JavaFX SDK, Framework Zend
para PHP e Ruby on Rails 3.0, bem como melhorias no editor de Java, Java Debugger problema de
rastreamento, e muito mais. Para baixar o NetBeans acesse o site do link:
http://www.netbeans.org/
4.10 Visão de outras IDEs para o desenvolvimento com Java
IDE ECLIPSE
O Eclipse é uma IDE para o desenvolvimento aplicações Java, ele também pode ser usado para o
desenvolvimento de aplicações utilizando outras linguagens como PHP, C++, etc. O Ambiente de
desenvolvimento multi linguagens de programação cujo projeto é patrocinado pela IBM. É bastante
flexível e integra com vários projetos bastante comuns na comunidade Java tais como cvs
(versionamento), ant(scripts) e junit (testes unitários). Não possui ainda um bom editor visual de interface

48
gráfica. O atual, chamado visual editor (VE) funciona com SWT e Swing mas ainda está na versão 0.5. O
desenvolvimento J2EE é viável com o uso de plugins obtidos de terceiros. Nesta apostila não iremos nos
aprofunda r nessa IDE, mas pode baixar e instalar no seu sistema par criar seus projetos de programação
com Java usando a IDE Eclipse. O Eclipse atualmente encontra-se na versão 3.6 chamada de HELIOS,
para baixá-lo acesse o seguinte link ao lado: http://www.eclipse.org/
IDE BLUEJ
BlueJ é um ambiente de desenvolvimento Java projetado especificamente para o ensino em um nível

introdutório. BlueJ foi projetado e implementado pelas equipes das universidade Monash
University,Melbourne, Australia e The University of Southern Denmark, Odense. Maiores informações
sobre BlueJ estão disponíveis no site oficial (http://www.bluej.org). O BlueJ é um
excelente ambiente para o fim a que se destina: a aprendizagem da progra mação orientada pelos objetos
utilizando a linguagem Java. No entanto e especialmente quando é utilizada uma linguagem muito
popular como a linguagem Java, o desenvolvimento de programas é feito utilizando IDEs muito
mais complexos e sofisticados. Tal é ne cessário para lidar com a complexidade de muitos dos programas
atuais.
Estes atingem frequentemente dezenas de milhares de linhas de código e, em alguns casos, muitas, muitas
mais. Tal implica a utilização de várias ferramentas de auxílio ao desenvolvimento de código. BlueJ
3.0.4,uma versão de manutenção que inclui uma série de correções de erros importantes, está agora
disponível para download.
IDE GEL
É um editor pequeno e rápido.Escrito em Delphi para computadores com Windows. Destaca sintaxe para
java,jsp,xml, html entre outras gramáticas, facilita o gerenciamento de projetos, mantém histórico local de
mudanças, possui suporte a CVS, JUnit e Ant entre outras facilidades. Livre para uso
comercial.Mais informações sobre essa IDE visite o site: http://www.dukeduck.com.br/
IDE JDEVELOPER
Uma das principais opções open source, uma terceira boa opção existe desde que a Oracle tornou seu
49
IDE Jdeveloper totalmente gratuito. Isso devido ao fato de a Oracle tornar open source dois frameworks
de desenvolvimento Java: o mecanismo de
persistência Oracle TopLink (se tornou a base da implementação de referência JPA do Glassfish) e os
componentes JavaServer Faces (JSF) Oracle ADF Faces, parte do Oracle Aplication Development
Framework. São dois ótimos recursos e o seu uso no desenvolvimento está totalmente integrado e
suportado no Oracle JDeveloper.
O Oracle JDeveloper é assim uma opção gratuita abrangente e amadurecida para o desenvolvimento Java
corporativo, principalmente em ambientes onde produtos Oracle já são utilizados (Database Server, BI,
Application Server, Portal). http://www.oracle.com/
4.11 Identificadores e palavras-chaves.
Java é uma linguagem centrada nos pacotes; os desenvolvedores da linguagem assumiram que, para uma
boa organização de nomes, seria fundamental na estrutura de programas em java. Imagine o seguinte
pesadelo: três programadores, na mesma empresa, mas trabalhando em diferentes partes de um projeto,
escrevem cada um uma classe chamada Utilitários. Se essas três classes Utilitários não tiverem sido
declaradas em nenhum pacote explícito, e estiverem no classpath, não seria possível dizer ao compilador
ou à JVM qual das três classes está tentando referenciar.
Identificadores legais são regras que o compilador usa para determinar se um dado nome é legal. Em
Java, os identificadores devem ser compostos apenas por caracteres. Unicode, números, símbolos de
moedas e caracteres de conexão como underscore.
REGRAS VÁLIDAS:
Devem iniciar com uma letra, símbolo comercial cifrão ($) ou underscore (_);
Após o primeiro carácter podem ter qualquer combinação de letras, caracteres e números;
Não possuem limite de tamanho;
Não podem ser palavras reservadas restritas da linguagem;
Em Java os identificadores são case-sensitive isto é, “JAVA” é totalmente diferente de “java” isso porque
o compilador diferencia maiúsculos de minúsculos.
Palavras-chave: São identificadores que, em Java, foram pré -definidas com propósitos específicos.
Não se pode usar esses identificadores como nomes de variáveis, métodos, classes, etc. A seguir, temos a
lista com as palavras -chave em Java.

50
true, false e null não são palavras-chave, porém, são palavras reservadas, e, da mesma
maneira, não é permitido seu uso na atribuição a nomes de variáveis, métodos ou
classes.
TIPOS PRIMITIVOS:
Todo programa de computador deve ser capaz de lidar com dados para conseguir fazer seus processos
como, por exemplo, somar, multiplicar, dividir, etc. Usar atributos é a melhor forma de manipular os
dados. Os tipos de dados são o que definem a quantidade de memória do computador que será utilizado
para guardar tal dado. As variáveis primitivas podem ser declaradas como variáveis de classe (static),
variáveis instâncias, parâmetros de métodos ou variáveis locais. Uma vez declarado, seu tipo primitivo
não pode nunca ser modificado, embora na maioria dos casos seu valor possa se modificar. Java é uma
linguagem fortemente tipada. Isso significa que toda variável deve ter um tipo declarado. Existem oito
tipos primitivos em Java. Quatro deles são do tipo inteiro; dois são do tipo de números de ponto
flutuante; um é o tipo de caracteres char, usado para unidades de código no esquema de codificação
Unicode e um deles é do tipo lógico para valores true/false (verdadeiro/falso).
Uso de valores literais de todos os tipos de dados existentes.
Um literal primitivo é simplesmente a representação do código -fonte dos tipos dados primitivos em
outras palavras um inteiro, um número de ponto flutuante, um booleano ou caracteres que você digite
enquanto escreve um código.

51
LITERAIS INTEIROS:
Há três maneiras de representar números na linguagem Java: decimal (base 10), octal (base 8) e
hexadecimal (base 16).
Literais decimais:
Os inteiros decimais não precisam de explicação, eles são representados da maneira tradicional, sem
prefixo de nenhum tipo, como no exemplo abaixo:
LITERAIS OCTAL:
Os inteiros octais usam somente dígitos de 0 a 7. Em Java, o inteiro é representado na forma
octal com a inclusão de um zero na frente do número, veja o exemplo abaixo:
LITERAIS HEXADECIMAIS:
Os números hexadecimais são construídos com o uso de 16 símbolos distintos. Já que não foram criados
símbolos numéricos unitários para os algarismos que vão de 10 a 15, usamos caracteres alfanuméricos
para representar esses dígitos.
Na Java linguagem todos os literais inteiros (octal, decimal e hexadecimal) são definidos como int (ou
seja inteiros) por padrão, mas também podem ser representados como Long com a inclusão de um sufixo
L ou l depois do número:
Exemplos:
52
Os tipos de dados inteiros que são os mais conhecidos e mais simples. Em Java, os números inteiros são
divididos em quatro tipos: byte, short, int e long.
O tipo byte é o de menor alcance entre os inteiros. Como o próprio nome sugere, ele consome apenas um
byte (8 bits) e pode guardar val ores entre -128 e 127.
O tipo short guarda inteiros de 2 bytes (16 bits) e pode guardar números entre - 32.768 a 32.767.
O tipo int é o tipo de dado mais comum. Ele consome 4 bytes (32 bits) e guarda valores entre -
2.147.483.648 e 2.147.483.647.
Long é o tipo de dado com maior alcance entre os inteiros. Consequentemente,também é o que ocupa
mais espaço (8 bytes ou 64 bits). Tem um grande alcance que fica entre -9,22E+18 (exatos -
9.223.372.036.854.775.808) e 9,22E+18 (exatos 9.223.372.036.854.775.807).
LITERAIS DE PONTO FLUTUANTE:

Os números de ponto flutuante são definidos com um número, um símbolo decimal e os outros números
que representam a fração. Para número decimais fracionários com grande precisão ou valores
extraordinários (geralmente utilizad os em matemática aplicada e complexa como cálculos físicos,
químicos, astrológicos, meteorológicos, etc) utilizamos o tipo de dado double.
53
Double é o tipo de dado mais complexo que existe em Java e o maior valor possível de se
armazenar é 1,797.693.134.862.315.7E+308. Muito mais do que qualquer programador precisa.
Float os literais de ponto flutuante são definidos Double (64 bits) por padrão, portanto, se desejarmos
atribuir um literal de ponto flutuante a uma variável float (32 bits), terá que anexar o sufixo F ou f ao
número. Se não o fizer, o compilador reclamará de uma possível falta de precisão, porque estará tentando
inserir em um container (potencialmente) menos preciso.
LITERAIS BOOLEANOS:
Os literais booleanos são a representação do código -fonte para valores boolean.
Um valor booleano só poderá ser definido como true ou false.
LITERAIS DE CARACTERES:
O literal char é representado por um único caractere entre aspas simples. Eles podem também representar
valores Unicode do caractere, usando a notação Unicode que acrescenta o prefixo \u ao valor, atribuir um
literal numérico, contanto que ele esteja no intervalo de 16 bits sem sinal (65535 ou menor).
Válidos:

54
Inválidos:
LITERAIS PARA STRING:

O literal de string é a representação do código-fonte para o valor de um objeto String. Embora as strings
não sejam primitivas, foram incluídas neste capitulo porque são utilizadas para representar valores
literais, em outras palavras, digitadas diretamente no código. Veremos
mais sobre Strings no capitulo 9.
Exemplo 01:
4.12 Operadores em Java:

Os operadores em Java produzem novos valores a partir de um ou mais valores, os quais são itens á
esquerda ou a direita do operador. O resultado da maioria das operações é um valor boleano ou numérico.
É importante lembrar que na linguagem Java não é possível sobrecarregar os operadores. Um dos
objetivos da linguagem Java é a portabilidade. Por isto muitos processadores da Intel computam x *
y e deixam em registrador de 80 bits, em seguida dividem por z e finalmente truncam o resultado de volta
para 64 bits. Isso pode gerar um resultado mais preciso e pode evitar o estouro de exponentes. Mas o
resultado pode ser diferente de uma computação que usa 64 bits o tempo todo.
Por esse motivo a especificação inicial da máquina virtual Java exigia que todas as computações fossem
truncadas. Não somente as computações truncadas podem causar estouro, como também são, na verdade
mais lentas do que as computações mais precisas, porque a operação de truncamento é demorada. Por
essa razão, a linguagem de programação Java foi atualizada para reconhecer as exigências
conflitantes de desempenho otimizado e reprodutibilidade perfeita.
OPERADORES DE ATRIBUIÇÃO COMPOSTO.
55
Os operadores de atribuição compostos permitem que os programadores preguiçosos economizem algum

trabalho de digitação. Na verdade, existem cerca de 11 operadores de atribuição composto, mas apenas os
4 mais comumente usados são:(+=, -= , *= , /= ).
Exemplo sem usar operador composto:
Exemplo usando operador composto:

56
Nota: Importante lembrar que as duas atribuições mostradas dão no mesmo resultado que as duas
primeiras.
OPERADORES DE COMPARAÇÃO.
 = = igual a.
 ! = diferente de.
Na linguagem Java são utilizados dois operadores de comparação (chamados também de operadores
de igualdade ou desigualdade) que compara dois itens semelhantes e retornam um valor booleano que
representa o que é verdadeiro sobre os dois itens serem iguais.
Exemplo utilizando o operador de igualdade:
Exemplo 01:
Exemplo utilizando o operador de diferente:

57
Exemplo 02:
IGUALDADE DE TIPOS PRIMITIVOS.

A maioria dos programadores Java está familiarizada com a comparação de valores primitivos. Isso
porque cada comparação pode envolver dois valores números (incluindo o tipo char), dois valores
booleanos ou duas variáveis de referências de objetos. O que não pode ser comparado: não é possível
comparar tipos dados incompatíveis, por exemplo, se um tipo booleano é igual a um tipo char. Existem
quatro tipos de itens que podemos testar:
 Números
 Caracteres
 Tipos booleanos primitivos
 Variáveis de referências de objeto; porém é importante lembrar que o operador (==) examina o
valor da variável, ou seja, o padrão de bits.
IGUALDADE DE VARIÁVEIS DE REFERÊNCIAS.
As variáveis de referências podem ser testadas com o operador (==) para sabermos se estão referenciando
um objeto em comum. Mas é muito importante ressaltar que o mesmo operador estará examinando os bits
da variável, portanto com relação as variáveis de referências, se os bits das duas variáveis forem
idênticos, elas estarão referenciando (apontando) o mesmo objeto.

58
Neste exemplo do código acima, foi criado três variáveis de referência a partir da classe Funcionário. As
duas primeiras f1 e f2 são objetos de Funci onário diferentes, que por acaso tem o mesmo valor inicial, a
terceira variável de referência f3, é inicializada para referenciar o mesmo objeto que a variável f1 está
referenciando. O operador == não testará se dois objetos são significativamente equivale ntes, isso porque
ele compara os bits das variáveis, então as referências de memórias das variáveis não soam iguais.
OPERADOR INSTANCEOF:
Permite-nos saber se um objeto pertence a uma classe ou não, ou seja, se o objeto passa no teste é-um.
Este operador é usado somente com variáveis de referências de objetos, e pode ser empregado para
verificar se um objeto é do tipo específico. Quando tratamos de tipos, queremos dizer tipo de interface ou
classe. Em outras palavras, se o objeto referenciado pela variáve l à esquerda do operador passaria no
teste é-um do tipo de interface ou classe do lado direito do operador.
Sintaxe do operador instanceof:

59
Exemplo 01:
Exemplo 02:
Nota: Neste exemplo acontece um erro de compilação; isso porque a variável [ e ] é do tipo String e
não do tipo Funcionário, nesse caso as classes não participam da árvore de herança.
Exemplo 03:
OPERADOR CONCATENAÇÃO DE STRINGS:

O sinal de adição (+) também pode ser usado para concatenar duas strings. Se um dos valores for uma
String, o operador + atuará como um operador de concatenação de Strings. E se os dois valores forem
números, o operando + funcionará como o operador de adição.
Exemplo 01.

60
Resultado do código acima, executado dentro de uma classe que possua o método main().
Exemplo 01. Resultado do código será mostrado ao lado, executado dentro de uma classe que possua o
método main().

61
4.13 Operadores aritméticos.
Eles podem ser usados da maneira padrão. Exemplos:
OPERADOR RESTO (%):

O operador resto da divisão divide o operando a esquerda pelo direito com o resultado sendo o resto dessa
divisão.
OPERADORES DE INCREMENTO E DECREMENTO:

São os operadores que nos permitem incrementar as variáveis em uma unidade. Podem ser usados diante
ou atrás da variável dependendo das necessidades, ou seja, se precisarmos que se incremente ou vice-

62
versa antes de utilizar ou o contrário.
Exemplo 01:
OBS:
R1 temos o resultado = 5, pois nesse caso, primeiro imprimimos o valor original da variável, logo em
seguida incrementamos o valor.
R2 temos o resultado = 6, pois nesse caso, mostramos a variável incrementada pelo comando interior,
porém nesse momento não alteramos o valor da variável.
R3 temos o resultado = 7, pois nesse caso, incrementamos primeiro a variável, depois mostramos a
variável incrementada.
Podemos ter um processo semelhando com o decremento. Exemplo 02:
OBS: A diferença que nesse caso podemos visualizar os resultados, 5,4 e 3;
Exercício resolvido
01 – Crie um programa em Java que decremente uma variável 4 vezes e mostre cada parte do calculo,
sendo que a variável se inicia com valor igual a 5.

63
OPERADORES RELACIONAIS:
Os operadores de relacionais de comparação sempre resulta em um valor booleano (true ou false). Esse
valor booleano é usado com mais frequência em teste if. Java possui quatro operadores de comparação
que podem ser usados para comparar quaisquer valores inteiros, numéricos de pontos flutuantes ou
caracteres.
OPERADORES LÓGICOS.
Expressões lógicas são aquelas que realizam uma operação lógica (ou, e, não, etc...) e retorna
verdadeiro ou falso. A linguagem Java especificam seis operadores lógicos (! , & , | , ^ , && , || ).

64
OS OPERADORES BITWISE :
Os operadores (^ , & , | ) são chamados de operadores de Bitwise. Esses operadores comparam duas
variáveis bit por bit, e retornam uma variável cujos bits foram definidos com base em se as duas variáveis
sendo comparadas tinham bits correspondentes. Eles podem ser: ambos ligados (&), outro ligado (|), ou
exatamente um ligado (^).
OPERADORES LÓGICOS DE ABREVIAÇÃO:

O operador de abreviação (&&) consiste no fato de ele não perder seu tempo avaliações inúteis.O
operador de abreviação (&&) avaliará o lado esquerdo da operação (operando um) e se esse operando
tiver um resultado false, ele não examinará o lado direito da equação(operando dois),já que o operador
saberá que a expressão completa não será true.
AND abreviação (&&)
OR abreviação (||)

65
Exemplo:
OPERADORES LÓGICOS ^ E !:
O operador lógico ^ (ou exclusivo) avalia valores booleanos. O operador ^ relaciona-se com os
operadores de não-abreviação, no sentido de que sempre avalia ambos os valores, o do lado direito e o do
lado esquerdo, em uma expressão. Para uma expressão OU exclusivo (^) ser verdadeira, exatamente um
operando precisa ser true. Exemplo.
 ^ OR exclusivo (xor)
 ! inversão boleana.
Exemplos:
Nota: A expressão acima avalia como false porque tanto o primeiro operando (2<3) quanto o segundo
(4>3) avaliam como true.
Exemplo 01:

66
Exemplo 02:
OPERADORES CONDICIONAIS.
O operador condicional é um operador ternário tem três valores usado para avaliar expressões boleanas de
modo semelhante a instrução IF, exceto por em vez de executar um bloco de código se o resultado do
teste for true, atribuir um valor à variável. Ou seja, objetivo do operador condicional é decidir qual dos
valores atribuir a uma variável. Ele é constituído dos símbolos ? (ponto de interrogação) e : (dois pontos),
os parênteses são opcionais. Veja a sintaxe:
X = (expressão boleana) ? valor a atribuir se true : valor atribuir se false
Exemplo 01:
Exemplo 02:

67
Exemplo 03:
OPERADOR TERNÁRIO
Operador ternário ou operador condicional tem objetivo de atribuir um valor a uma variável de acordo
com o resultado de um teste lógico.
Vejamos a sintaxe:
Teste lógico (?) valor se for verdadeiro (:) valor se for falso.
O teste lógico é qualquer expressão que pode ser avaliado como verdadeiro ou falso
Exemplo 01:
PRECEDÊNCIA DE OPERADORES
A precedência serve para indicar a ordem na qual o compilador interpretará os diferentes tipos de
operadores, para que ele sempre tenha como saída um resultado coerente e não ambíguo.
ordem operador
1 () parênteses
2 ++ pós-incremento e - - pós-decremento
3 ++ pré-incremento e - - pré-decremento
4 ! negação lógica
5 * Multiplicação e / divisão
68
6 % Resto da divisão
7 + soma e - subtração
8 < menor que, <= menor igual, > maior que, >= maior igual
9 == igual e ! = não igual
10 & AND binário
11 | OU binário
12 ^ OU exclusivo binário
13 && AND lógico
14 || OU lógico
15 ?: condicional
16 = atribuição

69
5.0 Controle de fluxo em Java

As estruturas de controle definem a sequência de execução das instruções. Não é possível implementar
um algoritmo que não seja trivial em uma linguagem de programação que não tenha um conjunto mínimo
de estruturas de controle. As estruturas de controle podem ser divididas em seleção, repetição e
sequência. A sequência é simplesmente definida pela execução sequencial dos comandos, de cima para
baixo.
5.1 Utilizar código que use instruções if
A expressão entre parênteses deve ter como resultado um valor booleano true ou false. Normalmente
testará algo para saber se é verdadeiro, seguida executará um bloco de código (uma ou mais instruções) se
o resultado for mesmo verdadeiro e opcional outro bloco de código se não false. Sintaxe da declaração if:
Fluxograma da declaração if:
EXPRESSÕES VÁLIDAS PARA INSTRUÇÕES IF

Exemplo 01:

70
Neste exemplo, ambas as instruções são avaliadas como verdadeira tanto a do lado direito quanto a do
lado esquerdo, pois, o valor da variável x for maior do que o valor da variável y, então o bloco de
instrução é executado, e a mensagem será impressa na saída padrão.
Exemplo 02:
Neste outro exemplo a instrução é avaliada como true, pois, o valor da variável teste é false, mas quando
o fluxo entra no if a variável teste recebe true, l ogo bloco de instrução será executado e resultando
impresso na saída padrão.
EXPRESSÕES VÁLIDAS PARA INSTRUÇÕES IF-ELSE

A declaração if-else é usada quando queremos executar determinado conjunto de instruções se a condição
for verdadeira e outro conjunto se a condição for falsa.
Sintaxe da declaração if-else:
Fluxograma da declaração if – else:

71
Notas: Nestes exemplos a instrução do lado esquerdo é avaliada como verdadeira, pois, o valor da
variável x não é maior do que o valor da variável y e a instrução do lado direito também é avaliada como
verdadeira, pois a variável teste tinha valor inicial „false‟, mas dentro da instrução é atribuído um novo
valor igual a „true‟, logo bloco de instrução tanto da esquerda como o da direita serão executados, atribui
ndo um novo valor para a variável y igual a 25 imprimindo o valor de y na saída padrão.
Exemplo 01:
Notas: Nesses exemplos ambos os códigos do if serão avaliados como verdadeiros, então ele executa a
instrução imprimindo teste 1. Se a instrução if foss e falsa eles executariam imprimindo teste 2,mas no
nosso caso foram verdadeiras.
EXPRESSÕES VÁLIDAS PARA INSTRUÇÕES IF-ELSE-IF.

A declaração else pode conter outra estrutura if -else. Este cascateamento de estruturas permite ter
decisões lógicas muito mai s complexas.
A sintaxe da declaração if-else-if:

72
Podemos ter várias estruturas else-if depois de uma declaração if. A estrutura else é opcional e pode ser
omitida. No exemplo mostrado acima, se a expressão_lógica1 é verdadeira, o programa executa a
instrução1 e salta as outras instruções. Caso contrário, se a expressão_lógica1 é falsa, o fluxo de controle
segue para a análise da expressão_lógica2. Se esta for verdadeira, o programa executa a instrução2 e salta
a instrução3. Caso contrário, se a expressão_ lógica2 é falsa, então a instrução3 é executada.
FLUXOGRAMA DA INSTRUÇÃO IF-ELSE-IF:

73
Exemplo 01:
5.2 Expressões válidas para instruções switch e case.
Sintaxe da declaração switch:
Onde: variável_inteira é uma variável de tipo byte, short, char ou int. valor1, valor2, e assim por diante,
são valores constantes que esta variável pode assumir. Quando a declaração switch é encontrada, o fluxo
de controle avalia inicialmente a variável_inteira e segue para o case que possui o valor igual ao da variá
vel. O programa executa todas as instruções a partir deste ponto, mesmo as do próximo case, até
encontrar uma instrução break, que interromperá a execução do switch.
Se nenhum dos valores case for satisfeito, o bloco default será executado. Este é um bloco opcional. O
bloco default não é obrigatório na declaração switch.
Fluxograma da declaração switch:

74
Exemplo 01:
As constantes CASE são avaliadas de cima para baixo, e a primeira constante CASE
que bater com a expressão SWITCH será o ponto de entrada da execução.
Exemplo 02:
Solução Incorreta.

75
Solução Correta:
Este exemplo é perfeitamente válido para a declaração switch -case, porque mesmo a variável sendo do
tipo String, porém quando entrar na instrução switch, o método invocado pela variável s.length que
retornará um valor inteiro, ou seja o tamanho da string, que no nosso caso é igual a 7.
Exemplo 03:
No exemplo acima, quando fornecido argumento, a aplicação identifica se o primeiro caractere deste é
uma vogal. Se o argumento não for iniciado por uma vogal ocorre à execução da seção default da diretiva
switch. Caso não exista argumentos fornecido o programa imprime uma mensagem correspondente.

76
5.3 Loops e iteradores (usando os loops for, while e do while).
Os comandos de repetição, ou de iteração, executam um comando ou um bloco de comandos várias

vezes. É uma das formas para executar repetidamente um comando.
A outra é a recursão que é a chamada direta ou indireta de um método durante a execução do próprio
método. Em Java existem três formas de comandos de repetição: o while; o do-while; e o for.
Sintaxe: loop while Fluxograma: loop while
A declaração while executa repetidas vezes um bloco de instruções enquanto uma determinada condição
lógica for verdadeira.
Exemplo 01:
Como em todos os loops a expressão (teste) terá que resultar em um valor booleano. O corpo de loop
while só será executado se a expressão (também conhecida como condição) resultar em um valor true
(verdadeiro ). Uma vez que entramos no loop, seu conteúdo será repetido até que a condição não possa
mais ser atendida e seja avaliada como false (falsa), encerrando o loop.
Exemplo 02:

77
Neste exemplo a variável x é inicializada com 0 ao entrar no loop a condição é verificada como sendo
verdadeira, isso porque 0 é menor do que 5,então o bloco de código é executado, imprimindo na tela a
string x e o valor da variável x que no caso é 0,depois a execução do código passa para a próxima linha
que é o incremento da variável x, passando a valer 1. Agora a execução volta ao inicio do loop para
verificar novamente a condição e assim por diante até que a condição seja avaliada como falsa.
LOOP DO WHILE:
A declaração do-while é similar ao while. As instruções dentro do laço do -while serão executadas pelo
menos uma vez. Inicialmente, as instruções dentro do laço do - while são executadas. Então, a condição
na expressão lógica é avaliada. Se for verdadeira, as instruções dentro do laço do-while serão executadas
novamente.
Exemplo 01:
Neste exemplo a variável x é inicializada com 0, o bloco de código é executado pelo menos uma vez
antes que a condição seja verificada. Após a condição ser avaliada como verdadeira, a variável será
incrementada em 1 e a execução do código volta para o inicio do bloco e isso se repetirá até que a
condição seja avaliada como falsa.
LOOP FOR:

78
A declaração for, como nas declarações anteriores, permite a execução do mesmo bloco de código uma
quantidade determinada de vezes.
Sintaxe: do loop for:
Fluxograma: loop For.
Exemplo 01:

79
5.4 Loop for aprimorado (para arrays).
O comando FOREACH é utilizado quando você quantas vezes precisa fazer a interação. Ele é composto
por três expressões, sendo elas: a) Declaração e inicialização, b) Expressão condicional e c) Expressão de
interação. Exemplo 01:
Exemplo 02:
Nota: A saída dos exemplos anteriores, depois de compilado e executado, deverá ser uma exibição dos
números inteiros do arranjo com nome “semana”. Esta estrutura otimiza a interação no arranjo ou coleção
passada para a expressão podendo ser efetuada a navegação sem a necessidade de ín dices ou interadores.

80
5.5 Uso de break, continue e return.
BREAK:
A instrução break fará com que o programa encerre a execução do loop atual e inicie o processamento na
linha de código posterior ao bloco.,isso porque este comando serve para interromper a sequência de
execução dos comando e sair do comando switch. Isto não acontece apenas no comando switch. Toda vez
que um break é encontrado, o fluxo de execução “salta” para fora do bloco onde está contido o break,
sendo retomado no comando após o bloco.
É a declaração de desvio usada para sair de um laço antes do normal. O tipo determina para onde é
transferido o controle. O break transfere o controle para o final de uma construção de laço (for, do, while
ou switch). O laço vai encerrar independentemente de seu valor de comparação e a declaração após o laço
será executada. Exemplo:
Nota: Vamos analisar este exemplo acima que tem como resultado a impressão de todos os números cuja
o módulo da divisão por 10 seja igual a 0. Daí o resultado é o mostrado abaixo:
[ i = 100, i = 90, i= 80, i = 70, i= 60, i = 50, i = 40, i= 30, i = 20, i = 10 ]
Exemplo 02:
Agora vamos analisar o exemplo 02, que mostra o mesmo programa com uma pequena diferença que é a
inclusão do comando break depois do comando System.out.println();

81
Nota: Depois de analisarmos chegamos a seguinte conclusão: Este comando interrompe a execução do
loop satisfazendo a condição no bloco if. Então o resultado é a impressão de apenas o primeiro que
satisfaz a condição,que no nosso caso é o 100.
[ i = 100]
Continue:
A instrução continue fará com que somente a iteração atual do loop seja encerrada e que a próxima
iteração do mesmo loop seja iniciada deste que for atendida. Quando usar uma instrução continue em um
loop for, você terá que considerar seus efeitos na iteração do loop. A declaração continue faz com que a
execução do programa volte imediatamente para o início do laço, porém para a próxima interação. O
continue faz o interpretador pular para a próxima iteração e obriga -o a testar a condição. Exemplo:
A pergunta é: Esse é um loop infinito? A resposta é não. Quando a instrução continue for atingida, a
expressão de iteração ainda será executada! Ela será exatamente como se a iteração atual terminasse de
maneira natural. Portanto, no exemplo anterior, ainda aumentará o valor antes da condição (i < 10) ser
verificada novamente. Mas geralmente a instrução continue é usada dentro de um teste if como segue
abaixo:

82
Nota: Estes dois comandos também podem ser usados como instruções rotuladas. As instruções rotuladas
estão além do escopo do nosso curso, mas, embora muitas instruções em Java possam ser rotuladas, é
mais comum usar rótulos com instruções loop tais como for e while, em conjunto com instruções break
e continue. Uma instrução de rótulo deve ser colocada antes da instrução sendo rotulada, e consiste de um
identificador válido que termina com dois pontos (:). As instruções rotuladas serão necessárias somente
nas situações em que você tiver um loop aninhado e precisa indicar qual quer encerrar ou a partir do qual
deseja continuar a próxima iteração.
Return:
A declaração return é utilizada para sair de um método. O fluxo de controle retorna para a declaração que
segue a chamada do método original. A declaração de retorno possui dois modos: o que retorna um valor
e o que não retorna nada.
Exemplo:

83
6.0 Tipos de Variáveis, Constantes e Casting
6.1 O que é uma variável:

Variável: É um espaço na memória usado para
armazenar o estado de um objeto. Uma variável d eve ter um nome e um
tipo. O tipo da variável indica o tipo de dado que ela pode conter. O nome
das variáveis deve seguir as mesmas regras de nomenclatura que os
identificadores.
TIPOS DE VARIÁVEIS:
Variáveis de instância: Estas variáveis são não estáticas, ou seja, declaradas sem o modificador static.
Variáveis de instância são assim chamadas porque seus valores são únicos para cada instância da classe.
Assim, as variáveis podem armazenar valores diferentes para cada cópia de objetos da classe.
Variáveis de classes: Estas variáveis são declaradas com o modificador static. Isso informa ao
compilador que há exatamente uma única cópia desta variável, independente do número de instâncias da
classe.
Variáveis locais: São usadas para armazenar o estado temporário de um método. Variáveis locais são
acessíveis somente dentro do método em que são declaradas, e automaticamente abandonadas na saída do
método.
Parâmetros: São os parâmetros de métodos. Tais variáveis são acessíveis somente ao código no corpo do
método.
Exemplo de variáveis locais:
Na linguagem de programação Java não é permitido o uso de variáveis indefinidas. Variáveis

84
definidas dentro do método são chamadas de variáveis locais, temporárias ou estáticas e devem ser
inicializadas antes do uso. Vejamos a tabela abaixo com os seguintes valores iniciais.
Exemplo 02:
Atribuir um valor a uma variável parece bem simples; simplesmente insira o valor á direita do sinal (=)
para atribuí-lo á variável que estará à esquerda.
6.2 Variáveis estáticas:
É um membro que pertence a classe, uma variável estática é compartilhada por todas as instâncias de
classe, por que isto é apenas uma cópia da variável estática é mantida e somente a própria classe é
suficiente para acessar a variável marcada como estática.
Exemplo 01:
Exemplo 02:
Exemplo 03:
Neste exemplo vamos mostrar através de um programa como usar as variáveis estáticas.

85
6.3 Constantes
O valor de uma variável pode ser alterado durante a execução do programa. Mas, o valor de uma
constante não é alterado jamais. Por padrão, recomendamos que criem constantes sempre com letras
maiúsculas por seguirem as normas da SUN, as constantes trazem algumas vantagens, entre elas o fato de
que nomes descritivos para constantes podem tornar o programa mais fácil de ser lido.
Sintaxe:
final static tipo_de_dado IDENTIFICADOR = valor;
Exemplo 01:

86
6.4 Conversão ou Cast (explícita e implícita das variáveis de tipos

primitivos).
A conversão permitirá que sejam transformados valores primitivos de um tipo em outro. As conversões
podem ser implícitas ou explícitas das variáveis de tipos primitivos. Uma conversão implícita ocorre
quando fazemos uma transformação que envolve ampliação. Em outras palavras, quando inserimos um
item menor (exemplo, um tipo byte) em um container maior (como um tipo int). A transformação valor
maior em um container menor é conhecida como compactação e requer uma conversão explícita, em que
será informado ao compilador que conhece o perigo e aceita toda a responsabilidade. O Jav a converte
automaticamente valores de um tipo numérico para outro tipo maior. Vejamos algumas conversões
válidas em Java.
Utilizamos o casting para converter um objeto ou uma variável de um tipo primitivo para outra de um
tipo também primitivo. Podemos co nverter um double em um int, ou uma subclasse em uma superclasse.
A regra fundamental para o cast é: o casting não modifica o objeto ou valor que está sendo moldado;
porém, o receptor do cast constitui um novo objeto ou um novo tipo. O casting de dados primitivos ocorre
com bastante frequência. A maneira pelo qual o casting age depende da precisão dos dados envolvidos.
Por sua vez, a precisão depende da quantidade de informações que um tipo pode conter; assim, um tipo
de ponto flutuante double tem maior precisão que um float, pois o primeiro é um tipo de 64 bits e o
segundo, de 32 bits.
 Um byte pode ser convertido em um short, int, long, float ou double
 Um short pode ser convertido em um int, long, float ou double
 Um char pode ser convertido em um int, long, float ou double
 Um int pode ser convertido em um long, float ou double

87
 Um long pode ser convertido em um float ou double

 Um float pode ser convertido em um double
Sempre que houver uma transferência de dados de um tipo menos preciso para um mais preciso, o casting
explícito não é obrigatório.
REGRAS PARA CASTING:

Já a transferência de dados de um tipo mais preciso para um menos preciso requer um casting explícito.
Isso ocorre porque pode haver perda de dados durante a moldagem. Java pretende alertar o programador
do possível perigo de uma conversão desse tipo:
Exemplo 01:
Exemplo 02:
Exemplo 03:

88
Exemplo 04:
Exemplo 05:
O Java não faz automaticamente o “downcast”.
O casting entre objetos requer um pouco mais de cuidado. Veremos no decorrer da apostila como fazer o
casting de objetos.
6.5 Atribuindo uma variável de referência à outra.
As variáveis de referências são usadas para se referir (ou acessar) um objeto. Uma variável de referência
é declarada como sendo de um tipo específico, e esse tipo não pode nunca ser modificado. Uma variável
de pode ser usada para referir -se a qualquer objeto do tipo declarado, ou de um subtipo do tipo declarado
(um compatível). Variáveis de referência podem ser
declaradas como variáveis estáticas, variáveis de instâncias, parâmetros de métodos ou variáveis locais.
89
ESCOPO DE VARIÁVEIS.
Depois que declarou e inicializou uma variável, uma questão natural e muito importante é por quanto
tempo essa variável vai existir? Essa é uma pergunta que se refere ao escopo das variáveis em Java. O
escopo define onde uma variável é acessível durante a execução de um programa e quando a variável é
criada e destruída. A localização de uma variável dentro do programa estabelece seu escopo. Existem
quatro categorias de escopo de variáveis na linguagem Java, são elas:
Variáveis de instâncias de tipos primitivos.
As variáveis de instâncias são definidas dentro da classe, mas fora de qualquer método, e só são
inicializadas quando a classe é instanciada. As variáveis de instâncias são os campos que pertencem a
cada objeto único.
Exemplos:
Ou,

90
7.0 POO com Java
7.1 Introdução
Programação Orientada a Objetos se constitui em um conjunto de regras de programação. Estudamos
todos os processos na mesma classe. Porém sem saber estávamos usando algumas regras de POO
(Programação Orientada a Objetos) como, por exemplo, usando a classe “System” ou “JOptionPane”.
Essas classes não foram criadas por nós, porém elas foram reaproveitadas em nosso código com objetivo
de resolver os nossos algoritmos. Vamos fazer uma comparação com o dia - a - dia para entendermos
melhor.
Imagine que você trabalha com digitação de textos. Você não precisa saber como o computador foi
criado, nem como o Software que usa para digitar o texto foi desenvolvido. O seu objetivo é usar desses
recursos e criar um novo produto final. Um relatório de texto.

91
A Programação orientada a objeto é uma metodologia que os programadores utilizam com objetivo de
atingir alguns requisitos importantes na construção de um bom programa como:
 Organizar o código: Com o nosso código dividido, podemos facilmente dar manutenção ou
encontrar algum erro mais fa cilidade.
 Reutilização do código: Não precisamos reescrever todo o código, quando necessitamos dele
novamente.
 Manter Padrões: Utilização de um mesmo padrão conceitual durante todo o processo de criação
do código.
Até o final do curso iremos aprender e tra balhar nessa metodologia. Então, bastante atenção nesse e nos
próximos capítulos.
Classe, Atributos e Métodos.
Como estamos trabalhando com POO (Programação Orientada a Objetos), o nosso objetivo final é
construir um Objeto que tenha suas características. Um Objeto é criado a partir de uma “Classe”. Ela irá
servir como modelo para criação do Objeto. Vamos fazer uma comparação com o dia- a -dia para
entendermos melhor.
Um prédio não é construído de qualquer forma, o pedreiro irá construir o prédio de acordo
com as instruções da planta. Tamanho do banheiro, quantos quartos, porta de entrada. A
planta do prédio seria uma “Classe” ele serve como referencia na construção do prédio que é
um “Objeto”.
Iremos aprender como criar uma “Classe”, ou seja, referencia para futuros “Objetos”. Imagine que
queremos criar um “Pessoa”. Para poder criar uma “Pessoa” teremos antes que responder duas perguntas
básicas.

92
O que poderei
ter? O que poderei
fazer?
 Anote tudo que uma pessoa pode ter, como nome, data de nascimento, RG, CPF, etc . Para a
resposta da primeira pergunta, nós temos o que chamamos de “ Atributos da classe Pessoa”
 Anote Tudo que uma pessoa pode fazer, ou seja, suas ações, como acordar, dormir, falar o seu
nome, etc. Para a resposta da segunda pergunta nós temos o que chamamos de “Métodos da classe
Pessoa”
Com o conceito de Classe, atributos e métodos. Podemos agora criar uma classe em código Java, veja no
próximo tópico como iremos criá-la.
7.2 Construindo uma Classe.

Para criar uma classe, clicaremos com o botão direito do mouse no pacote do Projeto > novo > Classe
Java.
Agora construímos a nossa classe, mas o que significa este “public” antes dos atributos e métodos e o que

93
significa o “void”? Para entender melhor, temos que aprender sobre “Encapsulamento” e “tipo de retorno
de dados”. Assunto que iremos ver no próximo tópico.
7.3 Encapsulamento.
Encapsulamento é uma forma de proteção do nosso código, existem informações que queremos que
outras classes vejam e outras não. Imagine a sua conta de e-mail. A conta do seu usuário poderá ser vista
por outras pessoas, pois ele irá identificar o seu e-mail dos demais, porém a sua senha é algo “privado”
onde só você poderá ter acesso a ela. Da mesma forma que queremos mostrar ou proteger os nossos
dados, uma classe também tem as mesmas necessidades e podemos defini-las através do encapsulamento.
 public - ou publico, qualquer classe pode ter acesso)
 private - ou privado, apenas os métodos da própria classe pode manipular o atributo)
 protected - ou protegido, pode ser acessado apenas pela própria classe ou pelas suas subclasses).
Assim podemos alterar o “public” da nossa classe por outro valor de encapsulamento, dependendo da
necessidade de proteção dos nossos atributos ou métodos. Por boas práticas de programação, os atrib utos
da nossa classe Pessoa estarão como “private”.
7.4 Retorno
Os métodos podem realizar uma ação interna e podem influenciar em outros métodos através do seu
Retorno. Ele pode representar os tipos primitivos de dados que conhecemos como: int, string, double,
float, chat, boolean por exemplo, ou pode retornar vazio, simbolizado por “void”. Os métodos que tiver
retorno deverá ter dentro do seu corpo um “return” que irá representar o resultado final da minha
operação.
Veja o exemplo abaixo:
Neste exemplo alteramos o método “falarNome” da classe pessoa. O tipo de retorno desse método é
String. Então além da classe imprimir a frase, ele deverá guardar a String em uma variável chamada
“minhaFrase” e retornar ela para ser usada em outras classes na linha 23.
Construtores, métodos seteres e geteres

94
CONSTRUTORES
São métodos especiais, que são acionados no momento da construção da classe, ela deverá ter o mesmo
nome da Classe criada. Imagine que para que uma pessoa possa existir, ele precise inicialmente de um
nome e data de nascimento. Então podemos construir o nosso construtor da seguinte forma:
Nesse código o nosso construtor é responsável por alimentar os atributos nome e data de nascimento da
pessoa. também garantimos que ao momento da construção do objeto, uma “Pessoa” não poderá existir se
não tiver um nome e uma data de nascimento.
Mas como eu poderei alterar o meu CPF, RG, e como poderei mostrar esses valores de atributos? Assunto
que veremos no próximo tópico.
MÉTODOS SETERES E GETERES

Os métodos nomeados como “set” e “get” são responsáveis respectivamente por alterar um atributo e
mostrar um atributo da minha classe. Para que o NetBeans possa gerar esse código, iremos digitar: ALT+
INSERT > INSERIR CÓDIGO e marcar os atributos, “nome”, “cpf”, “rg”.
Como eu poderei usar o meu construtor, meus métodos do tipo “set” e “get”?
Este assunto veremos no próximo tópico.
7.5 Estanciando (Construindo um Objeto)

Agora estamos prontos para construir o nosso objeto usando a nossa classe “Pessoa” como referencia.
Então, iremos voltar à classe que tenha o método main e realizar a seguinte operação:

95
Agora estou estanciando o meu objeto e de acordo com meu construtor, eu preciso obrigatoriamente de
um nome = “Fabrício” e uma data de nascimento = “17/02/87” todos eles do tipo String. Vamos agora
usar os métodos da nossa classe criada.
Dessa forma podemos modificar e acessar qualquer variável dependendo das nossas necessidades. Todas
as informações do “Fabrício” estão dentro de uma variável do tipo “Pessoa” chamada de “x”. Se eu quiser
criar uma nova pessoa, posso chamá -la de qualquer outro valor.
7.6 Variáveis Estáticas

Variáveis estáticas são valores que se for alterado em um objeto de uma determinada classe todos os
objetos da estanciados da mesma classe, automaticamente terá o mesmo valor Ele normalmente é usado
quando todas as classes tem algo em comum. Imagine a seguinte situação.
A Classe “Pessoa” terá um atributo chamado: ondeVivo = “Planeta Terra”
Todas as pessoas moram em um planeta que conhecemos por “Planeta Terra”. Porém pesquisas mais
recentes mostram que o nome do nosso planeta deveria ser chamado de “Planeta Água”, pois nele
encontra-se mais água do que a terra.
Se tivermos 300 objetos estanciados do tipo pessoa, como alterar ondeVivo = “Planeta Água” em todos
os objetos em uma única instrução sem precisar percorrer todos eles?
Basta criar uma variável estática no atributo “ondeVivo”, assim se alteramos em 1 dos objetos essa
variável, todas elas sofrerão a mesma alteração. Veja como criá -lo:

96
Concluímos então que as variáveis estáticas não pertencem especificamente a nenhuma instancia de
objeto e sim uma referencia da classe. O que explica a substituição do termo “this” para o nome da classe
que contém a variável estática, no exemplo acima alteramos o termo “this” no método setOndeVivo pelo
nome da classe que contém a variável estática (Pessoa).
7.7 Métodos Estáticos

Os Métodos Estáticos se caracterizam por ser um referencia de método da Classe, sem a necessidade de
instanciarmos um objeto para utilizá -lo. Se quisermos, por exemplo, alertar ou mostrar o habitat das
pessoas sem precisar construir um objeto, podemos realizar essa ação apenas adicionando a palavra
reservada static nos métodos, dessa forma:
Obs.: Métodos estáticos aceitam apenas variáveis estáticas.

Para que possamos utilizar os métodos estáticos precisamos inserir o nome da classe com o método
estático criado.

97
8.0 Herança e Interface
8.1 Introdução
Estudamos como estruturar as nossas classes, agora precisamos gerar uma interação entre classes criadas.
Para isso no conceito de POO também temos que saber Interface e herança. Iremos aprender cada uma
delas, seu conceito e como implementá-las.
8.2 Herança
É fundamental para Java e outras linguagens de programação orientadas a objetos, o conceito de

herança, que permite ao código definido em uma classe ser reutilizado em outras classes.
Sintaxe de herança em Java:
class NomeDaClasseASerCriada extends NomeDaClasseASerHerdada
Em Java, pode ser definida uma superclasse geral (mais abstrata), e depois estendê-la com
subclasses mais específicas. A superclasse não sabe nada sobre as classes que herdam dela, mas todas as
subclasses precisam declarar explicitamente a relação de herança. Uma superclasse recebe
automaticamente as variáveis de instâncias acessíveis e os métodos definidos pela superclasse, mas é

98
também livre para substituir métodos da superclasse para definir comportamento mais específico. Os
objetos de uma mesma classe podem tirar proveito de relações de herança, onde objetos recém-criados
absorvem características de outros já existentes e adicionam -se novas características.
8.3 Object: A superclasse cósmica do Java
A class Object: A classe Object é o último ancestral – toda classe em Java estende de Object.
Entretanto, nunca será preciso gerar sua herança diretamente:
A superclasse terminal Object é automaticamente inclusa se nenhuma superclasse for mencionada
explicitamente. Pelo fato de todas as classes em Java estenderem Object, é importante familiarizar -
se com os serviços fornecidos pela classe Object. Remeteremos ao leitor a pesquisarem em artigos na
internet ou até mesmo ver a documentação on-line que lista os vários métodos da classe Object, mas que
só aparecem quando lidamos com threads (linhas de execução). Você pode usar variáveis do tipo Object
para referir-se a objetos de qualquer tipo.
É claro que uma variável do tipo Object somente será útil como um marcador genérico para valores
arbitrários. Para fazer qualquer coisa específica com o valor, você precisa ter algum conhecimento sobre
o tipo original e, então, aplicar uma conversão: Em Java, somente os tipos primitivos (números,
caracteres e valores lógicos) não são objetos. Todos os tipos de arrays, independentemente de serem
arrays de objetos ou arrays de tipos primitivos, são tipos de classes que estendem a classe Object.
Super: A palavra super seguida imediatamente de parênteses chama o construtor da superclasse de
mesma assinatura, deve ser a primeira instrução dentro de um construtor da subclasse.
Super-classe: É uma classe da qual se herda outras classes. A cláusula opcional estende em uma
declaração de classe especifica a superclasse diretamente da classe atual. Uma classe é dito ser uma
subclasse direta da classe, que se estende. A superclasse direta é a classe a partir de cuja aplicação à
99
implementação da classe atual é derivada. A cláusula extends não deve aparecer na definição da classe
java.lang.Object,pois é primordial a classe e não tem nenhuma superclasse direta. Se a declaração de
classe para qualquer outra classe não tem nenhuma cláusula extends, então a classe tem a classe
java.lang.Object como implícita superclasse direta.
Sub-classes: É uma classe que herda de uma classe ou de uma interface. Uma subclasse herda estado e
comportamento de todos os seus antepassados. A superclasse o termo refere-se ancestral direto de uma
classe, assim como todas as suas classes ascendentes. Essa hierarquia de classes segue uma apresentação
na forma de árvore, em que a raiz é a superclasse de todo o sistema. Cada nível abaixo dessa superclasse
do sistema acrescenta funções específicas.
Exemplo 01: Neste exemplo vamos mostrar como proceder com esse poderoso recurso do Java o qual
chamamos de herança simples.
Código da superclasse Conta.
Código da subclasse CPoupanca que estende da superclasse Conta.

100
Código da subclasse CEspecial que estende da superclasse Conta.

101
Diagrama de classes representando a herança entre as classes citadas acima.
Nota: Java permite que uma classe herde apenas as características de uma única classe, ou seja, não
pode haver heranças múltiplas. Porém, é permitido heranças em cadeias, por exemplo: se a classe
Mamífero herda a classe Animal, quando fizermos a classe Cachorro herdar a classe Mamífero, a classe
Cachorro também herdará as características da classe Animal.
Como estamos tratando de herança de classes, toda classe tem seu método construtor. Portanto, se
estamos trabalhando com duas classes, temos dois métodos construtores. Para acessarmos o método
construtor da classe que está sendo herdada usamos o super().

102
Exemplo 02:
Para demonstrar como definir o relacionamento de herança, considera-se o contexto de ter que
desenvolver um programa que simule o comportamento de vários tipos de animais como mostrado na
figura ao lado em um determinado ambiente.
Inicialmente, apenas um grupo de animais estará presente neste ambiente e cada animal deve ser
representado por um objeto. Além disso, os animais movem -se no ambiente ao seu modo e podem fazer
um conjunto de coisas. O programa deverá prever que novos tipos de animais poderão ser incluídos no
ambiente.
O primeiro passo é observar cada animal e definir o que cada objeto do tipo animal tem em comum no
que diz respeito aos atributos e comportamentos (métodos). Deve-se definir também como os tipos de
animais se relacionam. Inicialmente, o programa deve simular o comportamento dos animais ilustrados
na fi gura, ou seja, de um leão, de um lobo, de um gato, de um hipopótamo, de um tigre e de um cachorro.
O segundo passo consiste em projetar a superclasse, ou seja, a classe que representa o estado e o
comportamento em comum a todos os animais. Para este exemplo, como todos os objetos são animais, a
superclasse foi denominada como Animal e as variáveis e métodos em comuns a todos os animais foram
atribuídos a ela, como ilustrado na Figura. Neste exemplo, cinco variáveis foram definidas: (o tipo de
comida que o animal come), (o nível de fome do animal), (representação da altura e largura do espaço
que o animal vagará ao seu redor) e (as coordenadas X e Y do animal no espaço). Além disso, quatro
métodos foram definidos para definir o comportamento dos animais: (comportamento do animal ao fazer
algum ruído), (comportamento 57 do animal ao comer), (comportamento do animal dormindo) e
(comportamento do animal quando não está nem dormindo nem comendo, provavelmente vagueando no
ambiente).
O terceiro passo é o de decidir se alguma subclasse precisa de comportamentos (métodos) específicos ao
seu tipo de subclasse. Analisando a classe Animal, pode -se extrair que os métodos devem ter
implementações diferentes em cada classe de animais, afinal, cada tipo de animal tem comportamento

103
distinto ao comer e fazer ruídos. Assim, esses métodos da superclasse devem ser sobrescritos nas
subclasses, ou seja, redefinidos. Os métodos não foram escolhidos para serem redefinidos por achar que
esses comportamentos podem ser generalizados a todos os tipos de animais.
CONSTRUTORES DA SUBCLASSE
Os construtores da superclasse não são herdados pela subclasse, logo, esta deverá ter seus próprios
construtores para inicializar seus atributos. Todavia, ao instanciar um objeto da subclasse, devemos
inicializar aqueles atributos que ela está herdando, e o fazemos chamando algum construtor da
superclasse, usando a chamada super(...).
8.3.1 Classe Abstrata

Para entender o conceito de herança, precisamos primeiro entender No Português, a palavra “Abstrata”
refere-se a algo que não existe fisicamente, então se convertermos essa expressão em Java podemos dizer
que Classe Abstrata é uma classe que não pode ser um Objeto. Assim ela precisará ser herdada ou
implementada, no próximo tópico iremos ver como funciona em um exemplo de código.
Imagine que você tenha uma classe Carros que tenha métodos genéricos comuns a todos os veículos. Mas
você não quer que alguém de fato crie um objeto carro genérico, abstrato. Como se inicializaria o seu
estado? De que cor ele seria? Quantos assentos? Ou, mais importante, de que forma ele se comportaria?
Em outras palavras, como os métodos seriam implementados? Temos certeza de que o dono de uma
BMW lhe diria que o carro dele é capaz de fazer coisas que o GOL apenas sonha em fazer.
A implementação pode ser dessa forma mostrada acima, como também pode ser como segue no exemplo
abaixo:

104
Dessa forma podemos dizer que “MeuCarro” que poderá ser um Objeto, herda de “Carro” que é uma
classe abstrata.

105
Na Classe que contém o método Main, nós temos:

106
8.4 Interface
Interface é uma espécie de superclasse 100% abstrata que define os métodos que uma subclasse deve
suportar, mas não como esse suporte deve ser implementado. Isso porque ao criar uma interface, estará
definindo um contrato com o que a classe pode fazer, sem mencionar nada sobre como o fará. Uma
interface é um contrato. Qualquer tipo de classe (concreta) e de qualquer árvore de herança pode
implementar uma interface.
Exemplo 01:
Exemplo 02:
Exemplo 03:

107
Regras para as interfaces:

 Uma interface em Java é uma coleção de métodos abstratos que pode ser implementada por
uma classe.
 Uma interface na pode implementar outra interface ou classe.
 Os tipos de interface podem ser usados polimorficamente
 Os métodos de uma interface não devem ser estáticos.
 Uma interface deve ser declarada com a palavra -chave interface.
 Todos os métodos de uma interface são implicitamente public e abstract. As interfaces só podem
ser declaradas. Uma interface pode estender uma ou mais interfaces diferentes.
Todas as variáveis definidas em uma interface devem ser public, static e final.
As interfaces só podem ser declarar constantes e não variáveis de instância.

108
9.0 Herança (Polimorfismo)
9.1 Introdução
Neste capitulo veremos como funciona a interação com classes em Polimorfismo. Usamos esse recurso
quando queremos modificar métodos herdados para isso temos que aprender o conceito e prática de
sobrecarga e sobrescrita. Veremos estes assuntos no próximo tópico.
Sobrecarga
Usamos sobrecarregar de métodos quando temos um determinado método com o mesmo nome, porém
com assinaturas diferentes, sou seja, parâmetros diferentes, dessa forma quando usamos um determinado
método com sobrecarga podemos escolher qual método sobrecarregado será usado de acordo com o nú
mero e tipo de dados dos parâmetros oferecidos. Veja um exemplo abaixo:
Na Classe animal criamos dois métodos chamados comer, o método que não contém nenhum parâmetro,
o animal apenas mostra a ação de comer, estado da carne. O nosso segundo método, também se chama
comer, porém ele tem um assinatura diferente, ele recebe como parâmetro um valor boleano que se refere
ao estado da carne, dessa forma o animal pode simplesmente comer ou verificar o tipo de alimento antes
de se alimentar.
9.2 SobreEscrita
Usamos sobrescrita de métodos quando temos que modificar um método herdado da classe pai, para
sobrescrever os métodos teremos que criar o mesmo método herdado na classe filha com o nome
assinaturas igual. Levando em consideração a classe Animal criada no tópico anterior, veja no exemplo
abaixo
109
No exemplo anterior, o cachorro já herda o método comer, porém o animal come qualquer alimento, este
nosso cachorro não comer qualquer alimento, ele só come ração. O termo “@Override” no exemplo, não
é obrigatório, apenas para avisar a IDE que este é um método de sobrescrita.
Polimorfismo
Podemos dizer que polimorfismo é quanto temos métodos de sobrescritas distintos entre classes filhas
que referencia um mesmo Pai.
Veja o exemplo abaixo.
Note as roupas que eles usam. A pessoa por padrão tem um estilo de roupa, porém dependendo da
situação, temos que usar roupas específicas para cada situação. Um professor também é uma pessoa,
porém do tipo “Professor” e ele precisa de um tipo específico de uniforme para dar suas aulas. O aluno
também é uma Pessoa, porém ele precisa de um fardamento adequado para assistir as aulas. Assim nós
temos a classe “Professor” e “Aluno” herdando de “Pessoa” Porém cada uma delas tem métodos

110
diferentes quando nos referimos como eles se vestem. Vamos ver como ficaria em código Java o nosso
Polimorfismo.
Classe Pai:
Classe Filha de "Pessoa" que sobrescreve método vestirRoupa.
Classe Filha de "Pessoa" que sobrescreve método vestirRoupa.

111
10.0 Tratamento de Exceções
10.1 Capturando uma exceção usando o bloco (try e catch)

A linguagem Java fornece aos desenvolvedores um mecanismo sofisticado para manipulação de erros que
produz códigos de manipulação eficientes e organizados: a manipulação de exceções. A manipulação de
exceções permite que os desenvolvedores detectem erros facilmente sem escrever um código especial
para testar valores retornados. Permite também manter o código de manipulação de exceções nitidamente
separado do código que gerará a exceção. Além disso, permite que o mesmo código de manipulação de
exceções lide com as diferentes exceções possíveis.
A classe Throwable é a única classe cujas instâncias diretas ou indiretas podem ser usadas para serem
lançadas. A classe Throwable é pré -definida na linguagem Java, juntamente com várias outras classes
definindo um grande número de categorias de erro. Os programadores Java, por convenção, caso
queiram criar novas exceções devem estender a classe Exception que é uma subclasse de Throwable.
Duas classes descendentes da classe Throwable podem ser consideradas especiais: a classe Error e a
classe RuntimeException.
A linguagem Java não obriga o programador a tratar os lançamentos de exceção envolvendo instâncias da
classe Error, da classe RuntimeException e das classes delas derivadas, todos os outros lançamentos de
exceção devem ser tratados pelo programador. Capturando uma exceção com o bloco try e catch.
Vejamos a sintaxe.
O termo exceções significa „‟condição excepcional‟‟, e é uma ocorrência que altera o fluxo normal
do programa. Várias coisas podem levar a exceções, incluindo falhas do hardware, exaustão de recurso e
os famosos erros. Quando isso acontece, ou seja quando ocorre um evento excepcional ocorre em
Java, diz se que uma exceção será lançada.

112
Exemplo 01:
Nota: O método calc se for chamado com y igual zero (0), gerará um erro e uma exceção será lançada,
esse erro poderá ser sinalizado no bloco try-catch, então a execução do método pulará para o bloco de
código catch, onde será impressa uma mensagem de erro.
Exemplo 02:
Caso 01: Neste exemplo vamos chamar o método converteStr(), passando uma string numérica, que no
nosso caso é 8 e o resultado é a conversão da string em um número de ponto flutuante, daí a divisão é
feita e a execução do programa acontece sem nenhum problema.
Caso 02: Neste mesmo exemplo vamos chamar agora o método converteStr(), passando uma string não
numérica, que no nosso caso é a caractere 'n' e o resultado é o lançamento de uma exceção, jogando o
fluxo de execução do programa para o bloco catch, onde imprime uma mensagem na no console.

113
FINALLY
Finally: É o trecho de código final. A função básica de finally é sempre executar seu bloco de dados
mesmo que uma exceção seja lançada. É muito útil para liberar recursos do sistema quando utilizamos,
por exemplo, conexões de banco de dados e abertura de buffer para leitura ou escrita de arquivos.
Resultado do código acima:
LANÇADO UMA EXCEÇÃO COM O THROWS

O objeto de exceção é uma instância da classe Exception ou de uma de uma de suas subclasses. A
cláusula catch usa, como parâmetro, uma instância de objeto de um tipo derivado da classe Exception. A
linguagem Java exige que todo método capture a exceção verificada que pode vir a lançar ou então

114
declare que lançará a exceção. A declaração da exceção faz parte da interface pública do método. Na
declaração de uma exceção que poderá ser lançada, a palavra-chave throws é usada em uma definição do
método, junto com uma lista de todas as exceções verificadas que poderão ser lançadas.
Exemplo 01:
Exemplo 02:
CRIANDO UMA EXCEÇÃO COM THROW

A máquina Virtual Java lança referências para instâncias de maneira implícita utilizando as classes pré-
definidas. O programador pode utilizar o comando throw de forma explícita. Quando o fluxo de controle
atinge o comando throw <expressão>, a expressão é avaliada. Esta expressão corresponde em geral à
criação de um objeto e resulta numa referência, p. ex. throw new ErroDoTipoX();. A partir daí o fluxo de
controle será desviado para uma cláusula catch apropriada de algum comando try-catch.
O fluxo de controle segue a cadeia dinâmica dos registros de ativação das invocações dos métodos, ou

115
seja a execução de um método pode terminar (i) por que o fluxo de controle atingiu o final do método
(return implícito, somente no caso d e métodos do tipo void!), (ii) porque o fluxo de controle atingiu um
comando return, ou (iii) porque foi executado um throw implícito ou explícito que não foi apanhado por
um comando try -catch daquele método. A procura por um try-catch apropriado é propagada até o ponto
em que há um retorno para o método main, neste caso a execução do programa será finalizada, com
mensagem de erro provida pela MVJ dizendo que uma exceção foi lançada sem que fosse apanhada. E
deverá ser mostrado algo como:
Exemplos de exceções já definidas no pacote java.lang:

 ArithmeticException: indica situações de erros em processamento aritmético, tal como uma
divisão inteira por 0. A divisão de um valor real por 0 não gera uma exceção (o resultado é o valor
infinito).
 NumberFormatException: indica que tentou-se a conversão de uma string para um formato
numérico,mas seu conteúdo não representava adequadamente um número para aquele formato. É
uma subclasse de IllegalArgumentException;
 IndexOutOfBounds: indica a tentativa de acesso a um elemento de um agregado aquém ou além
dos limites válidos. É a superclasse de ArrayIndexOutOfBoundsException, para arranjos, e de
StringIndexOutOfBounds, para strings.
 NullPointerException: indica que a aplicação tentou usar uma referência a um objeto que não foi
ainda definida.
 ClassNotFoundException: indica que a máquina virtual Java tentou carregar uma classe
mas não foi possível encontrá-la durante a execução da aplicação.

116
11.0 Criando Diagrama UML
Introdução
Neste capítulo iremos aprender como, instalar e criar uma diagramação de classes usando o Netbeans
para a linguagem Java. UML significa: “Unified Modeling Language”, ou seja “Linguagem de
Modelagem unificada”. Modelar nosso código com objetivo de documentar e visualizar melhor o projeto.
Para realizar a instalação é simples, basta ir em Ferramentas > Plugins e buscar por UML. Este plugin
está disponível livremente a partir da versão 6.7.
Antes de começarmos a trabalhar com eles, precisamos lembrar quais os tipos de diagramas que podemos
desenvolver e qual a utilidade de cada uma dentro de um projeto de qualquer escala, visto no começo da
apostila.
Logo iremos aprender como exemplo a trabalhar com Diagrama de Classe, pois esse diagrama é bem
próximo da criação e estruturação de classes e herança entre as classes criadas.
Abrindo o Projeto na IDE Netbeans.
Criando um Novo Projeto Diagrama.

117
Nomeando Projeto de Diagrama.
Escolhendo Diagrama de Classe.

118
Entrando no Diagrama criado, podemos visualizar no Lado direto da IDE Netbeans, um botão chamado
“Paleta” ele será responsável abrir uma aba onde podemos montar os pacotes de classe.
Veja a interface da aplicação:
Na direita Clicando em “Class”, clique no palco principal que será gerado uma nova classe indefinida.
Para alterar a Classe, basta clicar em Create Atributes para criar os atributos , e Create Operation para
criar os métodos, lembre-se que para o diagrama, primeiro vem o nome da variável ou método, em
seguida vem o seu tipo:
Exemplo: nome : String
Veja como criar uma classe simples com o tipo, pessoa:
Dessa forma podemos criar qualquer classe com os seus atributos e métodos de forma a poder visualizar
melhor a estrutura do projeto.
Para criar interface ou Herança, basta clicarmos em uma classe ao qual você quer montar uma relação e
aparecerá o seguinte menu:

119

120
12.0 Fila e Pilha
Iremos estudar Alguns estilos de agrupamento e organização de dados, onde podemos listar, retirar ou
colocar elementos desse grupo de dados de forma organizada, levando em consideração a sua posição no
grupo, para isso podemos estudar conceitos de Fila e Pilha para essas aplicações, veremos nos próximos
tópicos como trabalhar com cada uma delas.
12.1 Fila
Imagine que você tem uma Fila de atendimento em um Banco. O que podemos observar em uma Fila?
 A fila poderá está vazia, onde o caixa não irá ter que trabalhar.
 A fila poderá está cheia, onde não poderá entrar ninguém mais na fila até que pelo menos saia uma
pessoa dela.
 Quando alguém novo chega, ele vai para o final da fila.
 A pessoa que é atendida é sempre o primeiro em uma fila e logo depois de ser atendido, ele sai da
fila, dando lugar a outras pessoas alterando a ordem de chamada de todo mundo. Quem era o
terceiro, passa a ser o segundo, quem era o segundo passa a ser primeiro na fila.
Tudo o que acontece em uma fila normal também pode ser implementado na Programação Java.
IMPLEMENTANDO FILA EM JAVA

Para que possamos implementar uma fila em Java temos que usar os métodos da interface “Queue” da
classe “LinkedList” Dessa forma:
Queue fila = new LinkedList();
O Objeto “fila” será responsável por conter método ao qual poderemos incluir, retirar, e mostrar o
próximo elemento da fila, veja na tabela abaixo os seus métodos e suas funções:
121
Método Função
element(Object); Mostra o primeiro elemento da fila sem removê-lo
offer(); Insere um novo elemento da fila
poll(); Retorna e retira o próximo elemento da fila. Retorna “null” se a fila
estiver vazia
Veja a implementação abaixo:
Os elementos nesse exemplo estão inseridos na seguinte ordem:
5 6 1 7 3
Retirando os 3 primeiros elementos da Fila com o método “Poll”, temos:
7 3
Inserindo o Elemento 10 e 1 na Fila usando o método “offer”, temos:

122
7 3 10 1
Sendo assim, se usarmos o método “Poll” mais 5 vezes, estes elementos seriam retornados e retirados da
fila nessa ordem mantendo a fila vazia. Quando a Fila estiver vazia, o comando “Poll” passará a retornar
“null”.
Vários sistemas usam esse recurso, como sistema de atendimento ao cliente, um sistema de fila de
impressora onde os primeiros documentos a serem impressos terão prioridade em relação aos outros
documentos que serão impresso em seguida. Pesquise por mais implementações usando o recurso de Fila.
12.2 Pilha
Imagine uma Pilha de Pratos a ser lavados. O que podemos observar?

 A pilha poderá está vazia, onde não precisamos lavar nenhum prato.
 A pilha poderá está cheia, onde não poderá entrar nenhum prato a mais, até ser lavado algum.
 O prato que chegar na pilha estará logo acima dos demais.
 O prato a ser lavado é justamente o de cima, ou seja, o ultimo prato da pilha, então os últimos
pratos a entrarem na pilha, serão os primeiro a ser lavados, logo que eles forem lavados eles sairão
da pilha, dando espaço para os pratos de baixo a ser lavados.
Claramente podemos perceber o velho ditado “Os últimos serão os primeiros” e esta regra também poderá
ser implementado em JAVA.
IMPLEMENTANDO PILHA EM JAVA

Para que possamos implementar uma pilha em Java temos que usar a Classe Stack, dessa forma:
Stack pilha = new Stack();

O Objeto “pilha” será responsável por conter método ao qual poderemos incluir, retirar, e mostrar o

123
ultimo elemento da pilha, veja na tabela abaixo os seus métodos e suas funções:
Método Função
empty() Verifica se a pilha está vazia retornando um Boolean
push(); Insere um novo elemento da pilha
pop(); Retorna e retira o ultimo elemento da pilha.
peek(); Retorna o ultimo elemento da pilha sem retirá-lo.
Veja na prática:
Os elementos nesse exemplo estão inseridos na seguinte ordem:
5 6 1 7 3
Retirando os 3 primeiros elementos da pilha com o método “pop”, temos:
5 6
Inserindo o Elemento 10 e 1 na Pilha usando o método “push”, temos:
5 6 10 1

124
Sendo assim, se usarmos o método “pop” mais quatro vezes, esses elementos seriam retornados e
retirados da pilha na ordem inversa mantendo a pilha vazia. O Comando “pop” não retorna null quando a
pilha estiver vazia, então recomenda -se sempre verificar se contém elementos na pilha usando o método
“empty”.
Vários sistemas usam esse recurso, um deles é bem usado por nós sem percebermos, imagine que está
digitando um texto e precisa “desfazer” uma operação. Cada elemento de “Input” é posto em uma pilha e
quando usamos o “CTRL+Z” é como usar um “pop” na pilha de retirando apenas o ultimo elemento
digitado. Pesquise por mais implementações usando o recurso de Pilha.

125
13.0 Coleções: List e Map

Introdução a Coleções/Collections
Aprendemos em capítulos anteriores que existe uma estrutura de dados chamada Array. Essa estrutura de
dados ela foi criada para guardar na memória do computador dados primitivos ou objetos do mesmo tipo,
de maneira organizada (bloco de dados contínuo), em que cada informação pode ser acessada por índices
(index),
A estrutura de dados Array é muito inflexível, é preciso definir seu tamanho assim que nós a criamos. E
isso pode gerar um problema para nós programadores Java.
Vamos analisar a seguinte situação:
Criaremos um Array para guardar os nomes de uma lista de 10 alunos do Curso
de Java:
Mas se no meio do meu programa eu precisar acrescentar a minha lista mais 20 alunos. Como o tamanho
do Array alunosNomes foi definido com 10 posições então não seria possível adicionar os 20 novos
alunos a essa estrutura, teríamos que tratar isso. Uma das alternativas para fazer isso é acrescentar o
seguinte código:

126
Como facilitar isso?

Como usar o conceito de Array, porém com um pouco mais de flexibilidade?
Coleções podem ser a saída para este problema. Uma das formas de pensar nas coleções é como Arrays
turbinadas, incrementadas com várias funcionalidades e regras.
A definição formal de Coleções é: estruturas de dados utilizadas para a rmazenar e manipular
informações, ou seja, são objetos que representam um grupo de objetos.
Esse capítulo tem como objetivo abordar as principais funcionalidades e regras de duas das principais
coleções do Java: List e Map.
13.1 Collection List ou Coleção Lista
Uma lista é uma coleção de elementos arrumados numa ordem linear, isto é, onde cada elemento tem um
antecessor (exceto o primeiro) e um sucessor (exceto o último). Normalmente implementada como
"Array" ou "Lista Encadeada". A Lista pode ser mantida ordenada ou não e as operações mais
importantes de uma coleção do tipo Lista são:
Adição de elementos
 Adicionar um objeto em qualquer lugar da lista, fornecendo o índice desejado;
Remoção de elementos
 Remover um objeto presente em qualquer lugar da lista, fornec endo o índice desejado;
Acesso aos elementos
 Obter o elemento de qualquer posição da lista, fornecendo o índice desejado;
 Iterar sobre os elementos;
Pesquisa de elementos
 Descobrir se certo elemento está na lista;
 Descobrir o índice de certo elemento na lista (onde está);
Indagar sobre atributos
 Obter o número de elementos da coleção;

127
Em Java existem três classes que trabalham com a Coleção do tipo Lista ou List elas se encontram no
pacote/package java.util . São elas:
 Vector
 ArrayList
 LinkedList
Escolhemos explanar nesse capítulo a classe Java mais utilizada para implementar listas que é
a classe ArrayList.
ArrayList

128
Acessando a documentação do Java 7 podemos visualizar todas as especificações dessa classe,

usada para programar coleções do tipo lista. Abaixo tabela com todos os métodos da classe ArrayList:
Desses métodos listados na documentação do Java 7 iremos estuda r os métodos principais, os quais
fazem as ações de adição de elementos, remoção de elementos, acesso aos elementos, pesquisa de
elementos e indagar sobre atributos de uma determinada lista.
CRIANDO UMA LISTA EM JAVA USANDO A CLASSE ARRAYLIST

Para criar uma lista usando a Classe ArrayList do Java, escreva em seu programa a seguinte linha
de código:
tipo: tipo do objeto que você quer guarda na lista. Ex: Integer, String, Carro, Pessoa, etc,
Exemplo:
Na versão 7 do Java você também pode criar uma lista de ssa forma:
Todas os códigos que trabalharem com listas usando a classe ArrayList precisam importar a
classe ArrayList. Isso pode ser feito adicionando a seguinte instrução no cabeçalho da
classe:
import java.util.ArrayList;
ADICIONANDO ELEMENTOS EM UMA LISTA

Agora que você já criou seu objeto Lista você pode adicionar elementos dentro dela. As Listas quando
criadas elas não possuem nenhum elemento, ou seja, elas são Listas Vazias.
Na Lista, diferente do Array, você não especifica seu tamanho, ela cresce de forma dinâmica à medida
que você acrescenta dados a ela.
Vamos aprender como adicionar elementos a uma Lista, para isso iremos usar o método add() que
pertence a classe ArrayList.

129
Exemplo:
O método add(), usado da forma mostrada acima ele se mpre coloca o novo dado adicionado à lista na
ultima posição da mesma, mas podemos utilizá-lo de outra maneira, de tal forma que podemos escolher a
posição em que queremos adicionar o novo elemento.
Vamos ver como fica essa outra forma de usar método add( ).
Exemplo:
Para visualizar todos os lados da lista na forma de uma String use o método toString(), desta forma:

130
Vamos aplicar esse método no exemplo em que criamos uma lista de anos, ficará desta maneira:
Saída do programa:
REMOVENDO ELEMENTOS DE UMA LISTA

Para remover um dado da lista utilizamos o método remove() da classe ArrayList. O método remove()
funciona da seguinte forma:

131
Vamos aplicar esse método no exemplo em que criamos uma lista de anos, ficará desta maneira:
Outra forma de usar o método remove() é passando para o método o objeto que você quer remover.
Ficando desta forma:
Exemplo:
Saída do programa sem o método remove():
Saída do programa aplicando o método remove():

132
ACESSANDO ELEMENTOS DA LISTA

Para acessar um valor de uma determinada lista usamos o método get() da classe ArrayList dessa forma:
Exemplo:
Temos métodos na classe ArrayList para auxiliar na interação da lista, ou seja, percorrer a lista acessando
os seus valores em todas as direções possíveis.
Esses métodos precisam, além da lista que iram auxiliar a percorre, um objeto do tipo ListIterator onde
esse objeto será como um leitor de posições da lista que pode percorrer a lista em todos os sentidos
possíveis.
Vamos entender melhor com o seguinte exemplo:
Vamos criar uma lista em Java, usando a classe ArrayList, para guardar o nome das linhas de ônibus de
Fortaleza.
Agora vamos criar um objeto do tipo ListIterator, onde esse objeto será como um leitor de posições da
lista que pode ser deslocado para frente e para trás ao longo de uma lista. Para criar um objeto do tipo
ListIterator precisamos importar a classe que cria esse objeto para o nosso programa, pois esse objeto não
pode ser instanciado pela classe ArrayList. A importação da classe é feita adicionando a seguinte
instrução no cabeçalho de sua classe:
import java.util.ListIterator;

133
Após importar o método podemos criar nosso objeto do tipo ListIterator da seguinte maneira:
Por fim, podemos usar os métodos da classe ArrayList que nos ajudam a percorrer uma lista, da seguinte
forma:
Saída do programa:
De forma semelhante ao método hasNext() e o método next() podemos ainda usar em nossos programas
Java os seguintes métodos:
Métodos para auxiliar percorrendo uma Lista usando a classe ArrayList
 hasNext(): retorna true se o elemento lido pelo percorredorLista tem sucessor, caso contrário

134
retorna false;
 hasPrevious(): retorna true se o elemento lido pelo percorredorLista tem antecessor, caso contrário
retorna false;
 next(): faz o percorreLista avançar para a posição seguinte da lista e retornar o novo valor lido;
 previous(): faz o percorreLista retroceder para a posição anterior da lista e retornar o novo valor
lido;
 nextIndex(): retorna o índice do elemento sucessor ao elemento l ido pelo percorreLista;
 previousIndex(): retorna o índice do elemento antecessor ao elemento lido pelo percorreLista;
PESQUISANDO ELEMENTOS DA LISTA

Pesquisar um elemento na lista é bastante simples. Vamos usar o método indexOf() que se encontra na
classe ArrayList para pesquisa em uma lista. Esse método retorna o valor do índice do objeto procurado
se ele existir na lista, caso contrário retorna -1.
Exemplo:
Saída do programa:

135
13.2 Collection Map ou Coleção Mapa
Um mapa armazena pares (chave, valor) chama dos itens, essas chaves e valores podem ser de qualquer
tipo, portanto, a chave é utilizada para achar um elemento rapidamente. Estruturas especiais são usadas
para que a pesquisa seja rápida, como "Tabela Hash" ou "Árvore". Os dados armazenados nos mapas
podem ser mantidos ordenados ou não (com respeito às chaves).
A coleção do tipo Mapa difere das Listas por diversas características, as principais são:
 as estruturas de dados que as implementam;
 na coleção do tipo Mapa podemos escolher o tipo e o valor q ue terão as chaves(índices), através
delas teremos acesso aos dados. As chaves (índices) e dados dos Mapas podem ser de qualquer
tipo, inclusive um objeto. Já nas Listas somente os valores armazenados podem ser de qualquer
tipo, seus índices são sempre números inteiros indexados a partir do zero de forma automática, à
medida que vamos adicionando elementos à coleção.
As operações mais importantes de uma coleção do tipo Mapa são:
Adição de elementos
 Adicionar um item no mapa (fornecendo chave e valor)
Remoção de elementos
 Remover um item com chave dada
Acesso aos elementos
 Iterar sobre os itens
Pesquisa de elementos
 Descobrir se um elemento com chave dada está na coleção
Indagar sobre atributos
 Obter o número de elementos
 Observe que o acesso à coleção sempre é feita conhecendo a chave
Vamos utilizar a classe HashMap para trabalhar com coleções do tipo mapa ou map.
13.3 HashMap
A classe HashMap é uma implementação da interface Map do pacote java.util, e possibilita trabalhar com
mapeamento de objetos no esque ma chave/valor, ou seja, informada a chave, resgato o valor.
Acessand a documentação do Java 7 podemos visualizar todas as especificações dessa classe, usada
para programar coleções do tipo mapa/map. Abaixo tabela com todos os métodos da classe HashMap:

136
Vamos explanar os principais métodos da classe HashMap, métodos que nos permitirá criar, adicionar,
remover, selecionar e pesquisar itens em uma coleção do tipo Map.
CRIANDO UMA COLEÇÃO DO TIPO MAPA USANDO A CLASSE HASHMAP

Para criar um mapa usando a Classe HashMap do Java, escreva em seu programa a seguinte linha
de código:
tipo_da_chave: coloque o tipo que terá a chave/índice do seu Map, essa chave será usada para acessar os
valores guardados no Map;
tipo_do_valor: coloque o tipo que terá os valores que serão guardados em seu Map;
Pronto, dessa forma já instanciamos uma coleção do tipo Map usando a classe HashMap.
Agora temos que inserir elementos a coleção do tipo Map , pois só criamos o Map, mas não há elementos
dentro dele.
Lembre se de importar a Classe HashMap para seu programa, já que estamos usando-a para implementar
e trabalhar com Coleções do tipo Mapa. Podemos importar a classe colocando a seguinte instrução no

137
cabeçalho do programa o qual estamos escrevendo:

import java.util.HashMap;
ADICIONANDO ELEMENTOS EM UMA COLEÇÃO DO TIPO MAPA

Após criar o seu Map, podemos adicionar um elemento usando o método put() da Classe HashMap da
seguinte forma:
objeto_chave: valor do objeto que será a chave de acesso para os valores do mapa;
objeto_valor: valor do objeto que será guardado no mapa;
Exemplo:
Vamos criar um Map para guardar estados e suas respectivas capitais. Os
estados serão as chaves e as capitais serão os valores guardados no Mapa, ambos serão do tipo String.
Agora vamos adicionar os valores ao nosso mapa usando o método put, da seguinte forma:
Vamos usar o método toString() para visualizar como estão os dados dentro do nosso mapa, da seguinte
forma:
Saída do Programa:
REMOVENDO ELEMENTOS EM UMA COLEÇÃO DO TIPO MAPA

Para remover elementos de uma coleção do tipo Mapa usando os métodos da Classe HashMap usamos o
método remove().
objeto_chave: chave de acesso do elemento a ser removido do mapa;

138
O método remove() retorna uma String com o valor removido do mapa ou retorna o valor null se não for
achado nenhum valor associado a chave passada no argumento do método.
Exemplo:
Saída do programa:
SELECIONANDO/PESQUISANDO ELEMENTOS EM UMA COLEÇÃO DO TIPO MAPA

O método de seleção get() da classe HashMap é o mesmo método usado para se pesquisar um valor
dentro de um mapa. Esse método funciona da seguinte forma:
objeto_chave: chave de acesso do elemento a ser selecionado/pesquisado do mapa;

139
Exemplo:
Saída do programa:
NÚMERO DE ELEMENTOS EM UMA COLEÇÃO DO TIPO MAPA

Para sabermos o número de elementos contido em um mapa podemos utilizar o método size(), esse
método pode ser usado de maneira semelhante com coleções do tipo Lista usando a classe ArrayList.
O método size() funciona da seguinte forma:
A chamada ao método size() nos retorna um valor inteiro que é a quantidade de elementos de um mapa.
Exemplo:

140
Saída do programa:

141
14.0 Interface Gráfica com usuário - GUI

A Interface Gráfica com o Usuário, também conhecido como GUI - Graphical User Interface, em Java,
é feita através de bibliotecas de classes, sendo que a primeira a surgir foi a AWT(Abstract Window
Toolkit). A AWT surgiu já na vers ão 1.0, mas se tornou confiável a partir da versão 1.1. A maneira como
as classes dessa biblioteca trabalham garante a criação dos elementos da interface de usuário seguindo o
comportamento destinado às ferramentas GUI nativas de cada plataforma (Windows, Mac, Solaris, ...).
Alguns exemplos destes elementos são: botões, listas, menus, componentes de textos, contêineres (janelas
e barras de menus), caixas de diálogo para abrir ou salvar arquivos, além de elementos para manipulação
de imagens, fontes e cores.
A portabilidade de plataforma funcionava bem em aplicações simples, mas aplicações que envolviam
elementos mais complexos, como menus e barras de rolagem, por exemplo, apresentavam diferenças de
comportamento conforme a plataforma. O que aconteceu foi que as aplicações visuais feitas em Java não
se pareciam, e nem tinham as mesmas funcionalidades, com as aplicações convencionais de cada
plataforma.
A partir da versão 2 do Java, a JFC (Java Foundation Classes) apresentou novos recursos para a
construção da GUI das aplicações, o que melhorou muito os problemas de portabilidade. São eles:
 Java 2D: novas funções para desenhos e gráficos.
 Drag & Drop: clicar, arrastar, copiar e colar.
 Swing: biblioteca de classes extensão da AWT, onde são apresentados novos componentes de
interface e o que é conhecido por look and feel, que é uma adaptação perfeita da GUI ao sistema
operacional específico de desenvolvimento.
142
É bom salientar que o Swing não substitui o AWT, mas é o kit de ferramentas GUI mais utilizado para
desenvolvimento de aplicações visuais. O AWT continua existindo, mantendo a mesma arquitetura criada
para o Java versão 1.1.
O Swing possui muito mais recursos, além de garantir maior portabilidade e, em boa parte dos casos, é
mais fácil de usar. Isso não significa que ou se utiliza AWT ou se utiliza Swing, normalmente o que
acontece é que elementos das duas bibliotecas são utilizados conjuntamente nas aplicações.
14.1 Bibliotecas AWT e SWING
São as fontes das classes que utilizaremos a partir daqui. Nelas moram os componentes gráficos para
Java, e por isso devemos importá -las no início de nossas classes gerenciadoras de telas:
 import javax.swing.*;
 import java.awt.*;
14.2 JFrame
Pode parecer estranho para quem vem de outras linguagens, como o Delphi ou o VB, mas em Java, cada
tipo de componente gráfico é uma classe com atributos e métodos próprios. E para utilizá-las, devemos
instanciá-las.
CAMADAS JFRAME
Antes que possamos criar nossa primeira ja nela precisamos conhecer como funciona a hierarquia dos
elementos que são responsáveis pela visualização gráfica.
Onde:
RootPane – Representa uma camada que irá gerenciar todas as camadas internas.
143
LayeredPane – Contém uma região para Barra de Menu e o ContentPane

ContentPane – Contém todos os Componentes como um campo de texto,campo de seleção de opções,
etc.GlassPane – Camada que por padrão é invisível, porém pode ser usado para mostrar algum
componente por cima das demais, como uma imagem.
Agora que sabemos como funciona um Jframe iremos criar nossa primeira janela em Java.
Nossa primeira Janela com JFrame
A primeira e mais simples chama-se JFrame, e cria telas retangulares sem nada dentro, um espaço onde
trabalharemos logo depois.
O método SetBounds trabalha com a localização e tamanho da tela, sendo a seguinte ordem: distância do
canto esquerdo da tela, distância do topo da tela, largura e altura.
tela.getContentPane().setBackground(Color.RED);
Aqui, invocamos o método que verifica qual é o campo d e Content do JFrame, ou seja, a região onde não
está o menu nem as bordas, e muda sua cor a partir do método set Background. Eu usei uma biblioteca de
cores, a Color, e defini a janela como vermelha; Poderia ter usado azul, cinza, verde, etc.
tela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Aqui, eu determino qual a ação a executar quando este JFrame for fechado. No caso, ele fecha o
programa todo, num efeito de BREAK. A instrução DISPOSE_ON_CLOSE apenas levará o JFrame a
fechar sem derrubar o programa todo.
tela.setLayout(null);
Aqui, escolhi um Layout para o meu JFrame. Ou melhor, escolhi que seja nenhum. Existem
Layouts prontos para JFrames, onde os botões ficam dispostos em forma de fileira, ou nos cantos,
ou expandidos. A maioria tem um resultado grotesco. Se quisermos desenhar nossa tela com liberdade
para fazê-la bonita, temos que escolher o NULL;
tela.setVisible(true);
Depois de preparado, o JFrame pode já ficar visível. Este passo vem no final de toda a sua montagem.

144
Agora vamos ver como ficou nossa janela.
14.3 Criando uma classe com propriedades JFrame
No tópico anterior aprendemos como construir uma Janela usando as propriedades do JFRAME
diretamente. Para a nossa janela criada, o método main tinha a responsabilidade direta de criar uma
janela. Para essa situação, se quiséssemos criar uma nova janela tínhamos que chamar novamente a
Classe JFrame e atribuir todas as características novamente linha a linha. Podemos construir uma janela
de uma forma melhor criando um próprio modelo com métodos, encapsulamento, herança e os demais
recursos aprendidos sobre orientação a objetos. Para criar o nosso modelo de JFrame precisamos primeiro
criar uma classe e herdá-la de JFRAME dessa forma:
Assim nossa classe chamada “MinhaJanela” herda todas as propr iedades de JFrame através da
classe Pai.

145
Podemos definir um padrão para qualquer janela criada partindo de “MinhaJanela”, vamos agora definir
que toda janela nossa terá obrigatoriamente um título. Basta inserirmos um construtor e redirecionar esse
valor para classe que tem a responsabilidade de receber o título de uma Janela.
No construtor podemos também definir qualquer outra propriedade na sua chamada, como coordenadas,
cor do plano de fundo, procedimento utilizado quando for fechada a janela, layout, visibilidade, etc. Veja
o Exemplo abaixo ainda no mesmo construtor:
Agora indicamos que qualquer instancia de “MinhaJanela” terá as mesmas propriedades, sendo
diferenciadas apenas pelo seu Título.
Vamos instanciar no método main a classe que acabamos de definir:
Temos então o mesmo resultado do tópico anterior, perceba que se quisermos criar uma 2 janela por
exemplo, não precisamos definir todas as propriedades novamente, basta instanciar uma nova
“MinhaJanela” definindo um segundo título, assim teremos uma nova janela.
Usando herança, podemos através da nossa classe definida, acessar os elementos do Jframe baseado no
seu nível de encapsulamento. No Exemplo abaixo usaremos o método setLocation() para alterar a
localização da nosssa janela. Esse método não foi criado por nós, mas foi definido pelas classes Pai nas
definições de herança da Classe Jframe.

146
Temos então o seguinte resultado final:
Iremos usar o exemplo da Classe Minha Janela para criar os componentes nos próximos tópicos.
14.4 JLabel
É um pequeno componente com o qual colocamos pedaços de texto sem nenhuma função, a não ser a de
indicar para quê servem os campos de uma tela qualquer.

147
O código acima não apresenta grandes novidades. Apenas instanciamos o Jlabel , dando-lhe um texto
qualquer para exibir. Depois, demos o mesmo setBounds nele, em seguida fizemos a ação realmente
revolucionária:
super.getContentPane().add(texto);
Adicionamos o objeto “texto” na tela usando super.getContentPane(). Note que o setBounds do “texto”
passa a usar como bordas as bordas do JFrame. E fica contido nele.
O JLabel pode ter desenhos por dentro, mas veremos isso mais adiante, quando tratarmos do Icon, outro
tipo de objeto Java.
O resultado de nossa janela é esse:

148
14.5 JButton
O JButton é, finalmente, o botão. Colocamos ele nas telas com inúmeras funções. Estas funções
serão tratadas mais adiante, quando chegarmos às aulas sobre Eventos. Por enquanto, basta-nos desenhar
os botões.
O JButton poderá ser instanciado de três formas diferentes:
JButton() – aqui, teremos depois que rodar um método setText(“algum texto”) para dar-lhe um
conteúdo(um conteúdo que aparece para o usuário).
JButton(String) – aqui, escrevemos algum texto para aparecer no botão e o usuário saber do que se trata.
JButton(icon) – neste caso, adicionamos uma figura ao botão para dar -lhe uma aparência personalizada.
Veja este código:
No exemplo acima, usamos praticamente a mesma tela criada antes, porém adicionamos as rotinas de
criação de um botão. Primeiro, instanciam os a classe JButton e usamos os métodos já conhecidos
setBounds para definir suas coordenadas.
A nossa janela ficará assim:

149
14.6 JTextField
O JTextField é uma caixa utilizada para que o usuário possa escrever um texto de uma linha só. Trata-se
de um componente bastante simples, que tem basicamente as mesmas especificações do que acabamos de
ver nos componentes anteriores.
Enriquecendo o código anterior, adicionando um JTextField:

150
O tratamento do texto de um JTextField dar-se-á por meio de dois métodos bastante simples:
getText() – servirá para capturar o quê o usuário digitou no campo.
setText() – servirá para determinarmos que texto deve ir no campo. Muito útil quando se abre um registro
de um banco de dados e o campo JTextField deve receber um campo de registro para alteração.
A nossa janela ficará assim após acrescentar o JTextField:
14.6 Icon
A classe Icon tem um uso bastante simples, mas muito importante. Com ela, podemos carregar uma
imagem (devidamente criada em um arquivo JPG ou PNG), para dentro do programa, utilizando esta
imagem como quisermos.
Primeiro temos que inserir uma imagem no seu projeto, crie uma pasta dentro do seu projeto chamada
“img” e nela coloque qualquer imagem, em seguida insera uma imagem chamada “logo.png”;
Em sua Janela faça o seguinte código:

151
No exemplo acima carregamos as informações da Imagem que importamos, em seguida partindo da

construção de uma ImageIcon passando como argumento url indicada, capturamos apenas as informações
de Icon para ser utilizada nos nossos componentes, alguns componentes aceitam Icon como argumento no
construtor, como Jbutton, Jpanel, etc.

152
14.7 Editando fonte com o setFont()

Podemos formatar as fontes de nossos botões e rótulos.
Vamos usar o método setFont dessa forma:
Nossa janela ficará assim:
14.8 JMenuBar, JMenu e JMenuItem
Estas classes são utilizadas sempre em conjunto, para criar um menu na parte superior do JFrame, e
deixar seu software com aquela facilidade de uso que os usuários modernos exigem.
Aqui, começamos a trabalhar uma modalidade de programação que costumo chamar informalmente de
“empilhamento de objetos”, pois os objetos só funcionam quando colocamos um dentro do outro em uma
espécie de pirâmide.
O objeto que serve de base é o JMenuBar, adicionad o diretamente ao JFrame, e sobre ele vão todas as
coisas. Ele é a barra clara no alto do JFrame, dentro da qual os menus ficarão.
Depois, temos os JMenu, que ficam dentro da MenuBar e podem, inclusive, ficar um dentro do outro.
Dentro dos JMenu, ficam os JMenuItem, que têm uma função cada um. Para ativar suas funções,
utilizaremos os Listeners, mais adiante. Deixemos isso para outro capítulo.

153
Criando uma janela, um JMenuBar(container de menus), Menus(JMenu) e por fim itens de

menus(JMenuItem).
Agora vamos adicionar o JMenuBar dentro da janela, depois adicionar os JMenus dentro do JmenuBar, e
por fim adicionar dentro do JMenu itens de menus(JMenuItem).

154
A ultima linha de código representa um método que será responsável pelas configurações da janela
Principal, veja a baixo a sua implementação.
Agora vamos ver como ficou nossa janela:
14.9 JCheckBox
Uma JCheckBox é um daqueles componentes em que vemos uma caixinha quadrada com uma
frase ao lado, e podemos marcar ou desmarcar a caixinha quadrada.
As CheckBoxes não são usadas para fazer escolhas com apenas uma opção válida, podendo ser todas
marcadas ou todas desmarcadas livremente, desde que o programador não coloque restrições no próprio
código.
Veja como trabalhar com JCheckBox no exemplo de código abaixo:

155
Depois, para termos um retorno do valor de cada JCheckBox, utilizamos o método isSelected(),
que retorna um valor booleano.
Assim:
boolean x = cbPizza.isSelected();
Ou ainda:
if (cbPizza .isSelected()) {
- Funções a serem executadas.
}
Veja como ficou nossa janela:

156
14.10 JRadioButton
O JRadioButton funciona apenas quando pensamos nele inserido em um grupo. Eu posso colocar quantas
opções quiser, formando um menu, e se todos os meus JRadioButtons estiverem no mesmo grupo, o
usuário só poderá marcar um deles. Ao marcar um, os outros perdem a marcação. Para isso, temos
que adicionar também um ButtonGroup.
Veja o código abaixo e saiba como trabalhar com JRadioButton. Veja como ficou nossa janela:
JComboBox

157
A JComboBox desenha uma caixinha parecida com a JTextField, só que ao invés de termos um texto a
escrever, temos uma seta com a qual abrimos uma fileira de possibilidades de preenchimento para a caixa.
Veja como trabalhar como trabalhar com JcomboBox, observando o exemplo abaixo:
Para obter o retorno das informações, temos uma série de métodos que nos dizem o que, afinal, o usuário
escolheu. Os mais usados são os seguintes:
comb.getSelectedItem()
Este retorna o texto que está na caixa do Combo. Poderá ser usado especialmente para quando colocamos
o setEditable em TRUE, ou seja, quando o usuário pode escrever na caixa. O retorno deste método é uma
String, com o texto da caixa.
comb.getSelectedIndex();
158
Este método retorna o índice do item selecionado (como se as opções fossem um

vetor).
Veja abaixo o resultado:
Existem mais componentes Swing, além dos mostrados até aqui. Foram mostrados os
principais componentes. Caso você precise ou deseje conhecer mais componentes Swing
acesse:
http://docs.oracle.com/javase/7/docs/api/

159
15.0 Gerenciadores de Layout

Gerenciamento de layout ( Layout Management ) é o processo de determinar o tamanho e a posição dos
componentes na janela gráfica do programa. É ele o responsável por determinar onde o componente irá
ficar como irá ficar, qual o comportamento a ser tomado na hora de redimensionar a tela.
Por padrão o Java vem com cinco gerenciadores de layout: BorderLayout, BoxLayout,
FlowLayout, GridBagLayout, GridLayout e um adicional chamado CardLayout. São os gerenciadores de
layout que determinam como os componentes ir ão ficar em seu programa, portanto um bom
conhecimento sobre o funcionamento dos mesmos faz -se necessário para ter domínio de programação
gráfica em Java.
Geralmente, quando chamamos o método "add" para adicionar um componente na tela, ele será
posicionado de acordo com o gerenciador de layout previamente configurado. A maior parte
simplesmente vai adicionando os componentes com base na ordem em que foram programados, porém
alguns outros, como o BorderLayout, necessitam que você informe a posição relativa no container.
A escolha do gerenciador de layout depende muito das necessidades do programa. Por padrão todos os
objetos Containers são configurados para usar o FlowLayout, enquanto um JFrame e JDialog já usam o
BorderLayout como padrão.
Em ambos os casos é usado o método "setLayout" para especificar um novo layout manager, sendo
necessário passar para este método o tipo que desejamos. Abaixo há um exemplo para cada tipo de
gerenciador de layout, ficando assim fácil para vermos como cada um se comporta.
15.1 BorderLayout
BorderLayout trabalha como algumas coordenadas predefinidas , como norte, sul, leste, oeste e centro.
Para poder usar esse recurso temos que antes usar o método setLayout que antes era definido como “null”
para uma nova instancia de Border Layout.
Veja o Exemplo abaixo.

160
15.2 BoxLayout
Um BoxLayout coloca os componentes em uma única linha ou coluna, permitindo ainda que você
especifique o alinhamento deles. Para que um BoxLayout possa existir temos que passar como argumento
no seu construtor o container que será aplicado e um alinhamento que poderá ser horizontal ou vertical,
161
representado pelas constantes estáticas da classe BoxLayout : X_AXIS (para alinhamento horizontal dos
meus componentes) e Y_AXIS (para alinhamento horizontal).
Nossa janela ficará dessa forma:

162
15.3 FlowLayout
Como dito anteriormente, um FlowLayout é o gerenciador padrão de todo Container, caso não seja
especificado outro. FlowLayout posiciona os componentes lado a lado. Ela se diferencia de um
BoxLyout pois seus componentes podem se alinha horizontalmente e verticalmente baseando-se nas
dimensões do container. Veja o exemplo de sua aplicação.

163
15.4 GridLayout
Um GridLayout atua como uma grade de uma planilha de cálculo, colocando os componentes em linhas e
colunas pré-determinadas e deixando os componentes com o mesmo tamanho, para isso precisamos
definir um limite de linhas e colunas para esse layout. Veja isso no exemplo abaixo:

164
15.5 GridBabLayout
O mais flexível gerenciador de layout é o GridBagLayout. Ele permite colocar componentes em grades de

165
colunas, sendo possível um componente ocupar mais de uma coluna ao mesmo tempo. As linhas também
não precisam necessariamente ter os mesmos tamanhos, ou seja, você pode configurar diferentes larguras
e alturas de acordo com a necessidade. Eis o exemplo abaixo.

166
Logicamente é possível fazer muito mais com os gerenci adores de layout, há várias
maneiras de configurar e utilizar. Para obter mais informações sobre os métodos
disponíveis para cada um consulte a API, disponível em:
http://docs.oracle.com/javase/7/docs/api/
16.0 Eventos (Listeners)

Eventos em Java nada mais é que métodos especiais que são realizados baseados em alguma ação
de um usuário seja ele, um clique, um digitar de uma tecla, ao passar o mouse, etc.. Iremos ver nos
próximos tópicos como utilizar esses métodos especiais em nossos projetos.
ActionListener
O ActionListener. Trata-se de uma classe que detecta se houve uma ação em uma referencia a que ela está
associada (um botão, por exemplo) e que, dependendo da ação, executará uma função. ActionListener é
representado por uma interface, então para que a minha classe possa realizar tratamento de eventos, a
primeira implementação que iremos fazer é dar um “implements” na classe que queremos ter essa
funcionalidade , vejamos o exemplo abaixo:
Iremos também criar uma caixa de texto e um botão para utilizar um evento que irá capturar o que foi
digitado e imprimir na tela.
A Implementação ActionListener irá obrigar a minha classe a conter um método chamado,
actionPerformed, com um parâmetro do tipo “ActionEvent”. Veja a implementação abaixo.

167
Agora iremos construir nosso layout:
Os métodos que iremos utilizar para criar o evento são, addActionLIstener e setActionCommand, eles
serão responsáveis por redirecionar e enviar um comando para o método que nós criamos
actionPerformed.
addActionListener: Método que irá receber uma classe que irá conter uma implementação
actionListener, no nosso caso, nossa própria classe terá esse método, o motivo do argumento “this” no
exemplo anterior.
SetActionCommand: Método que irá enviar uma instrução para o método actionPerformed, com esse
recurso, podemos por exemplo criar outros outros botões enviando outros comandos para o mesmo
método realizando assim outras funções em uma mesma janela. No exemplo acima utilizamos um
comando que definimos como “OK”.
Iremos agora ver como irá iremos implementar o método actionPerformed: O processo é bem simples,
caso o ActionCommand do evento “e” seja igual a “OK” (comando que definimos usando
setActionCommand), uma caixa com uma mensagem aparecerá na tela informando o nome digitado.

168
Se para modificar um comando utilizamos o método setActionCommando , para que possamos resgatar o
que foi modificado usaremos os método getActionCommando e compararemos com o comando que
queremos acionar.
Agora iremos capturar o que foi digitado na caixa de texto, o exemplo acima mostra que chamamos o
atributo txtNome que foi definindo com JtextField e utilizar o método getText() que tem como retorno
uma String, essa String será capturada impressa na tela no momento do clique do botão.
Vejamos o resultado dessa operação:
Importante: Antes de passa para o próximo tópico, tenha certeza que entendeu todos os
processos envolvidos, pois os próximos eventos serão implementações semelhantes.
16.1 FocusListener
O FocusListener se parece com o ActionListener em seu modo de construção, mas serve para detectar
quando o foco (ou seja, o cursor, a seleção, não o ponteiro do mouse) está sobre um objeto ou não.
Ele possui dois métodos que precisam ser implementados: o focusGained e o focusLost, um para quando
o objeto ganha foco e outro para quando perde.

169
Para ativar o método, usamos addFocusListener. Usando esse recurso iremos mostrar um exemplo de
alteração da cor de um plano de fundo baseado em um foco em uma caixa de texto. Veja o exemplo
abaixo:
O resultado Final:

170
16.2 KeyListener
O KeyListener é uma interface que serve para que possamos coordenar as ações do usuário com o teclado
quando ele está escrevendo em algum espaço ou utilizando alguma função. Posso atribuir KeyListener a
qualquer objeto gráfico do J ava e detectar quando e o que o usuário está teclando.
A implementação KeyListener obriga a ter 3 métodos :
 keyTyped: Será ativado ao pressionar um botão caractere ou numérico do teclado.
 keyPressed: Será ativado ao segurar um botão, como SHIFT, CTRL, ALT etc.
 keyReleased: Será ativo ao deixar de pressionar o botão.
Para ativar o método, usamos addKeyListener. No exemplo abaixo alteramos a cor de plano de fundo da
caixa de texto para cada uma das ações realizadas pelo usuário.

171
NOTA: Pode-se detectar qual o botão apertado pelo usuário explorando a variável “KeyEvent e”, que
retornará o código da tecla apertada com o método: getKeyChar().
16.3 MouseListener
O MouseListener, como seu nome obviamente revela, serve para tratarmos eventos relacionados ao uso
do mouse.
A implementação MouseListener obriga a ter 5 métodos :

 mouseClicked: Será ativado no clique simples do mouse.
 mousePressed: Será ativado ao segurar o clique no mouse.
 mouseReleased: Será ativado ao deixar o clique do mouse.
 mouseEntered : Será ativado ao entrar na região do componente pelo mouse.
 mouseExited: Será ativa ao deixar a região do componente pelo mouse.
Para ativar o método, usamos addMouseListener. O código abaixo mostra como alterar o plano de fundo
do Container usando event os do mouse Veja a implementações dos métodos abaixo:

172
Nós podemos saber qual é a localização do ponteiro do mouse utilizando dois métodos:
getX() – retorna a posição do mouse no eixo X (horizontal) dentro do objeto a que estamos atribuindo
o MouseListener.
getY() – Faz o mesmo, só que com a posição do eixo Y (vertical).

173
Hino Nacional Hino do Estado do Ceará
Ouviram do Ipiranga as margens plácidas Poesia de Thomaz Lopes

De um povo heróico o brado retumbante, Música de Alberto Nepomuceno
E o sol da liberdade, em raios fúlgidos, Terra do sol, do amor, terra da luz!
Brilhou no céu da pátria nesse instante. Soa o clarim que tua glória conta!
Terra, o teu nome a fama aos céus remonta
Se o penhor dessa igualdade Em clarão que seduz!
Conseguimos conquistar com braço forte, Nome que brilha esplêndido luzeiro
Em teu seio, ó liberdade, Nos fulvos braços de ouro do cruzeiro!
Desafia o nosso peito a própria morte!
Mudem-se em flor as pedras dos caminhos!
Ó Pátria amada, Chuvas de prata rolem das estrelas...
Idolatrada, E despertando, deslumbrada, ao vê-las
Salve! Salve! Ressoa a voz dos ninhos...
Há de florar nas rosas e nos cravos
Brasil, um sonho intenso, um raio vívido Rubros o sangue ardente dos escravos.
De amor e de esperança à terra desce, Seja teu verbo a voz do coração,
Se em teu formoso céu, risonho e límpido, Verbo de paz e amor do Sul ao Norte!
A imagem do Cruzeiro resplandece. Ruja teu peito em luta contra a morte,
Acordando a amplidão.
Gigante pela própria natureza, Peito que deu alívio a quem sofria
És belo, és forte, impávido colosso, E foi o sol iluminando o dia!
E o teu futuro espelha essa grandeza.
Tua jangada afoita enfune o pano!
Terra adorada, Vento feliz conduza a vela ousada!
Entre outras mil, Que importa que no seu barco seja um nada
És tu, Brasil, Na vastidão do oceano,
Ó Pátria amada! Se à proa vão heróis e marinheiros
Dos filhos deste solo és mãe gentil, E vão no peito corações guerreiros?
Pátria amada,Brasil!
Se, nós te amamos, em aventuras e mágoas!
Porque esse chão que embebe a água dos rios
Deitado eternamente em berço esplêndido, Há de florar em meses, nos estios
Ao som do mar e à luz do céu profundo, E bosques, pelas águas!
Fulguras, ó Brasil, florão da América, Selvas e rios, serras e florestas
Iluminado ao sol do Novo Mundo! Brotem no solo em rumorosas festas!
Abra-se ao vento o teu pendão natal
Do que a terra, mais garrida, Sobre as revoltas águas dos teus mares!
Teus risonhos, lindos campos têm mais flores; E desfraldado diga aos céus e aos mares
"Nossos bosques têm mais vida", A vitória imortal!
"Nossa vida" no teu seio "mais amores." Que foi de sangue, em guerras leais e francas,
E foi na paz da cor das hóstias brancas!
Ó Pátria amada,
Idolatrada,
Salve! Salve!
Brasil, de amor eterno seja símbolo

O lábaro que ostentas estrelado,
E diga o verde-louro dessa flâmula
- "Paz no futuro e glória no passado."
Mas, se ergues da justiça a clava forte,

Verás que um filho teu não foge à luta,
Nem teme, quem te adora, a própria morte.
Terra adorada,
Entre outras mil,
És tu, Brasil,
Ó Pátria amada!
Dos filhos deste solo és mãe gentil,
Pátria amada, Brasil!

Informatica Programacao Orientada A Objetos Java 2019

Enviado por

Dados do documento

Descrição original:

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

Informatica Programacao Orientada A Objetos Java 2019

Enviado por

Direitos autorais:

Formatos disponíveis

Escola Estadual de Educação Profissional [EEEP] Ensino Médio Integrado à Educação Profissional

Equipe de Elaboração - 2012

5.2 Expressões válidas para instruções switch e case. ............................................................................ 74

14.9 JCheckBox .................................................................................................................................... 155

Informática – Programação Orientada a Objetos / Java

A Programação Orientado a Objeto constitui em um conjunto de regras de programação. Estudamos

Informática – Programação Orientada a Objetos / Java

1.0 Introdução a Sistemas

Informática – Programação Orientada a Objetos / Java

1.1 Modelagem de Sistemas

 Representar de forma gráfica ou textual partes reais ou imaginárias do sistema.

 Por no papel a concepção que se tem de como funcionará o sistema concebido.

 Documentar de forma gráfica ou em texto um sistema existente (engenharia reversa).

Por que é importante modelar?

O que é uma informação?

“Conhecimento consiste de dados e informações organizados e processados para transmitir compreensão,

1.2 Dado, Conhecimento e Informação.

Observe nas imagens abaixo a distinção entre Dados, Informações e Conhecimento:

Resultado do processo cognitivo, iniciado por um novo estímulo

Informática – Programação Orientada a Objetos / Java

DADO INFORMAÇÃO CONHECIMENTO

1.3 O que é um sistema

Segundo Chiavenato (1999) e Oliveira (2002), o sistema apresenta os seguintes componentes:

 Objetivos: é a finalidade para o qual o sistema foi criado;

 Processamento: fenômeno que realiza as mudanças, é o mecanismo que converte as entradas em

 Saídas do Sistema: são os resultados do processamento.

 Ambiente: é o meio que envolve externamente o sistema.

válidos para o funcionamento com excelência.

1.4 Como construir um Sistema de informação baseado em computador

Em posse de um objetivo, qual seja planejar e desenvolver a construção de um Sistema de Informação

Informática – Programação Orientada a Objetos / Java

Mas, afinal, a quem compete este trabalho?

1.5 O papel do Analista de Sistemas

Um bom analista de sistemas tem como principais características:

 Conhecimento teórico e prático de computação;

 Ampla visão organizacional e empresarial;

 Bom senso na tomada de decisões;

 Bom relacionamento interpessoal para lidar com todos envolvidos no projeto;

Informática – Programação Orientada a Objetos / Java

1.6 Fases do desenvolvimento de sistemas

Nessa fase, são analisados os seguintes questionamentos:

 O sistema poderá contribuir de fato para realização dos objetivos previstos?

 O sistema poderá ser implementando, apesar de restrições de cunho tecnológico, organizacional e

 É possível sua integração a sistemas já em funcionamento?

Informática – Programação Orientada a Objetos / Java

Exemplos de especificações definidas nesta fase:

 Aprimoramento do fluxo de dados da alternativa escolhida;

 Identificação do banco de dados ou arquivos a serem utilizados;

 Detalhamento de arquivos de dados e seus layouts;

 Criação de layouts de relatórios a serem emitidos pelo sistema;

 Especificação de todos os programas que irão compor o sistema;

 Revisão na estimativa de custos;

 Preparação da documentação inicial do sistema;

 Definição dos tipos de dispositivo de armazenamento;

 Elaboração de um plano de testes;

Informática – Programação Orientada a Objetos / Java

Finalmente, chegamos à implantação e manutenção, última fase da criação de um sistema. Implantar

Agora, é apenas manter em pleno funcionamento, desenvolvendo pequenas melhorias e adequações

Informática – Programação Orientada a Objetos / Java

Informática – Programação Orientada a Objetos / Java

Informática – Programação Orientada a Objetos / Java

2.1 Análise de Requisitos