Manual de Programacao Orientada Ao Objecto

MANUAL DO CURSO DE LICENCIATURA EM
Gestão de Sistemas de
Informação
3º Ano
Disciplina: Programação Orientada a Objectos

Código: ISCED1-GSI22
Total Horas/1o Semestre: 150 horas
Créditos (SNATCA):
Número de Temas:
INSTITUTO SUPER
INSTITUTO SUPERIOR DE CIÊNCIAS E EDUCAÇÃO A DISTÂNCIA - ISCED

ISCED CURSO: GESTÃO DE SISTEMAS DE INFORMAÇÃO; 3º Ano
Disciplina/Módulo: Programação Orientada ao Objecto
Direitos de autor (copyright)
Este manual é propriedade do Instituto Superior de Ciências e Educação a Distância (ISCED), e

contém reservados todos os direitos. É proibida a duplicação ou reprodução parcial ou total
deste manual, sob quaisquer formas ou por quaisquer meios (electrónicos, mecânico, gravação,
fotocópia ou outros), sem permissão expressa de entidade editora (Instituto Superior de Ciências
e Educação a Distância (ISCED).
A não observância do acima estipulado o infractor é passível a aplicação de processos judiciais

em vigor no País.
Instituto Superior de Ciências e Educação a Distância (ISCED)

Direcção Académica
Rua Dr. Almeida Lacerda, No 212 Ponta - Gêa
Beira - Moçambique
Telefone: +258 23 323501
Cel: +258 82 3055839
Fax: 23323501
E-mail: isced@isced.ac.mz
Website: www.isced.ac.mz
i
Agradecimentos
O Instituto Superior de Ciências e Educação a Distância (ISCED) agradece a colaboração dos

seguintes indivíduos e instituições na elaboração deste manual:
Autor Maiden Djento Mário Pereira Alfinete
Direcção Académica do ISCED

Coordenação
Instituto Superior de Ciências e Educação a Distância (ISCED)
Design
Instituto Africano de Promoção da Educação a Distância (IAPED)
Financiamento e Logística
Revisão Científica e XXXXX

Linguística
Ano de Publicação 2018
Local de Publicação ISCED – BEIRA
ii
Visão geral 1
Bem vindo à Disciplina/Módulo de Programação Orientada ao Objecto ........................ 1
Objectivos do Módulo ....................................................................................................... 1
Quem deveria estudar este módulo .................................................................................. 2
Como está estruturado este módulo .................................................................................. 2
Ícones de actividade.......................................................................................................... 3
Habilidades de estudo ...................................................................................................... 4
Precisa de apoio? .............................................................................................................. 5
Tarefas (avaliação e auto-avaliação) ............................................................................... 6
Avaliação .......................................................................................................................... 7
TEMA – I: CONCEITOS E FUNDAMENTOS BÁSICOS DE PROGRAMAÇÃO EM JAVA 9

UNIDADE Temática 1.1. A linguagem Java. ...................................................................... 9
Introdução .......................................................................................................................... 9
Sumário............................................................................................................................ 12
Exercícios ......................................................................................................................... 12
UNIDADE Temática 1.2. Variáveis e constantes e tipos de dados primitivos. ................. 13
Introdução ........................................................................................................................ 13
Sumário............................................................................................................................ 18
Exercícios ......................................................................................................................... 18
UNIDADE Temática 1.3. Operadores. ............................................................................. 19
Introdução ........................................................................................................................ 19
Sumário............................................................................................................................ 29
Exercícios ......................................................................................................................... 29
UNIDADE Temática 1.4. Estrutura de controlo de fluxo em Java. ................................... 30
Introdução ........................................................................................................................ 30
Sumário............................................................................................................................ 46
Exercícios ......................................................................................................................... 46
Exercícios do TEMA .......................................................................................................... 47
TEMA – II: GESTÃO DE ERROS E EXCEPÇÕES 48

UNIDADE Temática 2.1. Try/Catch;................................................................................. 48
Introdução ........................................................................................................................ 48
Sumário............................................................................................................................ 55
Exercícios ......................................................................................................................... 55
UNIDADE Temática 2.2. Bloco “finally”; .......................................................................... 56
Sumário............................................................................................................................ 57
Exercícios ......................................................................................................................... 57
TEMA – III: Graphical User Interface 59

UNIDADE Temática 3.1. A linguagem Java. .................................................................... 59
Introdução ........................................................................................................................ 59
Sumário............................................................................................................................ 63
iii
Exercícios de AUTO-AVALIAÇÃO .................................................................................... 63

UNIDADE Temática 3.2. Limitando caracteres com JTextField. ....................................... 64
Introdução ........................................................................................................................ 64
Sumário............................................................................................................................ 72
Exercícios para AVALIAÇÃO ............................................ Erro! Marcador não definido.
Exercícios do TEMA ........................................................... Erro! Marcador não definido.
UNIDADE Temática 3.3. Formatando campos com JFormattedTextField. ........................ 73
Introdução ........................................................................................................................ 73
Sumário............................................................................. Erro! Marcador não definido.
Exercícios para AVALIAÇÃO ............................................ Erro! Marcador não definido.
TEMA – V: MINIPROJECTO 80
UNIDADE Temática 4.1. A linguagem Java. .................................................................... 80
Bibliografia 81
iv
Visão geral
Bem vindo à Disciplina/Módulo de Programação

Orientada ao Objecto
Objectivos do Módulo
O objectivo fundamental do modulo de Programação orientada a

Objectos é a transmissão de conhecimentos e criação de habilidades
técnicas que permitam aos alunos uma compreensão clara da forma
a desenvolver aplicações que assentam na implementação em
computador de modelos de objectos do mundo real.
O estudante deverá:
▪ Discutir alternativas de projecto de Linguagens;
▪ Implementar conceitos como abstracção de dados, modularidade
e reusablidade;
Objectivos Específicos
▪ Desenvolver técnicas de implementação de linguagens;
▪ Ter uma visão geral dos paradigmas imperativa, orientado a
objectos e funcional;
▪ Construir GUI adequados aos seus programas de acordo com os
princípios de interface homem-máquina;
▪ Sistematizar a utilização das estruturas de dados na resolução de
categorias de problemas;
▪ Saber escolher, comparar, conceber e utilizar estruturas de dados
adequadas ao problema a resolver;
▪ Conhecer a programação em Java e resolver problemas
adequados a programas de média dimensão;
▪ Conhecer a modelação orientada a objectos (O O) e usá-la para
resolver problemas com aplicação da programação O O em Java.
▪ Implementa linguagens formais;
▪ Tem uma visão geral dos paradigmas de programação mais
usuais;
▪ Trabalha com a linguagem java.
1
Quem deveria estudar este módulo
Este Módulo foi concebido para estudantes do 3º ano do curso de

licenciatura em Gestão de Sistemas de Informação do ISCED. Poderá
ocorrer, contudo, que haja leitores que queiram se actualizar e
consolidar seus conhecimentos nessa disciplina, esses serão bem-
vindos, não sendo necessário para tal se inscrever. Mas poderá
adquirir o manual.
Como está estruturado este módulo
Este módulo de Programação Orientada a Objectos, para

estudantes do 3º ano do curso de licenciatura em Gestão de Sistemas
de Informação, à semelhança dos restantes do ISCED, está
estruturado como se segue:
Páginas introdutórias
▪ Um índice completo.
▪ Uma visão geral detalhada dos conteúdos do módulo, resumindo
os aspectos-chave que você precisa conhecer para melhor
estudar. Recomendamos vivamente que leia esta secção com
atenção antes de começar o seu estudo, como componente de
habilidades de estudos.
Conteúdo desta Disciplina / módulo
Este módulo está estruturado em Temas. Cada tema, por sua vez
comporta certo número de unidades temáticas ou simplesmente
unidades. Cada unidade temática se caracteriza por conter uma
introdução, objectivos, conteúdos.
No final de cada unidade temática ou do próprio tema, são
incorporados antes o sumário, exercícios de auto-avaliação, só
depois é que aparecem os exercícios de avaliação.
Os exercícios de avaliação têm as seguintes características: Puros
exercícios teóricos/Práticos, Problemas não resolvidos e actividades
práticas, incluído estudo de caso.
2
Outros recursos
A equipa dos académicos e pedagogos do ISCED, pensando em si,

num cantinho, recôndito deste nosso vasto Moçambique e cheio de
dúvidas e limitações no seu processo de aprendizagem, apresenta
uma lista de recursos didácticos adicionais ao seu módulo para você
explorar. Para tal o ISCED disponibiliza na biblioteca do seu centro
de recursos mais material de estudos relacionado com o seu curso
como: Livros e/ou módulos, CD, CD-ROM, DVD. Para além deste
material físico ou electrónico disponível na biblioteca, pode ter
acesso a Plataforma digital moodle para alargar mais ainda as
possibilidades dos seus estudos.
Auto-avaliação e Tarefas de avaliação
Tarefas de auto-avaliação para este módulo encontram-se no final

de cada unidade temática e de cada tema. As tarefas dos exercícios
de auto-avaliação apresentam duas características: primeiro
apresentam exercícios resolvidos com detalhes. Segundo, exercícios
que mostram apenas respostas.
Tarefas de avaliação devem ser semelhantes às de auto-avaliação,
mas sem mostrar os passos e devem obedecer o grau crescente de
dificuldades do processo de aprendizagem, umas a seguir a outras.
Parte das tarefas de avaliação será objecto dos trabalhos de campo
a serem entregues aos tutores/docentes para efeitos de correcção e
subsequentemente nota. Também constará do exame do fim do
módulo. Pelo que, caro estudante, fazer todos os exercícios de
avaliação é uma grande vantagem.
Comentários e sugestões
Use este espaço para dar sugestões valiosas, sobre determinados

aspectos, quer de natureza científica, quer de natureza didáctico-
Pedagógica, etc., sobre como deveriam ser ou estar apresentadas.
Pode ser que graças as suas observações que, em gozo de confiança,
classificamo-las de úteis, o próximo módulo venha a ser melhorado.
Ícones de actividade
Ao longo deste manual irá encontrar uma série de ícones nas margens
das folhas. Estes ícones servem para identificar diferentes partes do
processo de aprendizagem. Podem indicar uma parcela específica
de texto, uma nova actividade ou tarefa, uma mudança de
actividade, etc.
3
Habilidades de estudo
O principal objectivo deste campo é o de ensinar aprender a

aprender. Aprender aprende-se.
Durante a formação e desenvolvimento de competências, para

facilitar a aprendizagem e alcançar melhores resultados, implicará
empenho, dedicação e disciplina no estudo. Isto é, os bons resultados
apenas se conseguem com estratégias eficientes e eficazes. Por isso é
importante saber como, onde e quando estudar. Apresentamos
algumas sugestões com as quais esperamos que caro estudante possa
rentabilizar o tempo dedicado aos estudos, procedendo como se
segue:
1º Praticar a leitura. Aprender a Distância exige alto domínio de

leitura.
2º Fazer leitura diagonal aos conteúdos (leitura corrida).
3º Voltar a fazer leitura, desta vez para a compreensão e

assimilação crítica dos conteúdos (ESTUDAR).
4º Fazer seminário (debate em grupos), para comprovar se a sua

aprendizagem confere ou não com a dos colegas e com o padrão.
5º Fazer TC (Trabalho de Campo), algumas actividades práticas ou

as de estudo de caso se existirem.
IMPORTANTE: Em observância ao triângulo modo-espaço-tempo,

respectivamente como, onde e quando...estudar, como foi referido
no início deste item, antes de organizar os seus momentos de estudo
reflicta sobre o ambiente de estudo que seria ideal para si: Estudo
melhor em casa/biblioteca/café/outro lugar? Estudo melhor à
noite/de manhã/de tarde/fins-de-semana/ao longo da semana?
Estudo melhor com música/num sítio sossegado/num sítio barulhento!?
Preciso de intervalo em cada 30 minutos, em cada hora, etc.
É impossível estudar numa noite tudo o que devia ter sido estudado
durante um determinado período de tempo; deve estudar cada ponto
da matéria em profundidade e passar só ao seguinte quando achar
que já domina bem o anterior.
Privilegia-se saber bem (com profundidade) o pouco que puder ler e

estudar, que saber tudo superficialmente! Mas a melhor opção é
juntar o útil ao agradável: Saber com profundidade todos conteúdos
de cada tema, no módulo.
4
Dica importante: não recomendamos estudar seguidamente por

tempo superior a uma hora. Estudar por tempo de uma hora
intercalado por 10 (dez) a 15 (quinze) minutos de descanso (chama-
se descanso à mudança de actividades). Ou seja, que durante o
intervalo não se continuar a tratar dos mesmos assuntos das
actividades obrigatórias.
Uma longa exposição aos estudos ou ao trabalho intelectual

obrigatório pode conduzir ao efeito contrário: baixar o rendimento
da aprendizagem. Por que o estudante acumula um elevado volume
de trabalho, em termos de estudos, em pouco tempo, criando
interferência entre os conhecimentos, perde sequência lógica, por fim
ao perceber que estuda tanto, mas não aprende, cai em insegurança,
depressão e desespero, por se achar injustamente incapaz!
Não estude na última da hora; quando se trate de fazer alguma

avaliação. Aprenda a ser estudante de facto (aquele que estuda
sistematicamente), não estudar apenas para responder a questões de
alguma avaliação, mas sim estude para a vida, sobre tudo, estude
pensando na sua utilidade como futuro profissional, na área em que
está a se formar.
Organize na sua agenda um horário onde define a que horas e que

matérias deve estudar durante a semana; Face ao tempo livre que
resta, deve decidir como o utilizar produtivamente, decidindo quanto
tempo será dedicado ao estudo e a outras actividades.
É importante identificar as ideias principais de um texto, pois será

uma necessidade para o estudo das diversas matérias que compõem
o curso: A colocação de notas nas margens pode ajudar a estruturar
a matéria de modo que seja mais fácil identificar as partes que está
a estudar e Pode escrever conclusões, exemplos, vantagens,
definições, datas, nomes, pode também utilizar a margem para
colocar comentários seus relacionados com o que está a ler; a melhor
altura para sublinhar é imediatamente a seguir à compreensão do
texto e não depois de uma primeira leitura; Utilizar o dicionário
sempre que surja um conceito cujo significado não conhece ou não lhe
é familiar;
Precisa de apoio?
Caro estudante, temos a certeza que por uma ou por outra razão, o
material de estudos impresso, lhe pode suscitar algumas dúvidas como
falta de clareza, alguns erros de concordância, prováveis erros
ortográficos, falta de clareza, fraca visibilidade, página trocada ou
invertidas, etc.). Nestes casos, contacte os serviços de atendimento e
apoio ao estudante do seu Centro de Recursos (CR), via telefone, SMS,
5
E-mail, se tiver tempo, escreva mesmo uma carta participando a

preocupação.
Uma das atribuições dos Gestores dos CR e seus assistentes
(Pedagógico e Administrativo), é a de monitorar e garantir a sua
aprendizagem com qualidade e sucesso. Dai a relevância da
comunicação no Ensino a Distância (EAD), onde o recurso as TIC’s se
tornam incontornável: entre estudantes, estudante – Tutor, estudante –
CR, etc.
As sessões presenciais são um momento em que você caro estudante,
tem a oportunidade de interagir fisicamente com staff do seu CR, com
tutores ou com parte da equipa central do ISCED indigitada para
acompanhar as suas sessões presenciais. Neste período pode
apresentar dúvidas, tratar assuntos de natureza pedagógica e/ou
administrativa.
O estudo em grupo, que está estimado para ocupar cerca de 30%
do tempo de estudos a distância, é muita importância, na medida em
que lhe permite situar, em termos do grau de aprendizagem com
relação aos outros colegas. Desta maneira ficará a saber se precisa
de apoio ou precisa de apoiar aos colegas. Desenvolver hábito de
debater assuntos relacionados com os conteúdos programáticos,
constantes nos diferentes temas e unidade temática, no módulo.
Tarefas (avaliação e auto-avaliação)
O estudante deve realizar todas as tarefas (exercícios, actividades e

auto−avaliação), contudo nem todas deverão ser entregues, mas é
importante que sejam realizadas. As tarefas devem ser entregues
duas semanas antes das sessões presenciais seguintes.
Para cada tarefa serão estabelecidos prazos de entrega, e o não
cumprimento dos prazos de entrega, implica a não classificação do
estudante. Tenha sempre presente que a nota dos trabalhos de campo
conta e é decisiva para ser admitido ao exame final da
disciplina/módulo.
Os trabalhos devem ser entregues ao Centro de Recursos (CR) e os
mesmos devem ser dirigidos ao tutor/docente.
Podem ser utilizadas diferentes fontes e materiais de pesquisa,
contudo os mesmos devem ser devidamente referenciados,
respeitando os direitos do autor.
O plágio1 é uma violação do direito intelectual do(s) autor(es). Uma
transcrição à letra de mais de 8 (oito) palavras do testo de um autor,
sem o citar é considerado plágio. A honestidade, humildade científica
1
Plágio - copiar ou assinar parcial ou totalmente uma obra literária, propriedade
intelectual de outras pessoas, sem prévia autorização.
6
e o respeito aos direitos autorais devem caracterizar a realização

dos trabalhos e seu autor (estudante do ISCED).
Avaliação
Muitos perguntam: Com é possível avaliar estudantes à distância,

estando eles fisicamente separados e muito distantes do
docente/tutor! Nós dissemos: Sim é muito possível, talvez seja uma
avaliação mais fiável e consistente.
Você será avaliado durante os estudos à distância que contam com
um mínimo de 90% do total de tempo que precisa de estudar os
conteúdos do seu módulo. Quando o tempo de contacto presencial
conta com um máximo de 10%) do total de tempo do módulo. A
avaliação do estudante consta detalhada do regulamentado de
avaliação.
Os trabalhos de campo por si realizados, durante estudos e
aprendizagem no campo, pesam 25% e servem para a nota de
frequência para ir aos exames.
Os exames são realizados no final da cadeira disciplina ou modulo e
decorrem durante as sessões presenciais. Os exames pesam no mínimo
75%, o que adicionado aos 25% da média de frequência,
determinam a nota final com a qual o estudante conclui a cadeira.
A nota de 10 (dez) valores é a nota mínima de conclusão da cadeira.
Nesta cadeira o estudante deverá realizar pelo menos 2 (dois)
trabalhos e 1 (um) (exame).
Algumas actividades práticas, relatórios e reflexões serão utilizados
como ferramentas de avaliação formativa.
Durante a realização das avaliações, os estudantes devem ter em
consideração a apresentação, a coerência textual, o grau de
cientificidade, a forma de conclusão dos assuntos, as recomendações,
a identificação das referências bibliográficas utilizadas, o respeito
aos direitos do autor, entre outros.
Os objectivos e critérios de avaliação constam do Regulamento de
Avaliação.
7
TEMA – I: CONCEITOS E FUNDAMENTOS BÁSICOS DE PROGRAMAÇÃO EM JAVA
UNIDADE Temática 1.1. A linguagem Java.

UNIDADE Temática 1.2. Variáveis e constantes e tipos de dados
primitivos.
UNIDADE Temática 1.3. Operadores.
UNIDADE Temática 1.4. Estrutura de controlo de fluxo em Java.
UNIDADE Temática 1.5. EXERCÍCIOS deste tema
Introdução
A tecnologia Java é usada para desenvolver aplicativos para uma ampla

variedade de ambientes, de dispositivos consumidores a sistemas corporativos
heterogéneos. Nesta seção, obtenha uma visualização de alto nível da
Objectivos
específicos plataforma Java e seus componentes.
1.1.1. A linguagem Java
A maioria dos desenvolvedores Java constantemente consultam a documentação

on-line oficial da API Java, também chamada de Javadoc. Por padrão, você vê
três áreas de janela no Javadoc. A área de janela superior esquerda mostra
todos os pacotes na API e a área de janela inferior esquerda mostra as classes
em cada pacote. A área de janela principal (à direita) mostra os detalhes do
pacote ou classe actualmente seleccionados. Por exemplo, se você clicar no
pacote java.util na área de janela superior esquerda e clicar na classe ArrayList
listada abaixo dele, verá os detalhes sobre ArrayList na área de janela direita,
incluindo uma descrição do que ela faz, como usá-la e seus métodos.
Como qualquer linguagem de programação, a linguagem Java tem sua própria

estrutura, regras de sintaxe e paradigma de programação. O paradigma de
programação da linguagem Java baseia-se no conceito de OOP, que os
recursos da linguagem suportam. A linguagem Java deriva da linguagem C,
portanto suas regras de sintaxe assemelham-se às regras de C. Por exemplo,
os blocos de códigos são modularizados em métodos e delimitados por chavetas
({ e }) e variáveis são declaradas antes que sejam usadas.
9
Estruturalmente, a linguagem Java começa com pacotes. Um pacote é o

mecanismo de namespace da linguagem Java. Dentro dos pacotes estão as
classes e dentro das classes estão métodos, variáveis, constantes e mais. Neste
tutorial você aprende sobre as partes da linguagem Java.
1.1.2. O compilador Java
Quando você programa na plataforma Java, escreve seu código-fonte em

arquivos .java e depois os compila. O compilador verifica seu código nas regras
de sintaxe da linguagem e depois grava byte code em arquivos. class. Bytecode
é um conjunto de instruções destinadas a executar em uma Java virtual machine
(JVM). Ao incluir esse nível de abstracção, o compilador Java difere-se de
outros compiladores de linguagem, que escrevem instruções adequadas para o
chipset de CPU no qual o programa é executado.
1.1.3. A JVM
No tempo de execução, a JVM lê e interpreta arquivos .class e executa as

instruções do programa na plataforma de hardware nativa para qual a JVM
foi escrita. A JVM interpreta o bytecode como uma CPU interpretaria instruções
de linguagem assembly. A diferença é que a JVM é uma parte do software
escrita especificamente para uma determinada plataforma. A JVM é o núcleo
do princípio "gravação única, execução em qualquer local" da linguagem Java.
Seu código pode executar em qualquer chipset para o qual a implementação
da JVM adequada está disponível. JVM’s estão disponíveis para principais
plataformas, como Linux e Windows, e subconjuntos de linguagem Java foram
implementados nas JVM’s para telefones celulares e chips hobbyist.
1.1.4. O colector de lixo
Em vez de forçá-lo a manter a alocação de memória (ou usar uma biblioteca

de terceiros para isso), a plataforma Java fornece gerenciamento de memória
fora do padrão. Quando seu aplicativo Java cria uma instância de objecto no
tempo de execução, a JVM aloca automaticamente espaço de memória para
esse objecto a partir de um conjunto de memória heap— reservado para uso
de seu programa. O colector de lixo Java é executado em segundo plano,
mantendo o controle de quais objectos o aplicativo não necessita mais e
recuperando memória deles. Essa abordagem para manipulação de memória
10
é chamada de gerenciamento implícito de memória porque não exige a

gravação de qualquer código de manipulação de memória. A colecta de lixo
é um dos recursos essenciais para o desempenho da plataforma Java.
1.1.5. O Java Development Kit
Java Development Kit (JDK) significa Kit de Desenvolvimento Java, e é um

conjunto de utilitários que permitem criar sistemas de software para a
plataforma Java), você obtém, — além do compilador e de outras ferramentas,
— uma biblioteca de classe completa de utilitários de pré-construção que o
ajuda a realizar tarefas de desenvolvimento de aplicativo mais comuns. A
melhor forma de obter uma ideia do escopo dos pacotes e bibliotecas JDK é
verificar a documentação da API JDK.
1.1.6. O Java Runtime Environment
O Java Runtime Environment (JRE; também conhecido como o tempo de

execução Java) inclui a JVM, bibliotecas de códigos e componentes necessários
para executar programas que são escritos na linguagem Java. O JRE está
disponível para diversas plataformas. É possível redistribuir livremente o JRE
com seus aplicativos, de acordo com os termos da licença do JRE, para fornecer
aos usuários do aplicativo uma plataforma na qual executar seu software. O
JRE está incluído no JDK.
11
Sumário
Nesta Unidade temática 1.1 estudamos e discutimos fundamentalmente

o que é a linguagem de programação java e como qualquer linguagem
de programação, a linguagem Java tem sua própria estrutura, regras de
sintaxe e paradigma de programação. O paradigma de programação
da linguagem Java baseia-se no conceito de OOP, que os recursos da
linguagem suportam.
Também falamos de compilador que verifica seu código nas regras de
sintaxe da linguagem e depois grava byte code em arquivos. class. E
Java Runtime Environment (JRE; também conhecido como o tempo de
execução Java) inclui a JVM, bibliotecas de códigos e componentes
necessários para executar programas que são escritos na linguagem
Java.
Exercícios
1. Defina em suas próprias palavras JAVA.

2. O que entendeste sobre o conceito de OOP?
3. Qual é a função de JVM (Java Virtual Machine)?
4. Para alem de ser um conjunto de bibliotecas o que pode se
obter com o JDK?
5. Em que linguagens de programação podemos desenvolver uma
aplicação com o uso de programação orientada a objectos?
12
UNIDADE Temática 1.2. Variáveis e constantes e tipos de dados primitivos.
Introdução
1.2.1. Constantes
Ao escrever aplicações (programas) precisamos, via de regra, referenciar valores.

Objectivos Para tal usamos identificadores (nomes) aos quais são associados valores. Os
específicos identificadores são, então, utilizados em operações. Um identificador representa
sempre o último valor a ele associado e não a série histórica de valores associados.
Ao associarmos um novo valor a um identificador, a associação anterior se desfaz.
Assim, o identificador em questão não pode mais ser utilizado para manipular o
valor anteriormente associado.
Um identificador que pode ter a sua associação com um valor refeita zero ou mais
vezes é chamado de variável. Se uma variável não tiver ainda um valor associado,
então dizemos que ela está indefinida. Ao escrevermos uma aplicação podemos
associar um valor a um identificador e especificar que tal associação não pode
mais ser desfeita. Neste caso dizemos que tal identificador representa uma
constante.
Uma aplicação pode manipular valores de naturezas distintas tais como caracteres,
inteiros e reais. O uso pretendido de uma variável deve ser declarado para
orientar o compilador no processo de análise sintáctica do "código fonte" (isto é,
código escrito em uma linguagem de programação de alto nível de abstracção) e
de geração de "código objecto" (isto é, código em linguagem de máquina). A
declaração de uso pretendido se dá através da definição de um tipo para cada
identificador utilizado para representar um valor. Um tipo caracteriza o universo
de valores válidos que podem ser associados a identificadores definidos como
sendo do tipo em questão.
1.2.2. Variáveis
Na maioria dos programas que escrevemos, não estamos interessados em apenas

mostrar uma caixa de mensagens para o usuário. Queremos também armazenar e
processar informações.
13
Em um sistema bancário, por exemplo, estaríamos interessados em armazenar o

saldo de uma conta e o nome do dono da conta. Para armazenar esses dados,
precisamos pedir para o JAVA reservar regiões de memória que serão utilizadas
para armazenar informações. Essas regiões de memória são conhecidas como
variáveis.
As variáveis guardam informações de um tipo específico. Podemos, por exemplo,

guardar um número inteiro representando o número da conta, um texto para
representar o nome do dono da conta ou um número real para representar o saldo
actual da conta. Para utilizar uma variável, devemos primeiramente declará-la no
texto do programa.
Na declaração de uma variável, devemos dizer seu tipo (inteiro, texto ou real, por
exemplo) e, além disso, qual é o nome que usaremos para referenciá-la no texto
do programa. Para declarar uma variável do tipo inteiro que representa o número
de uma conta, utilizamos o seguinte código:
int numeroDaConta;
Repare no ; (ponto e virgula) no final da linha. Como a declaração de uma variável

é um comando da linguagem JAVA, precisamos do; (ponto e virgula) para terminá-
lo. Além do tipo int (para representar inteiros), temos também os tipos double e
float (para números reais), String (para textos), entre outros.
Depois de declarada, uma variável pode ser utilizada para armazenar valores.
Por exemplo, se estivéssemos interessados em guardar o valor 1 na variável
numeroDaConta que declaramos anteriormente, utilizaríamos o seguinte código:
numeroDaConta = 1;
Lê-se "numeroDaConta recebe 1". Quando, no momento da declaração da

variável, sabemos qual será seu valor, podemos utilizar a seguinte sintaxe para
declarar e atribuir o valor para a variável.
double saldo = 100.0;
14
1.2.2.1 Operações com variáveis
Agora que já sabemos como guardar informações no programa, estamos

interessados em executar operações nesses valores. Pode ser interessante para um
usuário saber qual será o saldo de sua conta após um levantamento de 10 meticais.
Para realizar essa operação, devemos subtrair 10 meticais do saldo da conta:
saldo = saldo - 10.0;
Nesse código, estamos a guardar na variável saldo o valor da conta 100.0 (saldo
antigo) menos 10.0 então seu valor final será de 90.0. Da mesma forma que
podemos subtrair valores, podemos também fazer somas (com o operador +),
multiplicações (operador *) e divisões (operador /).
Podemos ainda guardar o valor do saque em uma variável:
double valorDoLevantamento = 10.0;
saldo = saldo - valorDoLevantamento;
Depois de realizar o levantamento, queremos mostrar para o usuário qual é o saldo

actual da conta. Para mostrarmos essa informação, utilizaremos o método
System.out.print():
System.out.print ("O saldo da conta após o levantamento é: "

+ saldo);
15
1.2.3. Tipos de Dados Primitivos
Observamos que no Java toda variável possui um tipo, utilizamos o int quando
queremos armazenar valores inteiros e double para números reais. Agora vamos
descobrir quais são os outros tipos de variáveis do Java.
Os tipos listados nessa tabela são conhecidos como tipos primitivos ou value types
da linguagem Java. Toda vez que atribuímos um valor para uma variável de um
tipo primitivo, o Java copia o valor atribuído para dentro da variável.
Agora que conhecemos os tipos primitivos da linguagem Java, vamos ver como é
que eles interagem dentro de uma aplicação. Suponha que temos um código que
declara uma variável do tipo inteiro e depois tenta copiar seu conteúdo para uma
variável long:
int valor = 1;
long valorGrande = valor;
Nesse caso, como o tamanho de uma variável long é maior do que o de uma
variável int, o Java sabe que podemos copiar o seu conteúdo sem perder
16
informações e, por isso, esse é um código que compila sem nenhum erro. Agora
vamos tentar copiar o int para uma variável do tipo short:
int valor = 1;
short valorPequeno = valor;
Nesse código, tentamos copiar o conteúdo de uma variável maior para dentro de
uma de tamanho menor. Essa cópia pode ser perigosa pois o valor que está na
variável do tipo int pode não caber na variável short e, por isso, o compilador do
Java gera um erro de compilação quando tentamos fazer essa conversão.
Para forçarmos o compilador do Java a fazer uma conversão perigosa, precisamos

utilizar uma operação do Java chamada casting falando para qual tipo queremos
fazer a conversão.
int valor = 1;
short valorPequeno = (short) valor;
17
Sumário
Nesta Unidade temática definimos variáveis e constantes e tipos de

dados primitivos, e onde estabelecemos que variável é um espaço na
memoria que usamos para armazenar uma informação que pode variar
enquanto que constante é o mesmo mais ao invés de armazenar valores
que varia armazém valores fixos, a titulo de exemplo o PI.
Também listamos e vimos exemplos de vários tipos de dados primitivos.
Exercícios
1. Por suas palavras define uma constante.

2. Diferencie uma constante de uma variável.
3. Quais são os tipos de variais que vimos?
4. Faça uma lista de 5 variáveis e indique o seu tamanho em bytes.
5. O que acontece quando temos uma variável com um tamanho
menor e tentamos operar com uma variável de tamanho maior?
6. Qual é a diferença entre dados numéricos inteiros e os decimais?
18
UNIDADE Temática 1.3. Operadores.
Introdução
Operadores são símbolos que representam atribuições, cálculos e ordem dos

dados. As operações seguem uma ordem de prioridades, ou seja, alguns
cálculos (ou outros) são processados antes de outros. Por exemplo, na Álgebra
Objectivos
específicos podemos mostrar a seguinte ordem:
Ordem Operadores Operação
1 / * Divisão e multiplicação
2 + - Soma e subtracção
Assim, as operações de divisão e multiplicação, por serem de ordem 1, serão

executadas antes das operações de soma e subtracção (ordem 2). Também, as
operações de divisão e multiplicação são de mesma ordem (1) e não importa,
entre si, a ordem da operação (2 dividido por 4 vezes 9 é igual a 2 vezes 9
dividido por 4).
1.3.1. Tipo
Os operadores são divididos em 3 tipos em relação à quantidade de

operandos no qual operam: unário, binário e ternário.
int a = 5, b = 2, c = 0; // -- é um operador unário pois

opera apenas em a;
a--;
c = a * b; // * é um operador binário pois

opera em a e b.
c = c < 0 ? a : b; // ?: é O operador ternário. Opera

em na expressão booleana (c < 0), e
em a ou b.
19
1.3.2. Precedência
2. Precedência indica a ordem na qual um operador opera em relação à

avaliação de uma expressão.
A tabela seguinte elenca os operadores por precedência, do maior para o

menor.
Tipo de Operador Lista de Operadores
Sufixais expr++ expr--
Prefixais ++expr --expr +expr -expr ~ !
Multiplicativos */%
Aditivos +-
Shift Binário << >> >>>
Comparativos < > <= >= instanceof
igualdade == !=
Bit-aBit E &
Bit-aBit XOU OR ^
Bit-aBit OU OR
|
Lógico E &&
Lógico OU ||
Ternário ?
Atribuição = += -= *= /= %= &= ^= |= <<= >>= >>>=
3.
20
4. Precedência 13: operadores sufixais
5. São operadores unários posicionados após o identificador da variável para

incrementar ++ ou decrementar -- uma variável de tipo numérico em 1. Não
podem ser utilizados em variáveis do tipo String, boolean ou de referência.
Também não podem ser utilizados em valores de expressão e em literais.
Diferente dos operadores de pré incremento/decremento, esses operadores
sufixais retornam o valor original da variável para a expressão e depois
realizam a operação sobre a variável.
int numero = 5; //A variável número é inicializada com 5.
System.out.println(numero++); //É exibido 5, o valor

original, e então a variável é actualizada para 6.
System.out.println(numero); //É exibido 6, valor

incrementado na instrução anterior.
6. Precedência 12: operadores prefixais
São operadores unários que alteram o valor de uma variável e seus sinais são
posicionados antes do identificador da variável. Como exemplo, pode-se citar
o Incremento ++, Decremento --, Sinal Positivo +, Sinal Negativo -, Inversão e
Incremento ~ e Negação !. O incremento e decremento, já vimos o que faz. Eles
estão sendo citados aqui novamente porque seus sinais podem vir antes de
variáveis também e numa operação complexa (com outros operadores binários)
alteram a precedência da operação. O Sinal Positivo +retorna a variável que
vem depois dele com o mesmo sinal, o Sinal Negativo - inverte o sinal de
variáveis transformando números positivos em negativo e vice-versa. Ele não
pode ser usado em variáveis dos tipos booleano e char. O Incremento e Inversão
~ aumenta o número em uma unidade e inverte o seu sinal. Só pode ser usado
em inteiros. Já a operação de negação ! transforma "verdadeiro" em "falso" e
vice-versa, só podendo ser usado em variáveis do tipo booleano. Também só
funcionam em variáveis, não em literais. Exemplos de uso:
21
int numero=5; //numero contém 5
boolean ligado=false; //ligado contém "falso"
++numero; //numero agora vale 6
--numero; //numero passa a valer 5
numero=+numero; //numero continua valendo 5
numero=-numero; //numero passa a valer -5
numero=~numero; //numero passa a valer 4
ligado=!ligado; //ligado passa a representar o

valor "true"
Observação: uma diferença importante entre os operadores '++' e '--'

prefixais e sufixais é o tempo de avaliação da expressão comparado com a
alteração da variável. A saber:
int x = 5; // x contém 5
int y, z; // y e z não foram definidos
y = x++; // primeiro faz y igual ao valor (anterior)

de x, e depois modifica x
z = ++x; // primeiro modifica x, e depois atribui a

z o novo valor de x
7. Neste exemplo, temos que, ao final x vale 7 (duas vezes incrementado), y vale
5 (o valor inicial de x) e z vale 7 (o valor final de x). Deve-se evitar usar mais
de um operador prefixal e sufixal na mesma linha, porque isto torna o código
incompreensível, por exemplo: x = (y++ + ++z - --x) + ++y.
8.
9. Precedência 11: operadores multiplicativos
São operadores que realizam uma operação igual ou semelhante à

multiplicação. Exemplos de operações do tipo são a Multiplicação (*), a Divisão
(/) e o Resto (%). O primeiro pode realizar a multiplicação entre dois valores
22
que não sejam do tipo boolean e nem do tipo char. O segundo pode dividir o
primeiro número pelo segundo. Também não pode ser usado em valores
booleans ou char. O terceiro retorna o resto da divisão do primeiro pelo
segundo. Exemplos de uso:
int numero=5; //numero passa a valer 5
numero=numero*4; //numero assume o valor 20
numero=200/numero; //numero assume o valor 10
numero=5%12; //numero assume o valor 5
Precedência 10: operadores aditivos
São operadores que realizam alguma operação igual ou equivalente à adição.

Assim como os Operadores Multiplicativos, os Aditivos podem ser usados tanto
em variáveis como em literais (quando fazem a concatenação de strings). Mas
também não podem ser usados em variáveis char e boolean. Eles também não
alteram as variáveis passadas para eles. No lugar disso, eles retornam um
número que deve ser direcionado par uma variável por meio da operação de
atribuição (veja abaixo). Exemplos de uso:
int numero=5; //numero passa a valer 5
numero=numero+8; //numero passa a valer 13
numero=numero-numero; //numero passa a valer zero
String x="Alo"; // x é inicializado com a string "Alo"
String y="Mundo!"; //y é inicializado com "Mundo!"
x = x + ", " + y; // x passa a valer "Alo, Mundo!"
23
Precedência 9: operadores de shift
São operadores que deslocam os bits de um número de modo a alternar o seu

valor. Exemplos de operadores deste tipo são o Shift para a Direita (>>), o
Shift para a Direita Sem-Sinal(>>>) e o Shift para a Esquerda (<<). O primeiro
valor a ser recebido pelo operador é o número sobre o qual será realizado um
Shift e o segundo número é a quantidade de posições de bits a serem
deslocados. Exemplos de uso:
int numero=-3; //numero vale -3
numero=numero>>1; //numero vale -2
numero=numero<<1; //numero vale -4
numero=numero>>>1; //numero vale 2147483646
numero=numero<<1; //numero vale -4
Precedência 8: operadores comparativos
São operadores que comparam dois números e retornam em seguido o valor

booleano "verdadeiro" ou "falso". Como exemplo, pode-se citar o Menor que
(<), Maior que (>), Menor ou Igual que (<=), Maior ou Igual que (>=) e Exemplo
de (instanceof). O significado dos quatro primeiros operadores é evidente. Já
a operação Exemplo de, retorna "verdadeiro" se o primeiro operando for um
Objecto pertencente à classe passada como segundo operando e "falso" caso
contrário. Exemplos de uso:
boolean variavel;
variavel=(4<4); //variavel recebe "falso"
variavel=(4<=4); //variavel recebe "verdadeiro"
variavel=(-1>-3); //variavel recebe "verdadeiro"
variavel=(-4>=0); //variavel recebe "falso"
24
Precedência 7: operadores de igualdade
São semelhantes aos Operadores Comparativos. Eles também recebem números

como operandos e retornam um valor boolean. A diferença é que estes
operadores apenas verificam se as variáveis são iguais ou não. Como exemplos
de operadores assim, pode-se citar o Igual a (==) e Diferente de (!=). Estes
operadores podem ser usados em qualquer tipo de variável, desde que elas
sejam do mesmo tipo. Exemplos de uso:
boolean variavel;
variavel=(-5==5); //variável recebe "falso"
variavel=(2!=45674); //variável recebe "verdadeiro"
Ao utilizar operadores de igualdade com objectos, a comparação é feita entre

suas referências. Dessa forma, dois objectos cognitivamente iguais, podem ser
avaliados como diferentes. Exemplo:
class Pessoa{
String nome;
public Pessoa(String nome){
this.nome = nome;
new Pessoa("miguel") == new Pessoa("miguel") // comparação

avaliada como falsa
Precedência 6, 5 e 4: operadores Bit-aBit
Os Operadores Bit-a-Bit são todos aqueles que realizam suas operações sobre
os bits de um número, e não sobre o seu valor. Existem ao todo três destes
operadores e cada um deles tem um valor de precedência diferente. O que
tem precedência mais alta é o AND bit-a-bit (&). Ele analisa dois bits e retorna
1 se ambos forem iguais à 1 e 0 caso contrário. Depois vem o OR exclusivo bit-
a-bit (^) que retorna 1 se os bits forem diferentes e 0 caso contrário. Por último,
25
vem o operador OR inclusivo (|), que retorna 0 caso ambos os bits valerem 0 e
retorna 1 caso contrário. Estes operadores podem ser usados em qualquer tipo
de dados, desde que possuam o mesmo tamanho em bits. Exemplos de uso:
int numero;
numero=34&435; //numero passa a valer 34
numero=34^46; //numero passa a valer 12
numero=436|547; //numero passa a valer 951
Precedência 3 e 2: operadores AND e OR
Os operadores AND e OR só podem ser usados em variáveis e literais do tipo

boolean. O operador AND (&&) retorna "verdadeiro" quando seus dois
operandos também valem "verdadeiro" e retorna "falso" caso contrário. O
operador OR (||) retorna "falso" quando seus dois operandos são falsos e
retorna "verdadeiro" caso contrário. Exemplos de uso:
boolean variavel;
variavel=(2<45)&&(45<2) //variavel passa a valer "falso"
variavel=(2<45)||(45<2) //variavel passa a valer

"verdadeiro"
Precedência 1: operadores ternários
O operador ternário recebe ao todo três operandos. O primeiro operando

deve possuir necessariamente um valor do tipo boolean. Os outros dois
operandos podem ser de qualquer tipo. Caso o valor do primeiro operando
seja "verdadeiro", o operador retorna um valor igual ao do segundo operando.
Caso o seu valor seja "falso", ele retorna um valor idêntico ao terceiro
operando. Exemplos de uso:
int numero1=245;
int numero2=123;
26
numero1=(numero1>numero2)?numero1:numero2; /* Faz com que a variavel

numero 1 receba sempreo maior valor entre ela mesma e a numero2. Neste
caso, ela receberá o seu próprio valor por ele ser maior*/
Precedência 0: atribuições
Os operadores de atribuição são os mais numerosos e os que tem uma

prioridade menor de serem interpretados. Um exemplo deste operador (=)foi
bastante usado neste capítulo. Ele armazena o valor que aparecer à direita na
variável presente à esquerda. Caso deseje-se que a variável da esquerda
receba o valor dela mesma após passar por alguma operação com um segundo
valor, basta colocar o símbolo da operação antes do sinal "=" e colocar o
segundo valor à direita. Exemplos de uso:
int numero = 3; //numero recebe o valor 3
numero += 7; //numero recebe 3+7. Ou seja, 10.
numero -= 32; //numero recebe o seu valor menos 32. Ou

seja, -22.
numero %= -3; //numero recebe o resto da divisão entre

seu valor e -3. Ou seja, -1.
numero *= 6; //numero recebe o seu valor vezes 6. Ou

seja, -6.
numero /= 2; //numero recebe o seu valor dividido por

2. Ou seja, -3.
Quando em uma mesma linha forem encontrados vários operadores diferentes,

serão executados primeiro aqueles que tiverem maior precedência. Se existirem
operadores com o mesmo valor de precedência, será realizado primeiro aquele
cujo símbolo aparecer primeiro. É possível alterar a ordem natural com que são
feitas as operações através do uso de parênteses. As operações entre
parênteses sempre são realizadas antes.
27
1.3.3. Separadores
Os separadores são sinais que separam, ou sejam, indicam/modificam a ordem

das operações (ou atribuições, ou interpretações etc.) que podem ou não ser
diferentes do comum. Em Álgebra, temos alguns separadores como os seguintes:
Ordem Separadores Descrição
1 , Vírgula
2 () Parenteses
3 [] Colchetes/ Parenteses
rectos
4 {} Chavetas
Separadores em Java
Ordem Separadores Descrição
1 ; Ponto-e-vírgula
1 . Ponto
1 , Virgula
1 () Parenteses
2 [] Parenteses rectos
2 {} Chavetas
28
Sumário
Nesta falamos dos operadores, separadores com um foco nas regras

de precedência para nos facilitar na percepção da logica algébrica
por detrás da Programação Orientada à Objectos
Exercícios
1. Qual deve ser a regra de precedência usada em Java?

2. Quais são os tipos de operadores quando ao numero de
operações?
3. Diga Qual será o valor de numero e expliquei porque.
int numero=5;
numero=numero+8;
numero=numero-numero;
4. Qual é a diferença entre escrever
(5==5) e escrever (5=5)
5. Qual é a função dos separadores?
29
UNIDADE Temática 1.4. Estrutura de controlo de fluxo em Java.
Introdução
Controle de fluxo é a habilidade de ajustar a maneira como um

programa realiza suas tarefas. Por meio de instruções especiais,
chamadas comandos, essas tarefas podem ser executadas
selectivamente, repetidamente ou excepcionalmente. Não fosse o
controle de fluxo, um programa poderia executar apenas uma única
sequência de tarefas, perdendo completamente uma das características
mais interessantes da programação: a dinâmica.
Podemos classificar os comandos aceitos pela linguagem Java em

basicamente quatro categorias:
Comando Palavras-chave
Tomada de decisões if-else, switch-case
Laços ou repetições for, while, do-while
Apontamento e tratamento de try-catch-finally, throw
excepções
outros break, continue, label:,
return
1.4.1. Execução Condicional
A forma mais simples de controle de fluxo é o comando if-else. Ele é

empregado para executar selectivamente ou condicionalmente um outro
comando mediante um critério de selecção. Esse critério é dado por uma
expressão, cujo valor resultante deve ser um dado do tipo booleano, isto
é, true ou false. Se esse valor for true, então o outro comando é
executado; se for false, a execução do programa segue adiante. A
sintaxe para esse comando é
if ([condição])
[comando] // Executado se a condição for true
30
Uma variação do comando if-else permite escolher alternadamente entre

dois outros comandos a executar. Nesse caso, se o valor da expressão
condicional que define o critério de selecção for true, então o primeiro
dos outros dois comandos é executado, do contrário, o segundo.
if([condição])
[comando 1] // Executado se a condição for true
else
[comando 2] // Executado se a condição for false
Por exemplo:
import java.io.StreamTokenizer;
public class sqrt {
public static void main (String [] args) {
double x;
StreamTokenizer inp = new

StreamTokenizer(System.in);
// Lê um dado double a partir do teclado
System.out.print("x = "); System.out.flush();
try {
inp.nextToken();
x = inp.nval;
catch(java.io.IOException e) {
x = 0;
/* Decide se é possível calcular a raiz quadrada

do número dado. Sendo possível, calcula-a. Do
contrário emite uma mensagem de aviso */
If (x >= 0)
31
System.out.println("raiz quadrada de x e " +

sqrt(x));
else
System.out.println("x e negativo");
E se toda uma lista de comandos deve ser executada selectivamente? A

esta altura, convém dizer que há uma maneira bastante conveniente de
agrupar longas sequências de comandos formando uma unidade lógica.
Trata-se da noção de bloco de comandos. Este consiste basicamente de
uma lista de comandos delimitados por chavetas { }. Para efeitos de
programação, um bloco de comandos é interpretado como se fosse um
único comando. Eis alguns exemplos de blocos de comandos:
1. {System.out.print("x = ");
System.out.println(x);}
2. {temp = y; y = x; x = temp;}
Desse modo, podemos fazer também a execução selectiva de blocos de

comandos conforme ilustra o seguinte programa para discutir sobre as
raízes de uma equação do segundo grau ax2+bx+c=0:
public class baskhara {
public static void main (String args []) {
double a, b, c, delta;
StreamTokenizer in = new
/* Requisitando do usuário os dados sobre a

equação a ser analisada. */
try {
System.out.println("Digite os coeficientes da
equação ax^2+bx+c = 0");
32
System.out.print("a = "); System.out.flush();

in.nextToken();
a = in.nval;
System.out.print("b = "); System.out.flush();

in.nextToken();
b = in.nval;
System.out.print("c = "); System.out.flush();

in.nextToken();
c = in.nval;
System.out.println("Falha na entrada dos

dados.");
a = 0; b = 0; c = 0;
/* Calculando o discriminante da equação */

delta = b*b - 4*a*c;
System.out.println(“Equação: ("+a+”)
x^2+("+b+")x+("+c+")" );
/* Decidindo sobre o número de raízes da equação

mediante o valor do discriminante calculado acima */
if (delta > 0) {/* A equação tem duas raízes

reais */
double r, d, x1, x2;
r = Math.sqrt(delta);
d = 2*a;
x1 = (-b - r) / d;
x2 = (-b + r) / d;
33
System.out.println("A equação tem duas

soluções reais: ");
System.out.println(" x1 = " + x1);
System.out.println(" x2 = " + x2);
else
if (delta < 0) /* A equação não tem raízes

reais */
System.out.println("A equação não tem

raízes reais.");
else {/* A equação tem uma raiz real dupla */
double x;
x = -b / (2*a);
System.out.println("A equação tem uma

única raiz real:");
System.out.println(" x1 = x2 = " + x);
System.out.println("Fim da discussão.");
1.4.2. if-then-else compacto
O if-else compacto não é propriamente um comando, mas um operador

que realiza avaliação selectiva de seus operandos, mediante o valor de
uma expressão booleana semelhante à do comando if-else. Se essa
expressão for true, então um primeiro operando é avaliado; se for false
então o segundo operando é avaliado. A sua sintaxe é
[expressão condicional]?[expressão 1]:[expressão 2]
onde [condição condicional] deve resultar em true ou false,

[expressão 1] e [expressão 2] são os operandos, que podem ser
expressões quaisquer. O valor resultante da aplicação do operador if-
34
else compacto é obviamente igual ao valor do operando que tiver sido

avaliado.
Para melhor ilustrar o if-else compacto, consideremos o seguinte

comando:
y = x < 1 ? x*x : 2-x;
Este é logicamente equivalente à seguinte sequência de comandos:
if (x<1) then
y = x*x;
else
y = 2-x;
É importante notar que o if-else compacto é um operador de baixa

precedência, logo o uso de parênteses para separar seus operandos não
é necessário (a menos que mais de um desses operadores esteja presente
na mesma expressão). Porém há casos em que o uso de parênteses para
definir claramente os operandos é essencial. Por exemplo, y = |x|*sin(x),
pode ser codificado como
y = ( x<0 ? -x : x ) * Math.sin(x); /* aqui os

parenteses são essenciais. */
Sem os parênteses, x * Math.sin(x) seria visto pelo operador if-else

compacto como se fosse um único operando, devido à alta precedência
do operador multiplicação.
1.4.3. Execução Selectiva de Múltiplos Comandos
Frequentemente, desejamos que um único comando (ou único bloco de

comandos) de uma lista seja executado mediante um dado critério. Isso
pode ser feito através do aninhamento ou acoplamento de vários
comandos if-else, do seguinte modo:
if ([condição 1])
[comando 1]
else if ([condição 2])
[comandos 2])
35
else if ([condição 3])
[comando 3]
....
else
[comando n]
A presença do último else, juntamente com seu comando, é opcional.

Neste código, o [comando 1] será executado (e os demais saltados)
caso a primeira condição seja true, o [comando 2] será executado (e
os demais saltados) caso a primeira condição seja false e a segunda
condição seja true, e assim sucessivamente. O [comando n] (se
houver) somente será executado (e os demais saltados) caso todas as
condições sejam false. Vejamos um exemplo:
public class sqrt {
public static void main (String args []) {
double x, y;
StreamTokenizer inp = new

/* Desejamos definir y tal que
| x+2, se x < -1,
y = | 1, se -1 <= x < 1,
| x*x, se 1 <= x.
*/
try {
System.out.print("x = "); System.out.flush();

inp.nextToken();
x = inp.nval;
catch(java.io.IOException e){
36
x = 0;
if (x<-1)
y = x+2;
else
if(x<=0)
y = 1;
else
y = x*x;
System.out.println("y = " + y);
1.4.4. Execução Selectiva por Valores
Assim como no caso execução selectiva de múltiplos comandos, há

situações em que se sabe de antemão que as condições assumem o valor
true de forma mutuamente exclusiva, isto é, apenas uma entre as
condições sendo testadas assume o valor true num mesmo momento.
Nesses casos, a linguagem Java (como também as linguagens C, C++ e
Pascal) provê um comando de controle de fluxo bastante poderoso.
Trata-se do comando switch, cuja sintaxe é a seguinte:
switch([expressão]) {
case [constante 1]:
[comando 1]
break;
case [constante 2]:
[comando 2]
break;
37
case [constante n]:
[de comando n]
break;
default:
[comando]
A [expressão] pode ser qualquer expressão válida. Esta é avaliada

e o seu valor resultante é comparado com as constantes distintas
[constante 1], [constante 2], ..., [constante n]. Caso
esse valor seja igual a uma dessas constantes, o respectivo comando é
executado (e todos os demais são saltados). Se o valor for diferente de
todas essas constantes, então o comando presente sob o rótulo default: é
executado (e todos os demais são saltados), caso este esteja presente.
Por exemplo:
public class teste {
public static void main (String args[]) {
int op;
op = 2;
System.out.print("valor de op eh: "+op)
switch(op) {
case 1:
System.out.println("case 1: op="+op);
break;
case 2:
System.out.println("case 2: op="+op);
break;
38
case 3:
System.out.println("case 3"+op);
break;
default:
System.out.println("default: op nao esta no

limite 1..3");
1.4.5. Laço de iteração enquanto/faça
Frequentemente, desejamos que uma tarefa seja executada

repetidamente por um programa enquanto uma dada condição seja
verdadeira. Isso é possível pela utilização do comando while. Este
comando avalia uma expressão condicional, que deve resultar no valor
true ou false. Se o valor for true, então o comando subjacente é
executado; se a expressão for false, então o comando é saltado e a
execução prossegue adiante. A diferença é que após executar o
comando subjacente, a expressão condicional é novamente avaliada e
seu resultado novamente considerado. Desse modo a execução do
comando subjacente se repetirá, até que o valor da expressão
condicional seja false. Observe, porém, que a expressão é avaliada
antes de uma possível execução do comando subjacente, o que significa
que esse comando pode jamais ser executado.
while([condição])
[comando subjacente]
Por exemplo:
// Achar a raiz quadrada de 2 pelo método de

bissecção
public class sqrt2 {
public static void main(String args[]) {
39
double a, b, x=1.5, erro = 0.05;
a = 1; b = 2; /* 1 < (raiz de 2) < 2 */
while( (b-a) > erro ) {
x = (a+b)/2;
if (x*x < 2) /* x < raiz de 2 */
a = x;
else /* x >= raiz de 2 */
b = x;
System.out.println("Valor aproximado de raiz

quadrada de 2: " + x);
Uma das observações importantes é sempre certificar que não ocorra o

laço infinito (um laço que nunca para, pois a condição sempre é
verdadeira). Caso tenha alguma chance de entrar no laço infinito,
coloque um contador ou use o laço for.
1.4.6. Laço de iteração faça/enquanto
Um outro tipo de laço de repetição, similar ao enquanto/faça, é o laço

faça/enquanto. Este é introduzido por um par de comandos do/while
que tem a seguinte sintaxe:
do
[comando]
while([condição]);
Diferente do laço enquanto/faça, este tipo de laço de repetição executa

o comando e em seguida avalia a expressão condicional. A repetição
ocorre se o valor dessa expressão for
40
true. Se esse valor for false, a execução prossegue adiante do

while. Vejamos o seguinte exemplo:
public class Menu {
public static void main(String args[]) {
char op;
int i = 0;
double x = 0;
do {
System.out.println("\nOpcoes:");
System.out.println("p - Atribuir: x = 0.5, i = 2");
System.out.println("n - atribuir: x = -0.2, i = -1");
System.out.println("x - ver o valor de x");
System.out.println("i - ver o valor de i");
System.out.println("f - fim");
System.out.print("Sua escolha: ");

System.out.flush();
try {
op = (char)System.in.read();
System.in.read(); // Para pegar o 'enter'
op = 'q';
switch(op) {
case 'p':
x = 0.5; i = 2;
break;
41
case 'n':
x = -0.2; i = -1;
break;
case 'x':
System.out.println("\n--> x = " + x);
break;
case 'i':
System.out.println("\n--> i = " + i);
break;
case 'f':
break;
default:
System.out.println("\n--> Opcao invalida");
} while(op != 'f');
System.out.println("\nAte logo.");
1.4.7. Laço de iteração com contagem
Em certas situações, precisamos de laços de repetições nos quais alguma

variável é usada para contar o número de iterações. Para essa
finalidade, temos o laço for. Este é o tipo de laço mais geral e mais
complicado disponível na linguagem Java. Sua sintaxe é a seguinte:
for ([expressão 1]; [condição]; [expressão 2])
[comando]
Onde [expressão 1] é chamada expressão de inicialização, [condição]

é uma expressão condicional e [expressão 2] é uma expressão
42
qualquer a ser executado no final de cada iteração. O laço for acima

é equivalente a:
[expressão 1]
while ([condição]) {
[comando]
[expressão 2]
Isto que dizer que o laço for avalia inicialmente a expressão de

inicialização. Em seguida, avalia a expressão condicional. Se o valor
desta for true, então o comando é executado, a segunda expressão é
avaliada em seguida, e finalmente o laço volta a avaliar novamente a
expressão condicional. Do contrário, se o valor da expressão for false, a
execução prossegue adiante do laço for. Este arranjo é muito conveniente
para manter variáveis de contagem, conforme ilustra o seguinte exemplo:
for (i=0; i<n; i++)
System.out.println("V["+i+"]="+v[i]);
Este código imprime os valores de cada elemento v[i] de um vetor v,

para i variando de 0 até n-1. O operador ++ foi utilizado na última
expressão do laço for para somar um ao valor da variável de contagem.
Caso necessitássemos de um incremento (ou decremento) maior do que
um, poderíamos usar os operadores += ou -=. Por exemplo, para
imprimir todos os números pares entre de 0 até 10, poderíamos fazer:
for(i=0; i<=10; i+=2)
System.out.println(" " + i);
Tanto a [expressão 1] quanto a [expressão 2] do laço for permitem

acomodar múltiplas expressões, bastando separá-las por vírgula. Por
exemplo, a soma de {1/n} n=1,2, .., N pode ser obtida por:
for (soma=0, n=1; n<=N;n++)
soma += 1/n;
ou ainda por
43
for(soma=0, n=1; n<=N; soma += 1/n, n++);
1.4.8. break e continue
O comando break é usado para interromper a execução de um dos

laços de iteração vistos acima ou de um comando switch. Este comando
é comumente utilizado para produzir a parada de um laço mediante a
ocorrência de alguma condição específica, antes da chegada do final
natural do laço.
Exemplo:
// Achar i tal que v[i] é negativo
for(i=0; i<n;i++)
if(v[i] <0) break;
if(i == n)
System.out.println("elemento negativo não

encontrado.");
E se isto se der dentro de um laço duplo? Nesse caso, o comando break

provocará a interrupção apenas do laço em que o comando é
imediatamente subjacente. Os outros laços continuam normalmente.
Exemplo:
/* Notificando a existencia de elemento nulo em cada linha da

matriz A*/
for(i=0; i<m; i++) /* Para cada linha i da matriz faça*/
for(j=0; j<n; j++) /* Para cada coluna j da matriz faça*/
if(A[i][j] == 0) {
System.out.println("A possui elemento nulo na linha

"+i);
break;
44
O comando continue tem a função de pular directo para final do laço,

mas em vez de interromper o laço como no break, ele continua
executando o próximo passo do laço. Não vamos ficar estudando o uso
de continue por ser puco usual na programação estruturada.
O comando "goto" em Java é feito pelo break ou continue com rótulo.

Isto é útil para interromper de uma vez só, a execução de um laço
múltiplo ou pular para um determinado ponto do programa. O uso de
saltos deste tipo deve ser evitado na programação estruturada, excepto
quando trata de alguma optimização muito importante. Caso contrário,
nosso programas pode tornar totalmente ilegível. Nós vamos ver um
exemplo, mas lembre-se que se necessitar de um "goto", está faltando a
estruturação do programa. Nós estudamos essas coisas para poder
entender o programa já feito.
exemplo:
// calculando a raiz da soma dos quadrados de

A[i][j]
soma = 0;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
if(A[i][j]<0) {
System.out.println("Erro. existe elemento

negativo.");
break fim;
esle
soma += Math.sqrt(A[i][j]);
fim:
System.out.println("soma = " + soma);
o nome colocado na localização é denominado de rótulo e deve ser

declarado como label.
45
Sumário
Nesta Unidade temática estudamos Controle de fluxo, que é a

habilidade de ajustar a maneira como um programa realiza suas tarefas.
Por meio de instruções especiais, chamadas comandos, essas tarefas
podem ser executadas selectivamente, repetidamente ou
excepcionalmente. Não fosse o controle de fluxo, um programa poderia
executar apenas uma única sequência de tarefas, perdendo
completamente uma das características mais interessantes da
programação: a dinâmica.
Exercícios
1. Quais são as estruturas de controle de fluxo que vimos?

2. Classifica as estruturas de controle por função.
3. Faça uma estrutura de controle onde determina o preço de
bilhete de acordo com a faixa etária do cliente.
4. Escreva uma estrutura de controle que faça a contagem
regressiva a partir do numero 1000.
5. Qual é a função do break e continue dentro de um bloco do
switch.
46
Exercícios do TEMA
1. Em suas palavras defina Compilador JAVA.

2. Qual é a função de uma JVM (JAVA Virtual Machine)?
3. No colector de lixo JAVA que nome se da a abordagem para a
manipulação de memorias?
4. O que é uma constante JAVA?
5. Qual é a principal diferença entre uma variável e uma
constante em JAVA?
6. Com que tipo de dados primitivos podemos escrever números
decimais?
7. Diga quais são os operadores da 1ª e 2ª ordem.
8. Java e Aritmética possuem a mesma regra de precedência?
Justifique a sua resposta com exemplos.
9. O que é um operador Ternário?
10. Como são feitas as operações com operadores prefixos?
47
TEMA – II: GESTÃO DE ERROS E EXCEPÇÕES
UNIDADE Temática 2.1. Try/Catch;

UNIDADE Temática 2.2. Bloco “finally”;
UNIDADE Temática 2.1. Try/Catch;
Introdução
2.1.1. Iniciando no Try/Catch
Você irá utilizar este bloco quando você usar algum método que lance
uma CheckedException e quando você quer dar algum tratamento a
exception.
Um bloco “try” é chamado de bloco “protegido” porque, caso ocorra

algum problema com os comandos dentro do bloco, a execução desviará
para os blocos “catch” correspondentes.
Necessitamos usar try, porque estamos fazendo operação de conversão,

é uma maneira mais robusta de tratar possíveis erros no momento da
conversão, por exemplo, não é possível converter um caractere “?” por
um número, porém como a entrada de dados é liberada o usuário final
poderá digitar algo inadequado, resultando em erro e quebra da
execução do programa por falha, com o try podemos evitar esta queda
brusca e então tratar o erro da melhor forma.
2.1.2. Sintaxe
A estruturação desses blocos obedece à seguinte sintaxe:
try {
// código que inclui comandos/invocações de

métodos
// que podem gerar uma situação de exceção.
} catch (XException ex) {
48
// bloco de tratamento associado à condição de
// exceção XException ou a qualquer uma de suas
// subclasses, identificada aqui pelo objeto
// com referência ex
} catch (YException ey) {
// bloco de tratamento para a situação de exceção
// YException ou a qualquer uma de suas subclasses
} finally {
// bloco de código que sempre será executado após
// o bloco try, independentemente de sua conclusão
// ter ocorrido normalmente ou ter sido

interrompida
Onde XException e YException deveriam ser substituídos pelo nome do

tipo de exceção. Os blocos não podem ser separados por outros
comandos — um erro de sintaxe seria detectado pelo compilador Java
neste caso. Cada bloco try pode ser seguido por zero ou mais blocos
catch, onde cada bloco catch refere-se a uma única exceção.
O bloco finally, quando presente, é sempre executado. Em geral, ele

inclui comandos que liberam recursos que eventualmente possam ter sido
alocados durante o processamento do bloco try e que podem ser
liberados, independentemente de a execução ter encerrado com sucesso
ou ter sido interrompida por uma condição de exceção. A presença desse
bloco é opcional.
Alguns exemplos de exceções já definidas no pacote java.lang incluem:
• ArithmeticException: indica situações de erros em processamento

aritmético, tal como uma divisão inteira por 0. A divisão de um
49
valor real por 0 não gera uma excepção (o resultado é o valor

infinito);
• NumberFormatException: indica que se tentou 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 objecto 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.
Além disso, outros pacotes especificam suas excepções, referentes às suas

funcionalidades. Por exemplo, no pacote java.io define-se IOException,
que indica a ocorrência de algum tipo de erro em operações de entrada
e saída. É a superclasse para condições de excepção mais específicas
desse pacote, tais como EOFException (fim de arquivo ou
stream), FileNotFoundException (arquivo especificado não foi
encontrado) e InterruptedIOException(operação de entrada ou saída
foi interrompida).
Uma excepção contém ao menos uma String que a descreve, que pode
ser obtida a aplicação do método getMessage(), mas pode
eventualmente conter outras informações. Por
exemplo, InterruptedIOException inclui um atributo público do tipo
inteiro, bytesTransferred, para indicar quantos bytes foram transferidos
antes da interrupção da operação ocorrer. Outra informação que pode
sempre ser obtida de uma excepção é a sequência de métodos no
momento da excepção, obtenível a partir do método printStackTrace().
50
Como excepções fazem parte de uma hierarquia de classes, excepções

mais genéricas (mais próximas do topo da hierarquia) englobam aquelas
que são mais específicas. Assim, a forma mais genérica de um bloco try-
catch é:
try { ... }
catch (Exception e) {...}
Pois todas as excepções são derivadas de Exception. Se dois blocos

catch especificam excepções em um mesmo ramo da hierarquia, a
especificação do tratamento da excepção derivada deve preceder
aquela da mais genérica. Veja um exemplo mais claro:
void saveNetDevices() {
try {
FileOutputStream fos = new
FileOutputStream("NetDevices.txt");
ObjectOutputStream oos = new

ObjectOutputStream(fos);
oos.writeObject(mNetDevices);
oos.close();
fos.close();
} catch (NullPointerException nexc) {
JOptionPane.showMessageDialog(null, "NetDevices
list is null - No devices saved", "Saving NetDevices",
JOptionPane.INFORMATION_MESSAGE);
51
} catch (InvalidClassException nexc) {
list is invalid - No devices saved", "Saving
NetDevices", JOptionPane.INFORMATION_MESSAGE);
} catch (NotSerializableException nexc) {
list is not serializable - No devices saved", "Saving
NetDevices", JOptionPane.INFORMATION_MESSAGE);
} catch (IOException nexc) {
JOptionPane.showMessageDialog(null, "IO
Exception saving NetDevices list - No devices saved",
"Saving NetDevices",
Neste exemplo o bloco protegido pode gerar vários tipos de excepções.

Caso ocorra uma “InvalidClassException”, a execução será desviada
para o segundo bloco “catch” e, após executar o seu código, sairá para
o fim do método.
A ordem em que colocamos os blocos “catch” é muito importante: deve

ser da mais específica para a mais genérica. Exemplo:
try {
comando(s);
} catch (Exception e) {
52
comando(s);
} catch (FileNotFoundException f) {
comando(s);
Supondo que ocorreu uma “FileNotFoundException” dentro do

bloco “try”, a execução vai procurar o primeiro bloco “catch” que seja
compatível com o tipo de Exception ocorrida. O primeiro bloco será
analisado e, como Exception é superclasse de “FileNotFoundException”,
a execução entrará no primeiro bloco “catch”. O segundo sequer será
testado.
Para que tudo funcione temos que trocar a ordem dos blocos “catch”:
try {
comando(s);
} catch (FileNotFoundException f) {
comando(s);
} catch (Exception e) {
comando(s);
Assim, caso ocorra uma “FileNotFoundException” o primeiro bloco será

accionado. Se ocorrer uma outra classe de Exception, por
exemplo: “InterrupedIOException”, ele entrará no segundo
bloco “catch”.
Se você usa algum método que lança “Checked Exceptions” você deve,
obrigatoriamente, tratar esta Exception. Ou seja, tem que haver
53
um “catch” correspondente à Exception que você está lançando ou que

seja superclasse desta. Veja um exemplo:
try {
FileReader fin = new FileReader("oids.txt");
BufferedReader br = new BufferedReader(fin);
while ((mOID = br.readLine()) != null) {
oidsList.add(new String(mOID));
br.close();
fin.close();
} catch (FileNotFoundException fnf) {
JOptionPane.showMessageDialog(null, "Extra OIDS

file not found", "Loading Extra OIDs",
O construtor da classe FileReader pode

lançar “FileNotFoundException” caso o arquivo não exista. Logo, se
utilizar esta classe, você tem que tratar esta exception. Por isto o
comando está dentro de um bloco “try/catch”.
54
Sumário
Nesta Unidade temática 2.1 aprendemos como utilizar o try e catch que
serve para tratamento de erros e excepções matemática onde o try é a
possível solução do problema e o catch é o problema a ser resolvido.
Exercícios
1. Qual é a função essencial do try?

2. Para que é que serve o catch?
3. Como podemos revolver o problema da divisão de qualquer
numero por zero usando o try/catch.
4. O que inca a excepção NumberFormatException?
5. Faça o uso de um NullPointerException em uma aplicação.
55
UNIDADE Temática 2.2. Bloco “finally”;
2.2.1. Bloco “finally”
As vezes é necessário executar um código mesmo que tenha havido uma

Exception. É para isto que servem os blocos “finally”. Sua sintaxe é:
try {
comando(s);
} finally {
comando(s);
}\ou
try {
comando(s);
} catch (ClasseDeException VarException) {
comando(s);
} finally {
comando(s);
Os comandos dentro de um bloco “finally” serão executados de

qualquer maneira, mesmo que a execução tenha passado por um
bloco “catch”.
Ao contrário dos blocos “catch” você só pode ter um bloco “finally” por
cada bloco “try”.
56
Sumário
Nesta Unidade temática 2.2 somente do finally que tem como função
principal fazer com que uma aplicação mesmo que tenha uma excepção
corra e que “substitui” o catch que quem a função inversa.
Exercícios
1. Crie um código que faz o uso do finally.

2. Demostre o código usando o catch ao invés do finally e explique
qual é a vantagem de um em relação o outro.
57
Exercícios do TEMA
1. Qual é a sintaxe do um try/catch?

2. Faça uma lista de excepções no pacote java.lang.
3. Como é se cria excepções manualmente?
4. Crie uma excepção manualmente.
5. Qual é a excepção mais genérica que podemos encontrar na
hierarquia de classes?
58
TEMA – III: Graphical User Interface
UNIDADE Temática 3.1. Java Swing;

UNIDADE Temática 3.2. Limitando caracteres com JTextField;
UNIDADE Temática 3.3. Formatando campos com JFormattedTextField;
UNIDADE Temática 3.1. Java Swing.
Introdução
O Swing é um framework que disponibiliza um conjunto de elementos

gráficos para ser utilizado na plataforma Java. O Swing é compatível
com o Abstract Window Toolkit (AWT), mas trabalha de forma
totalmente diferente. A API Swing, diferente do AWT, não delega a
tarefa de renderização ao sistema operacional, ele renderiza os
elementos por conta própria. Como a AWT é uma biblioteca de baixo-
nível que depende de código nativo da plataforma ela traz alguns
problemas de compatibilidade entre as plataformas, fazendo com que
nem sempre o programa tenha a aparência desejada em todos os
sistemas operacionais. Além disso, o Swing é mais completo e os
programas têm uma aparência muito parecida, independente do sistema
operacional que está sendo utilizado, possui uma enorme gama de
controles extras disponíveis, tais como áreas de texto que nativamente
podem mostrar conteúdo como RTF ou HTML, botões com suporte a
imagens, sliders, seleccionadores de cores, alteração do tipo de borda
para os componentes, maior controle de como desenhar os mínimos
detalhes de apresentação e muito mais. No entanto, a performance é um
pouco pior devido a alta abstracção, consumindo assim mais memória
RAM.
3.1.2. Componentes Swing
Os principais componentes do Swing são resumidos abaixo:
• JFrame representa a janela do programa com barra de título,

ícone, botões de comando, etc. Entre os principais métodos temos
o pack() que compacta a janela para o tamanho dos
componentes, setSize(int, int) que define
59
a largura e altura da janela, setLocation(int, int) que define a

posição da janela na tela (x,y), setBounds(int, int, int, int) que
define posição e tamanho, setVisible(boolean) que exibe a
janela e setDefaultCloseOperation(int) que define o que ocorre
quando o usuário tenta fechar a janela (as opções
são: DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, DISPOSE
_ON_CLOSE, EXIT_ON_CLOSE).
• JPanel representa um tipo básico de container para inserção de
componentes. Entre os principais métodos temos add(Component,
int) que adiciona o componente definindo sua posição
e setLayout(LayoutManagaer) que altera o tipo de layout.
• JLabel representa um rótulo de texto. Entre os principais métodos
temos o setText(String) que altera o texto e getText() que retorna
o texto atual.
• JTextField representa um campo de texto onde o usuário pode
informar um texto em uma linha. Entre os principais métodos
temos setText(String) que altera o texto e getText() que retorna
o texto atual.
• JPasswordField representa um campo de texto protegido,
subclasse de JTextField. O principal método é
o setEchoChar(char) que define o caractere que aparece ao
digitar um texto.
• JTextArea representa uma caixa onde o usuário pode informar
várias linhas de texto. Entre os principais métodos temos
o setText(String) que altera o texto, getText() que retorna o texto
atual, getSelectedText() que retorna o texto selecionado pelo
usuário e insert(String, int) que insere um texto na posição
especificada.
• JCheckBox representa uma caixa de seleção e permite
selecionar ou não uma opção. Entre os principais métodos temos
o setSelected(boolean) que altera o estado da caixa de seleção
e o método isSelected() que retorna true se a caixa estiver
marcada e false se não estiver marcada.
• JRadioButton representa um componente que permite selecciona
uma entre diversas opções. O
60
JRadioButton é semelhante ao JCheckBox, inclusive com os

mesmos construtores e métodos.
• JComboBox representa uma caixa de combinação, da qual o
usuário pode selecionar uma opção. Entre os principais métodos
temos o addItem(Object) que adiciona um item à lista de
opções, setEditable(boolean) que permite ao usuário digitar uma
opção, getSelectedIndex() que retorna a posição do item
atualmente selecionado, getSelectedItem() que retorna o texto
do item atualmente selecionado, setSelectedIndex(int) que
seleciona o item da posição especificada
e setSelectedIndex(Object) que seleciona o objeto especificado
na lista.
• JList representa uma lista de opções que permite a seleção de
mais de um item simultaneamente. Entre os principais métodos
temos o setListData(Object[]) que preenche ou altera os itens de
uma lista, getSelectedValues() que retorna um array de objetos
contendo itens seleccionados na lista.
• JButton representa um botão destinado a executar uma ação.
Entre os principais métodos temos o setText(String) que altera o
texto do botão e setIcon(Icon) que altera o ícone do botão.
Na Figura 1 podemos visualizar cada um dos componentes discutidos

acima, respectivamente.
61
Figura 1- Principais componentes do framework Swing.
Existem ainda diversos outros componentes Swing como o JSlider,

JProgressBar, JToolBar, JTabbedPane entre outros.
62
Sumário
Nesta Unidade temática 3.1. estudamos e discutimos fundamentalmente

o Java Swing que é um framework que disponibiliza um conjunto de
elementos gráficos para ser utilizado na plataforma Java. O Swing é
compatível com o Abstract Window Toolkit (AWT), mas trabalha de
forma totalmente diferente. A API Swing, diferente do AWT, não delega
a tarefa de renderização ao sistema operacional, ele renderiza os
elementos por conta própria. Além disso, o Swing é mais completo e os
programas têm uma aparência muito parecida, independente do sistema
operacional que está sendo utilizado, possui uma enorme gama de
controles extras disponíveis, tais como áreas de texto que nativamente
podem mostrar conteúdo como RTF ou HTML, botões com suporte a
imagens, sliders, seleccionadores de cores, alteração do tipo de borda
para os componentes, maior controle de como desenhar os mínimos
detalhes de apresentação e muito mais. No entanto, a performance é um
pouco pior devido a alta abstracção, consumindo assim mais memória
RAM.
Exercícios
1. O que são componentes Swing?

2. Qual é a vantagem de usas Swing ao invés do AWT?
3. Existe alguma diferença entre JFrame e JPanel? Justifique a sua
resposta.
4. Qual é a diferença entre um JRadioButton e JCheckBox.
5. Faça uma lista de todos os componentes do Java Swing.
63
UNIDADE Temática 3.2. Limitando caracteres com JTextField.
Introdução
Controlar a entrada de texto num componente JTextField não é tão

simples e ainda causa muitas dúvidas para os desenvolvedores que
trabalham com Swing em java. A classe javax.swing. JTextField é uma
subclasse da classe abstracta JTextComponent e o modelo de dados
padrão é um objecto da classe PlainDocument, subclasse
de AbstractDocument que implementa a interface Document. Um dos
métodos da classe PlainDocument é o insertString() que é herdado da
superclasse abstracta AbstractDocument. A assinatura do método é:
public void insertString(int offset, String str,

AttributeSet attr) throws BadLocationException
O argumento offset indica o deslocamento (a posição) inicial onde o

objeto String str deverá ser inserido. O AttributeSet seta os atributos
do JTextField, como os estilos.
Sempre que o conteúdo de um JTextField é modificado, o

método insertString() é invocado.
Segue na Exemplo 1 um exemplo de como poderíamos utilizar o

método insertString para criar um novo modelos de dados que seja
capaz de restringir a quantidade de caracteres aceitos no modelo de
dados de qualquer JTextField.
Exemplo 1. Criando um novo modelo de dados para restringir o número

de caracteres.
package com.exemplo;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;
64
public class TamanhoFixoJTextField extends

PlainDocument {
private int tamMax;
public TamanhoFixoJTextField(int tamMax)

{ super();
this.tamMax = tamMax;
public void insertString(int offset,

String str, AttributeSet attr)
throws BadLocationException {
if (str == null)
return;
//Define a condição para aceitar

qualquer número de caracteres
if (tamMax <= 0)
super.insertString(offset, str, attr);
return;
int tam = (getLength() + str.length());
65
//Se o tamanho final for menor, chama

insertString() aceitando a String
if (tam <= tamMax)
O argumento recebido pelo construtor define o número máximo de

caracteres aceitos. A chamada a super() no construtor permite que a
classe ancestral faça todas as inicializações necessárias. A variável de
instância tamMax recebe o valor do argumento do construtor. O
método insertString()nos permite sobrepor o método definido na
superclasse para que possamos defini-lo como quisermos. A
exceção BadLocationException é disparada quando a posição de
inserção na String é inválida. No corpo do
método insertString primeiramente garantimos que não estamos
recebendo uma String nula. Após isso verificamos o valor máximo de
caracteres a serem aceitos, se este valor for menor ou igual a zero, tem-
se que essa classe terá um comportamento igual a sua
ancestral PlainDocument, chamando o método insertString() da
superclasse e simplesmente a retornando. Dessa forma, se o máximo de
caracteres for menor ou igual zero, o número de caracteres aceitos será
indeterminado. A classe AbstractDocument ainda possui alguns métodos
que permitem o acesso aos dados que formam o conteúdo do JTextField,
são eles: getLength() ou ainda getText(). O método getLength() permite
que possamos acessar o número de caracteres atual do conteúdo. O
conteúdo pode ser acessado diretamente através de getText(). Portanto,
no código acima temos "int tam = (getLength() + str.length())" em
que tam é a soma do comprimento atual do conteúdo mais o comprimento
da String str que está por ser inserida. Se a soma for menor ou igual ao
número máximo de caracteres, aceitaremos str através da chamada ao
66
método insertString da superclasse, caso contrário não ocorrerá a

chamada e o conteúdo a ser inserido será ignorado.
Para testar o código presente na Exemplo 1, vamos fazer um exemplo

utilizando um JTextField que segue esse modelo. Na Exemplo 2 segue um
exemplo.
Exemplo 2. Testando o JTextField utilizando o modelo de dados criado.
import javax.swing.JFrame;
import javax.swing.JTextField;
public class TestandoJTextField extends JFrame {
private static final long serialVersionUID =

1L;
private JTextField txtExemplo;
public static void main(String[] args)
TestandoJTextField field = new

TestandoJTextField();
field.testaJTextField();
private void testaJTextField() {
this.setTitle("Exemplo");
this.setSize(200, 180);
//Definimos o tamanho padrão do JTextField
67
txtExemplo = new JTextField(10);
//Passamos para o construtor o número máximo

de caracteres aceitos
txtExemplo.setDocument(new
TamanhoFixoJTextField(5));
this.getContentPane().add(txtExemplo,
"North");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
;
setVisible(true); }
No exemplo mostrado no código acima, tentamos adicionar uma string

na caixa de texto do programa, ou seja, o nome “Rafael”, porém como
o nosso componente aceita no máximo cinco caracteres não conseguimos
digitar o nome inteiro. Segue na Figura 2 a demonstração do programa
funcionando e permitindo um número máximo de caracteres.
Figura 2 -Executando o programa e digitando uma string

Um pequeno problema é quando desejamos colar na
nossa JTextField customizada uma string maior que a permitida. Se
colarmos uma string que o número máximo de caracteres seja permitido
não será um problema. Por exemplo, se tentarmos copiar a String
68
“Marco” e colar no JTextField ele aceitará normalmente, conforme ilustra

a Figura 3.
Figura 3 - Colando um texto com cinco caracteres

No entanto, se copiarmos a string “Rafael” e tentarmos colar veremos
que essa string não será colada no JTextField, isso acontece porque esta
string ultrapassa o número máximo de caracteres permitidos e, portanto,
a string não é aceita. O ideal seria o campo de texto aceitar o número
mínimo de caracteres e desprezar o restante, dessa forma, a string
mostrada seria “Rafae”. Para modificar isso devemos fazer algumas
modificações no código. Segue na Exemplo 3 o novo código com
comentários das modificações.
Exemplo 3. Modificando o código para contemplar as novas

configurações.
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;
public class TamanhoFixoJTextField extends
PlainDocument {
private int tamMax;
public TamanhoFixoJTextField(int tamMax) {

super();
69
this.tamMax = tamMax;
}
public void insertString(int offset, String

str, AttributeSet attr)
throws BadLocationException {
if (str == null)
return;
//Define a condição para aceitar

qualquer número de caracteres
if (tamMax <= 0)
{
return;
}
int tam = (getLength() + str.length());
//Se o tamanho final for menor, chama

insertString() aceitando a String
if (tam <= tamMax) {
} else {
//Caso contrário, limita a string e
envia para insertString() que aceita a string
if (getLength() == tamMax) return;
String novaStr = str.substring(0,
(tamMax - getLength()));
super.insertString(offset, novaStr,
attr); } } }
70
O bloco else adicionado no final do código acima primeiramente verifica

se o comprimento actual do conteúdo é igual ao comprimento máximo,
então simplesmente retornamos, caso contrário criamos um novo objecto
String contendo apenas os caracteres de str que deveria caber no
JTextField.
Agora se tentarmos copiar a String “Rafael” e colarmos

no JTextField teremos como resultado a string limitada adicionada no
campo, conforme mostra a Figura 4 abaixo.
Figura 4 - Colando uma String maior que o permitido no campo.
71
Sumário
Nesta Unidade temática 3.2 aprendemos a limitar um determinado

campo de texto o que permite ao programador criar programas mais
organizados sem que haja diversos espaços dentro de campos de textos,
números e outro tipo de dados desnecessários
Exercícios
1. Crie um campo de texto que permita escrever o numero de

caracteres do seu apelido.
2. Crie um campo de numero que apenas aceite o numero de
caracteres de um ano. Ex: XXXX
72
UNIDADE Temática 3.3. Formatando campos com JFormattedTextField.
Introdução
As máscaras são muito utilizadas em sistemas comerciais, pois elas

ajudam na padronização da visualização de dados. Um exemplo de
máscara é o telefone: "(51)3636-0000" . Tudo que for digitado ficará
entre os caracteres especiais da máscara seguindo a sequencia.
Antes de criarmos e utilizarmos um JFormattedTextField devemos criar um

objeto MaskFormatter e configurar uma máscara. Segue no Exemplo um
exemplo de uma máscara definida para BI.
Exemplo 4. Definindo uma mascara para um BI.
MaskFormatter mascaraBi = new

MaskFormatter("#############-U");
Após isso, configuramos a máscara no JFormattedTextField, conforme o
código presente na Exemplo 5.
Exemplo 5. Configurando a mascara no objeto JFormattedTextField.
JFormattedTextField bi = new
JFormattedTextField(mascaraBi);
Quando criamos um MaskFormatter podemos utilizar ao invés de “#”,
outros caracteres, dependendo do tipo de restrição que desejamos
implementar no JFormattedTextField. Esses caracteres são definidos
abaixo:
• "#" indica que qualquer número poderá ser inserido (0-9);

• "U" indica que qualquer letra (a-z) poderá ser inserida. A
máscara converterá letras minúsculas em maiúsculas;
• "L" indica qualquer letra (a-z) poderá ser inserida. A máscara
converterá letras maiúsculas em minúsculas;
• "?" indica qualquer letra (a-z) poderá ser inserida. A máscara
manterá a letra inserida;
• "A" indica qualquer letra ou numero (0-9 e a-z) poderá ser
inserido;
73
• "H" indica qualquer caracter hexadecimal (0-9 a-f) poderá ser

inserido;
• "*" indica qualquer coisa, incluindo caracteres especiais poderão
ser inseridos.
Segue abaixo algumas máscaras prontas que podemos utilizar em nossos

projectos:
• Telefone Internacional: "+##(##)####-####"

• Telefone Nacional: "+(###)##-#######"
• Placa de automóveis: "UUU-####-UU"
• Cartão de eleitor: "#########/##"
• Data de nascimento: "##/##/####"
Para exemplificar o uso do JFormattedTextField segue o exemplo

presente na Exemplo 6, onde criamos quatro campos com máscaras, são
eles: CEP, Telefone, CPF, Data.
Exemplo 6. Exemplo de código utilizando máscaras para CEP, telefone,

CPF e Data.
import java.awt.Container;
import java.text.ParseException;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.text.MaskFormatter;
public class TestandoJFormattedTextField extends

JFrame {
private static final long serialVersionUID =

1L;
74
public static void main(String[] args)

{
TestandoJFormattedTextField field = new
TestandoJFormattedTextField();
field.testaJFormattedTextField();
}
private void testaJFormattedTextField() {

Container janela = getContentPane();
setLayout(null);
//Define os rótulos dos botões

JLabel labelCep = new JLabel("BI: ");
JLabel labelTel = new JLabel("Telefone:
");
JLabel labelCpf = new JLabel("NUIT: ");
JLabel labelData = new JLabel("Data:
");
labelCep.setBounds(50,40,100,20);
labelTel.setBounds(50,80,100,20);
labelCpf.setBounds(50,120,100,20);
labelData.setBounds(50,160,100,20);
//Define as máscaras
MaskFormatter mascaraCep = null;
MaskFormatter mascaraTel = null;
MaskFormatter mascaraCpf = null;
MaskFormatter mascaraData = null;
try{
75
mascaraBi = new
MaskFormatter("###########-U");
mascaraTel = new
MaskFormatter("(###)##-#######");
mascaraNuit = new
MaskFormatter("#########-##");
mascaraData = new
MaskFormatter("##/##/####");
mascaraCep.setPlaceholderCharact
er('_');
mascaraTel.setPlaceholderCharact
er('_');
mascaraCpf.setPlaceholderCharact
er('_');
mascaraData.setPlaceholderCharac
ter('_');
}
catch(ParseException excp) {
System.err.println("Erro na
formatação: " + excp.getMessage());
System.exit(-1);
}
//Seta as máscaras nos objetos

JFormattedTextField
JFormattedTextField jFormattedTextCep =
new JFormattedTextField(mascaraCep);
JFormattedTextField jFormattedTextTel =
new JFormattedTextField(mascaraTel);
JFormattedTextField jFormattedTextCpf =
new JFormattedTextField(mascaraCpf);
76
JFormattedTextField jFormattedTextData
= new JFormattedTextField(mascaraData);
jFormattedTextCep.setBounds(150,40,100,
20);
jFormattedTextTel.setBounds(150,80,100,
20);
jFormattedTextCpf.setBounds(150,120,100
,20);
jFormattedTextData.setBounds(150,160,10
0,20);
//Adiciona os rótulos e os campos de

textos com máscaras na tela
janela.add(labelCep);
janela.add(labelTel);
janela.add(labelCpf);
janela.add(labelData);
janela.add(jFormattedTextCep);
janela.add(jFormattedTextTel);
janela.add(jFormattedTextCpf);
janela.add(jFormattedTextData);
setSize(400, 250);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
}
Segue na Figura 5 um exemplo de como ficou a tela codificada acima.
Se tentarmos entrar com letras onde apenas se aceita número veremos

que os caracteres não serão aceitos no campo.
77
78
Exercícios
1. Crie uma Janela para inserir dados predefinidos em um

bilhete de identidade moçambicano.
2. Crie uma Janela para inserir dados predefinidos em
uma carta de condução.
Exercícios do TEMA
1. Faça uma janele.

2. Na janela do numero anterior crie dois campos de texto.
3. Ainda na mesma janela crie 4 botões para cada uma das
operações básicas matemáticas. (adição, subtracção,
multiplicação e divisão)
4. Faça métodos que deia utilidade aos botões em conformidade
com os números que aparecem.
5. Implementar um conversor binário- decimal com as seguintes
características:
• Interface: duas caixas de texto para receber valores numéricos
na base binária e na base decimal e botões para a conversão
em ambos os sentidos
• Funcionalidade: clicando-se um botão deve-se fazer o cálculo
no sentido correspondente. Considerar que o usuário SEMPRE
insere números válidos e que caixa vazia significa 0.
6. Implementar o jogo da memória
• Jogo apresenta um frame com 5 botões, contendo números ou
figuras
• Ao ser iniciado, o jogo sorteia um dos botões e o indica (por
exemplo, exibindo em outro lugar do frame o número ou figura
sorteada). O jogador deve então clicar no botão correspondente.
• O jogo prossegue, exibindo uma sequência de sorteios que vai
aumentando progressivamente. O jogador, por sua vez, ao final
da exibição deve repetir aquela sequência clicando nos botões.
• O jogo termina quando o usuário erra a sequência.
79
TEMA – V: MINIPROJECTO
UNIDADE Temática 4.1. Apresentação e defesa do projecto final.
Baseando-se na sua área de actividade, crie um projecto e uma aplicação que

faça o uso de tudo que aprendeu nesta cadeira. Devera usar uma interface
gráfica e os dados deveram estão formatados. Também deve ter em conta
que a aplicação deve correr localmente se uso de servidores externos.
Para melhor percepção aconselhasse um acompanhamento constante do

tutor do modulo
Apresentação e defesa do projecto final deve ser perante o júri composto

por 2 ou 3 docentes de Programação.
80
Bibliografia
Andrews, M. (1998). Getting Started with Swing. Retrieved from
hppt://www.java.sun.com/prudutcts/jfc/tsc/what.is.swig/getting.sta
rted/getting.started.html
Camarao, C., & Lucília , F. (2003). Porgramação de Computadores em JAVA.

Rio de Janeiro: LTC.
Correia, F. R. & Borges, R. M. Análise Orientada a Objectos com UML. [. On-

line]. Consultado em 17/04/2017. Disponível em
Deitel, H., & Deitel, P. (2001). Java: Como Programar (4 ed.).
Faria, T., Júnior, N. (2016). Orientação a Objetos - Conceitos e Aplicação com

Java (2ª ed.). AlgaWorks. Claro D. B. e Sobral J. B. M (2008). Programação em
java. CopyleftPearsonEducation. Florianópolis, SC.
Graham, R., Patashnik, O., & Knuth, D. (1994). Concrete Mathematics: A

Fundation for Computer Sciense. Addison-Wesley.
Paula Filho, Wilson de Pádua. Engenharia de Software: fundamentos,

métodos e padrões. São Paulo. LCT Editora
81

Manual de Programacao Orientada Ao Objecto

Enviado por

Dados do documento

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

Manual de Programacao Orientada Ao Objecto

Enviado por

Direitos autorais:

Formatos disponíveis

MANUAL DO CURSO DE LICENCIATURA EM

Disciplina: Programação Orientada a Objectos

INSTITUTO SUPERIOR DE CIÊNCIAS E EDUCAÇÃO A DISTÂNCIA - ISCED

Direitos de autor (copyright)

Este manual é propriedade do Instituto Superior de Ciências e Educação a Distância (ISCED), e

A não observância do acima estipulado o infractor é passível a aplicação de processos judiciais

Instituto Superior de Ciências e Educação a Distância (ISCED)

O Instituto Superior de Ciências e Educação a Distância (ISCED) agradece a colaboração dos

Autor Maiden Djento Mário Pereira Alfinete

Direcção Académica do ISCED

Revisão Científica e XXXXX

Ano de Publicação 2018

Local de Publicação ISCED – BEIRA

TEMA – I: CONCEITOS E FUNDAMENTOS BÁSICOS DE PROGRAMAÇÃO EM JAVA 9

TEMA – II: GESTÃO DE ERROS E EXCEPÇÕES 48

TEMA – III: Graphical User Interface 59

Exercícios de AUTO-AVALIAÇÃO .................................................................................... 63

Bem vindo à Disciplina/Módulo de Programação

O objectivo fundamental do modulo de Programação orientada a

Quem deveria estudar este módulo

Este Módulo foi concebido para estudantes do 3º ano do curso de

Como está estruturado este módulo

Este módulo de Programação Orientada a Objectos, para

A equipa dos académicos e pedagogos do ISCED, pensando em si,

Auto-avaliação e Tarefas de avaliação

Tarefas de auto-avaliação para este módulo encontram-se no final

Use este espaço para dar sugestões valiosas, sobre determinados

O principal objectivo deste campo é o de ensinar aprender a

Durante a formação e desenvolvimento de competências, para

1º Praticar a leitura. Aprender a Distância exige alto domínio de

2º Fazer leitura diagonal aos conteúdos (leitura corrida).

3º Voltar a fazer leitura, desta vez para a compreensão e

4º Fazer seminário (debate em grupos), para comprovar se a sua

5º Fazer TC (Trabalho de Campo), algumas actividades práticas ou

IMPORTANTE: Em observância ao triângulo modo-espaço-tempo,

Privilegia-se saber bem (com profundidade) o pouco que puder ler e

Dica importante: não recomendamos estudar seguidamente por

Uma longa exposição aos estudos ou ao trabalho intelectual

Não estude na última da hora; quando se trate de fazer alguma

Organize na sua agenda um horário onde define a que horas e que

É importante identificar as ideias principais de um texto, pois será

E-mail, se tiver tempo, escreva mesmo uma carta participando a

Tarefas (avaliação e auto-avaliação)

O estudante deve realizar todas as tarefas (exercícios, actividades e

e o respeito aos direitos autorais devem caracterizar a realização

Muitos perguntam: Com é possível avaliar estudantes à distância,

TEMA – I: CONCEITOS E FUNDAMENTOS BÁSICOS DE PROGRAMAÇÃO EM JAVA

UNIDADE Temática 1.1. A linguagem Java.

UNIDADE Temática 1.1. A linguagem Java.

A tecnologia Java é usada para desenvolver aplicativos para uma ampla

1.1.1. A linguagem Java

A maioria dos desenvolvedores Java constantemente consultam a documentação

Como qualquer linguagem de programação, a linguagem Java tem sua própria

Estruturalmente, a linguagem Java começa com pacotes. Um pacote é o

1.1.2. O compilador Java

Quando você programa na plataforma Java, escreve seu código-fonte em

No tempo de execução, a JVM lê e interpreta arquivos .class e executa as

1.1.4. O colector de lixo

Em vez de forçá-lo a manter a alocação de memória (ou usar uma biblioteca

é chamada de gerenciamento implícito de memória porque não exige a

1.1.5. O Java Development Kit

Java Development Kit (JDK) significa Kit de Desenvolvimento Java, e é um

1.1.6. O Java Runtime Environment

O Java Runtime Environment (JRE; também conhecido como o tempo de