Prévia do material em texto
Orientação a objetos
em Java – JOO
2016 v1
LogusTI – Treinamento em Informática
Tel (61) 3244 - 5000
WhatsApp (61) 9 8548-0058
SCS QD 02 BL C n 252
BRASÍLIA – DF
www.logusti.com.br
logusti@logusti.com.br
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 2
LogusTI
A LogusTI nasceu da necessidade de oferecer novos treinamentos na área de Tecnologia da
Informação em Brasília, visto que este segmento é escasso na Capital Federal.
A excelência dos serviços prestados pela LogusTI está apoiada em profissionais especializados,
processos estabelecidos e uma larga experiência em seus profissionais. O capital humano é um
elemento chave na estratégia de atuação da empresa, que investe continuamente na atualização e
capacitação de seus profissionais, propiciando um ambiente encorajador para serem os melhores
naquilo que fazem.
A alta qualidade dos serviços prestados aliada ao compromisso em gerar resultados e
proporcionar maior vantagem competitiva a seus clientes tem propiciado a LogusTI relacionamentos
duradouros e bem sucedidos com empresas de diversos segmentos de mercado.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 3
Sobre o autor Gleidson Porto
Bacharel em Ciência da Computação, Pós-graduação em Sistemas Orientados a Objetos, MBA
em Gestão Estratégica de TI pela FGV e Mestre em Gestão Estratégica das Organizações.
Tem experiência na área de Ciência da Computação, com ênfase Fábrica de Software,
Engenharia de Software e Governança Estratégica de TI;
Atuou como Gerente de Projetos Estratégicos de TI na CAPGEMINI/CPMBRAXIS, a maior
empresa de TI europeia e sétima maior do mundo, nas operações do Ministério de Ciência e
Tecnologia, Caixa Econômica Federal, Brasiltelecom, Oi e Embratur.
Atuou como Coordenador de TI pela Stefanini IT Solutions, maior empresa de TI brasileira, em
operações de missão crítica de TI na BrasilTelecom.
Atuou também professor de Informática da EIBNET – Escola de Informática de Brasília com
mais de 15.000 horas de treinamentos em JAVA, SCRUM, COBIT, APF, RUP e ITIL.
Foi professor de ensino superior de TI no Instituto Fátima em Brasília – DF durante 6 anos.
Hoje atua como coordenador da divisão de Desenvolvimento de Software da autarquia pública
CFM - Conselho Federal de Medicina e professor de ensino superior da Faculdade JK.
Atua também como instrutor da LogusTI.
Possui as certificações internacionais IBM Certified Solution Designer - Sun Certified Java
Programmer, IBM Rational Unified Process V7.0, COBIT, ITIL Foundation Certified e
ScrumMaster Certified pela ScrumAlliance.
https://www.linkedin.com/in/gleidson-porto-06817637/
gleidsonporto@gmail.com
http://lattes.cnpq.br/6540446452817806
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 4
Sumário
1 INTRODUÇÃO .............................................................................................................................................. 8
1.3 História da Linguagem Java ......................................................................................................................... 9
2 A LINGUAGEM JAVA ................................................................................................................................. 10
2.1 Java ......................................................................................................................................................... 10
2.2 Máquina Virtual ......................................................................................................................................... 10
2.3 Garbage Collection ................................................................................................................................... 11
2.4 Instalando o Java ...................................................................................................................................... 12
2.4.1 Instalando o JDK .................................................................................................................................... 12
2.4.2 Configurando o Java no Windows ........................................................................................................... 13
2.4.3 Confirmando a instalação e configuração do Java .................................................................................... 15
2.5 Compilando e executando o primeiro programa .......................................................................................... 15
3 AMBIENTE INTEGRADO DE DESENVOLVIMENTO - ECLIPSE ................................................................... 17
3.1 O Eclipse .................................................................................................................................................. 17
3.2 Característica e Ferramentas ..................................................................................................................... 17
3.3 Instalando o Eclipse .................................................................................................................................. 18
3.4 Conhecendo o Eclipse ............................................................................................................................... 18
4 SINTAXE DA LINGUAGEM JAVA................................................................................................................ 20
4.1 Delimitadores em Java .............................................................................................................................. 20
4.2 Identificadores e palavras reservadas......................................................................................................... 21
4.3 Declarando variáveis em Java ................................................................................................................... 23
4.5 - Convenções de codificação ..................................................................................................................... 26
4.6 Exercícios........................................................................................................................................ 27
5 EXPRESSÕES ............................................................................................................................................ 28
5.1 Operadores lógicos e aritméticos ............................................................................................................... 28
5.2 Concatenação de Strings com o operador + ............................................................................................... 29
Alguns métodos úteis em dados do tipo String:................................................................................................. 29
5.3 Promoção e Casting .................................................................................................................................. 30
5.4 Operadores de deslocamento (>>, <<, >>>)................................................................................................ 31
5.5 Circuitos lógicos ........................................................................................................................................ 31
5.6 Exercícios........................................................................................................................................ 32
6 FLUXO DE CONTROLE .............................................................................................................................. 33
6.1 Ramificação if,else ................................................................................................................................... 33
6.2 Ramificação switch ................................................................................................................................... 34
6.3 Repetição for ............................................................................................................................................ 35
6.4 Repetição while ........................................................................................................................................ 36
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 5
6.5 Comandos especiais de controle de fluxo: break, continue e label ................................................................ 37
6.6 Lendo valores do teclado ........................................................................................................................... 38
6.7 Exercícios................................................................................................................................................. 38
7 AGRUPAMENTO DE DADOS (ARRAYS)..................................................................................................... 39
7.1 Declarando e criando Arrays ...................................................................................................................... 39
7.2 Modificando o conteúdo de um array .......................................................................................................... 41
7.3 Acessando o conteúdo de um array ........................................................................................................... 41
7.4 Percorrendo um Array ............................................................................................................................... 42
7.5.1 Ordenando um Array .............................................................................................................................. 43
7.5.2 Duplicando um Array .............................................................................................................................. 43
7.5.3 Preenchendo um Array ........................................................................................................................... 43
7.6 Arrays multidimensionais ........................................................................................................................... 44
7.7 Array esparso ........................................................................................................................................... 44
7.8 Exercícios........................................................................................................................................ 45
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA ................................................................................................... 46
8.1 Fundamentos da Programação Orientada a Objetos ................................................................................... 46
8.2. Paradigma Orientado por Objetos ............................................................................................................. 46
8.3 Principais conceitos de POO...................................................................................................................... 46
8.3.1 Objetos .................................................................................................................................................. 46
8.3.2 Atributos e métodos................................................................................................................................ 48
8.3.3 Classes ................................................................................................................................................. 49
8.3.3 Instanciação........................................................................................................................................... 50
8.4 - Exercício - Conceitos OO ........................................................................................................................ 51
8.5 – Classes e Objetos em Java ..................................................................................................................... 52
8.5.1 Criando objetos em Java ........................................................................................................................ 52
8.5.2 Referências ........................................................................................................................................... 53
8.5.3 Manipulando Atributos ............................................................................................................................ 54
8.5.4 Valores Padrão ...................................................................................................................................... 54
8.6 Exercícios Complementares ...................................................................................................................... 56
9 OO - HERANÇA, POLIMORFISMO E INTERFACES .................................................................................... 57
9.1 Objetos e Construtor ................................................................................................................................. 57
9.2 Herança ................................................................................................................................................... 57
9.3 Polimorfismo ............................................................................................................................................. 59
9.3.1 Polimorfismo - Sobreescrita .................................................................................................................... 60
9.3.2 Polimorfismo – Sobrecarga ..................................................................................................................... 61
9.4 Exercício - Polimorfismo ............................................................................................................................ 62
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 6
9.5 Interfaces ................................................................................................................................................. 63
10 OO - CLASSES ABSTRATAS.................................................................................................................... 65
11 MODIFICADORES JAVA ........................................................................................................................... 66
11.1 Introdução .............................................................................................................................................. 66
11.2 Modificadores de Acesso ......................................................................................................................... 66
11.2.1 Private ................................................................................................................................................. 67
11.2.2 Protected ............................................................................................................................................. 68
11.2.3 Public .................................................................................................................................................. 69
11.2.4 Default (padrão) ................................................................................................................................... 69
11.3 Outros Modificadores ..............................................................................................................................69
11.3.1 Final .................................................................................................................................................... 69
11.3.2Abstract ................................................................................................................................................ 70
11.3.3 Static ................................................................................................................................................... 70
11.3.4 Transient ............................................................................................................................................. 71
11.3.5 Synchronized ....................................................................................................................................... 71
11.3.6 Volatile ................................................................................................................................................ 71
11.3.7 Native .................................................................................................................................................. 71
11.4 Encapsulamento ..................................................................................................................................... 71
11.4.1 Métodos Getters e Setters .................................................................................................................... 72
11.5 Exercício ................................................................................................................................................ 73
12 EXCEÇÕES – CONTROLANDO OS ERROS .............................................................................................. 75
12.1 Tratamento de exceções ......................................................................................................................... 75
12.2 Erros e Exceções de runtime ................................................................................................................... 77
12.3 Propagando exceções ............................................................................................................................. 77
12.4 Definindo e gerando exceçoes ................................................................................................................. 78
12.5 Hierarquia de exceções Java ................................................................................................................... 79
13 THREADS .......................................................................................................................................... 81
13.1 Conceito de Threads ............................................................................................................................... 81
13.2 Ciclo de Vida de uma Thread ................................................................................................................... 82
13.2.1 Criando Threads................................................................................................................................... 82
13.2.2 Iniciando Threads ................................................................................................................................. 83
13.2.3 Fazendo Thread Esperar ...................................................................................................................... 83
13.2.4 Finalizando Threads ............................................................................................................................. 83
13.2.5 Verificando se Threads estão Executando/Pronta/Esperando ou Novas/Mortas........................................ 83
13.3 Implementando Threads em java ............................................................................................................. 83
13.4 Escalonamento de Threads ..................................................................................................................... 85
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 7
13.5 Exercícios ............................................................................................................................................... 88
14 API JAVA - JAVA.IO ................................................................................................................................ 89
14.1 Classe InputStream ................................................................................................................................. 89
14.2 Lendo um arquivo ................................................................................................................................... 90
14.3 OutputStream ......................................................................................................................................... 92
14.4 Reader ................................................................................................................................................... 92
14.5 Writer ..................................................................................................................................................... 92
14.6 Buffers.................................................................................................................................................... 93
14.7 Exercícios ............................................................................................................................................... 94
15 COLLECTIONS FRAMEWORK .................................................................................................................. 95
15.1 – Introdução............................................................................................................................................ 95
15.2 – Tipos de Coleções ................................................................................................................................ 95
15.2.1 – Lista.................................................................................................................................................. 98
15.2.2 – Conjunto ........................................................................................................................................... 99
15.2.3 – Mapas............................................................................................................................................... 99
15.3 – Exercício ............................................................................................................................................ 101
RESPOSTAS DO EXERCÍCIOS.................................................................................................................... 102
REFERÊNCIAS ............................................................................................................................................ 137
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 8
1 INTRODUÇÃO
1.1 Sobre a LogusTI
A LogusTI nasceu da necessidade de oferecer novos treinamentos na área de Tecnologia
da Informação em Brasília, visto que este segmento é escasso na Capital Federal.
A excelência dos serviços prestados pela LogusTI está apoiada em profissionais
especializados, processos estabelecidos e uma larga experiência em seus profissionais. O
capital humano é um elemento chave na estratégia de atuação da empresa, que investe
continuamente na atualização e capacitação de seus profissionais, propiciando um ambiente
encorajador para serem os melhores naquilo que fazem.
A alta qualidade dos serviços prestados aliada ao compromisso em gerar resultados e
proporcionarmaior vantagem competitiva a seus clientes tem propiciado a LogusTI
relacionamentos duradouros e bem sucedidos com empresas de diversos segmentos de
mercado.
O principal objetivo da LogusTI é promover treinamentos de máxima qualidade que
relacionados às principais tecnologias utilizadas pelas empresas. Por meio desses
treinamentos, seus alunos se tornam capacitados para atuar no mercado de trabalho.
1.2 Objetivo
O objetivo fundamental dos treinamentos da LogusTI é transmitir os conhecimentos necessários
para que os seus alunos possam atuar no mercado de trabalho na área de Tecnologia da Informação.
A plataforma Java é a mais utilizada no desenvolvimento de software no mundo. Para utilizar os
recursos oferecidos por essa plataforma de forma eficiente, é necessário possuir conhecimento sólido
em orientação a objetos.
Assim sendo, esta apostila da LogusTI tem como intuito ensinar Java de uma maneira simples e
objetiva.
Esperamos que você aproveite esse material, e que ele possa contribuir positivamente para
construção do conhecimento acerca da programação Java.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 9
1.3 História da Linguagem Java
Java é uma linguagem de programação interpretada orientada a objetos
desenvolvida na década de 90 por uma equipe de programadores chefiada
por James Gosling, na empresa Sun Microsystems, adquirida pela Oracle.
Diferente das linguagens de programação convencionais, que são
compiladas para código nativo, a linguagem Java é compilada para um
bytecode que é executado por uma máquina virtual. A linguagem de
programação Java é a linguagem convencional da Plataforma Java, mas
não é a sua única linguagem.
Em 1991, na Sun Microsystems, foi iniciado o Green Project, o berço do Java, uma linguagem de
programação orientada a objetos. Os mentores do projeto eram Patrick Naughton, Mike Sheridan, e James
Gosling. Eles acreditavam que, eventualmente, haveria uma convergência dos computadores com os
equipamentos e eletrodomésticos frequentemente usados pelas pessoas no seu dia-a-dia.
Para provar a viabilidade desta ideia, 13 pessoas trabalharam arduamente durante 18 meses. No verão de
1992 eles emergiram de um escritório de Sand Hill Road, no Menlo Park, com uma demonstração funcional da
ideia inicial. O protótipo se chamava *7 (lê-se “Star Seven”), um controle remoto com uma interface gráfica
touchscreen. Para o *7, foi criado um mascote, hoje amplamente conhecido no mundo Java, o Duke. O trabalho
do Duke no *7 era ser um guia virtual ajudando e ensinando o usuário a utilizar o equipamento. O *7 tinha a
habilidade de controlar diversos dispositivos e aplicações. James Gosling especificou uma nova linguagem de
programação para o *7. Gosling decidiu batizá-la de “Oak”, que quer dizer carvalho, uma árvore que ele podia
observar quando olhava através da sua janela.
O nome da linguagem desenvolvida pelo projeto Green foi mudada de Oak para Java, que foi uma
homenagem à uma ilha da Indonésia de onde os Norte-Americanos importavam o café que era consumido pela
equipe de James Gosling. Ate 1994, não havia uma aplicação definida para o Java. Foi quando Jonathan Payne e
Patrick Naughton criaram um novo navegador para Web que podia executar programas escritos em Java
(applets), batizado de Web Runner. E em 1996, em uma iniciativa inédita, a Sun Microsystems resolveu
disponibilizar gratuitamente um kit de desenvolvimento de software para a comunidade, que ficou conhecido como
Java Developer`s Kit (JDK). Desde então a aceitação da tecnologia Java cresceu rapidamente entre empresas e
desenvolvedores. A Sun Microsystems lançou o JDK 1.1 com melhorias significativas para o desenvolvimento de
aplicações gráficas e distribuídas. Depois disso, a empresa continuou lançando novas versões gratuitas com
novas melhorias e recursos.
Em abril de 2009, a Oracle ofereceu US$ 7,4 bilhões pela aquisição da Sun Microsystems e a proposta foi
aceita. Essa aquisição deu à Oracle a propriedade de vários produtos, incluindo o Java e o sistema operacional
Solaris. Em comunicado, a Oracle afirmou que o Java foi o software mais importante adquirido ao longo de sua
história. Muitas especulações foram feitas acerca do futuro do Java depois de passar a ser propriedade da Oracle.
Mais com certeza essa aquisição contribuiu muito para que o Java tivesse um salto qualitativo.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 10
2 A LINGUAGEM JAVA
2.1 Java
Java é uma linguagem de programação orientada a objetos desenvolvida pela antiga Sun Microsystems,
agora Oracle. Modelada depois de C++, a linguagem Java foi projetada para ser pequena, simples e portável a
todas as plataformas e sistemas operacionais, tanto o código fonte como os binários. Esta portabilidade é obtida
pelo fato da linguagem ser interpretada, ou seja, o compilador gera um código independente de máquina chamado
byte-code. No momento da execução este byte-code é interpretado por uma máquina virtual instalado na máquina.
Para portar Java para uma arquitetura hadware/s específica, basta instalar a máquina virtual
(interpretador). Além de ser integrada à Internet, Java também é uma excelente linguagem para desenvolvimento
de aplicações em geral. Dá suporte ao desenvolvimento de software em larga escala.
2.2 Máquina Virtual
De acordo com a especificação da SUN, a máquina virtual do Java pode ser vista como:
Para um programa Java ser executado, ele precisa passar pelo processo ilustrado na figura abaixo:
Figura 1- JVM
O código é compilado, gerando um conjunto de instruções chamado de byte-code. Esse byte-code é
aplicado à Máquina Virtual Java (JVM) que se encarrega de interpretar os comandos para o sistema
operacional onde o programa está rodando. Ou seja, a máquina virtual traduz as instruções do código Java para
instruções válidas no sistema operacional em que está rodando. Se essa portabilidade fosse requerida em C, o
código deveria ser compilado várias vezes – uma para cada sistema operacional desejado. No caso do Java, o
código é compilado apenas uma vez, gerando o byte-code. Esse byte-code poderá então ser interpretado por
qualquer máquina virtual Java, rodando em Linux, Windows, Palm OS, Solaris ou qualquer outro sistema
operacional que possua uma máquina virtual Java implementada. (Compile once, run anywhere).
Uma máquina imaginária que é implementada via software ou hardware. Um código a ser
executado por essa máquina deve ser gravado em um arquivo com extensão .class. e
possuir um código compatível com as instruções Java.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 11
Uma JVM possui definições concretas para a implementação dos seguintes itens:
Conjunto de instruções (equivalentes às instruções da CPU)
Conjunto de registradores
Formato padrão de classes
Pilha de memória
Pilha de objetos coletados pelo garbage-collector
Área de memória
IMPORTANTE: a JVM não permite que um programa Java acesse recursos de hardware diretamente, protegendo
o computador de operações perigosas, como acesso à regiões protegidas da memória ou formatação física do
disco rígido.
Um programa Java só é executado caso o seu byte-code passe pela verificação de segurança da JVM, que
consiste em dizer que:
O programa foi escrito utilizando-se a sintaxe e semântica da linguagem Java
Não existem violações de áreas restritas de memória no código
O código não gera Stack Overflow
Os tipos de parâmetrosdos métodos são corretos
Não existe nenhuma conversão ilegal entre dados do programa, como a tentativa de conversão de inteiros
em ponteiros
O acesso a objetos está corretamente declarado
Caso alguma das condições acima não seja satisfeita, a máquina virtual Java causará um erro de execução
(runtime error).
2.3 Garbage Collection
Durante a execução de um programa de computador, ocorre a alocação e liberação dinâmica de memória
RAM. Dados são escritos e lidos da memória do computador satisfazendo os requisitos de cada programa. Em
linguagens tradicionais como Pascal, Basic e C/C++, o programador é responsável por controlar essa alocação,
impedindo o estouro de memória (stack overflow) e outros problemas, como o acesso indevido a áreas reservadas
de memória. Para facilitar a vida dos programadores, e evitar os erros comuns associados à alocação de
memória, a linguagem Java introduziu um novo conceito: o garbage-collection.
Garbage-collection é um mecanismo de controle automático de alocação e liberação de memória.
Quando uma variável é declarada em um código de computador, a JVM cria um ponteiro para uma área
de memória equivalente ao tamanho do tipo de dado utilizado por essa variável. Quando essa variável é
associada a outra região de memória, a JVM coloca o espaço alocado anteriormente em uma pilha de objetos em
Mais sobre
Geralmente, as máquinas virtuais utilizam uma estratégia de compilação chamada Just-in-time
compilation (JIT). Nessa abordagem, o código de máquina pode ser gerado diversas vezes durante o
processamento de um programa com o intuito de melhorar a utilização dos recursos disponíveis em um
determinado instante da execução.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 12
desuso. Caso o computador fique com pouca memória disponível, a JVM remove objetos dessa pilha, permitindo
que esse espaço de memória seja realocado.
O processo de garbage-collection ocorre automaticamente durante a execução de um programa Java. O
programador não precisa se preocupar com aritmética de ponteiros (grande dificuldade em linguagens como C e
Pascal).
2.4 Instalando o Java
Para desenvolver aplicações Java, o programador deve instalar em sua máquina um Java Development
Kit(JDK). Um JDK contém diversas ferramentas utilizadas na criação de um programa Java. Mostraremos a
seguir como instalar um JDK no sistema operacional Windows.
JDK: Faça o download da versão mais atual aqui:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Observe abaixo que a Oracle disponibiliza a versão do JDK para vários sistemas operacionais. Vamos
utilizar a versão jdk-8u101-windows-x64.exe para o Windows x64 de 193.68 MB.
Figura 2 – Site da Oracle para download do JDK
O procedimento de instalação no Windows é muito simples: basta você executar o arquivo e seguir os
passos abaixo:
2.4.1 Instalando o JDK
Execute o instalador do JDK (jdk-8u101-windows-x64.exe) e siga as instruções até concluir (next > next >
finish ), se desejar, é possível informar o diretório de instalação (que vai ser muito importante para
realizarmos a configuração do JDK – Figura 3).
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 13
Figura 3 – Tela de Instalação do JDK
Juntamente com o JDK será feita a instalação do JRE (Java Runtime Environment) que é o aplicativo que
permite executar os programas em JAVA no seu sistema operacional.
2.4.2 Configurando o Java no Windows
Clique com o botão direito em Computador e siga as opções Propriedades > Configurações
avançadas do sistema > (aba Avançado) Variáveis de Ambiente…
Crie/edite as variáveis do sistema listadas abaixo:
JAVA_HOME
Informe o diretório da instalação do JDK (Figura 4).
Exemplo C:\Program Files\Java\jdk1.8.0_101
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 14
Figura 4 – Configuração da variável de ambiente “JAVA_HOME”.
PATH
Informe %JAVA_HOME%\bin (Figura 5).
Figura 5– Configuração da variável de ambiente “PATH”.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 15
2.4.3 Confirmando a instalação e configuração do Java
Para confirmar que a instalação e configuração do JAVA foi realizada com sucesso, execute os comandos
“java -version” e “javac -version” no prompt de comando. O resultado esperado está na Figura 6.
Figura 6 – Validação de instalação e configuração do Java
2.5 Compilando e executando o primeiro programa
Vamos criar um simples programa para entendermos como funciona o processo de compilação e
execução. Utilizaremos a linguagem Java, que é amplamente adotada nas empresas. Observe o código do
exemplo de um programa escrito em Java que imprime uma mensagem na tela:
1 public class OlaMundo {
2 public static void main ( String [] args ) {
3 System.out.println("Olá Mundo!");
4 }
5 }
Código Java 2.5: OlaMundo.java
O código fonte Java deve ser colocado em arquivos com a extensão .java. Agora, não é necessário
entender todo o código do exemplo. Basta saber que toda aplicação Java precisa ter um método especial
chamado main para executar.
O próximo passo é compilar o código fonte, para gerar um executável que possa ser processado pela
máquina virtual do Java. O compilador padrão da plataforma Java ( javac) pode ser utilizado para compilar esse
arquivo. O compilador pode ser executado pelo terminal.
Mais sobre
No Linux, são as mesmas variáveis, mas o PATH é separado por :. Nos Windows velhos, como o 98, você
deve alterar isso no autoexec.bat. Nos Windows mais novos, como NT, 2000, e XP, procure onde você pode
adicionar novas variáveis de ambiente (em Iniciar - Painel de Controle – Sistema – Avançado Variáveis de
Sistema). No Linux, geralmente a alteração deverá ser feita no arquivo ~/.bashrc se você não tiver privilégios
de administrador.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 16
C:\LOGUSTI\EXEMPLOS> dir
OlaMundo.java
C:\LOGUSTI\EXEMPLOS>javac OlaMundo.java
C:\LOGUSTI\EXEMPLOS> dir
OlaMundo.class
OlaMundo.java
O código gerado pelo compilador Java é armazenado em arquivos com a extensão .class. No exemplo, o
programa gerado pelo compilador é colocado em um arquivo chamado OlaMundo.class e ele pode ser executado
através de um terminal.
C:\LOGUSTI\EXEMPLOS> dir
OlaMundo.class
OlaMundo.java
C:\LOGUSTI\EXEMPLOS> java OlaMundo
Olá Mundo!
Importante
Antes de compilar e executar um programa escrito em Java, é necessário que você tenha instalado e
configurado em seu computador o JDK (Java Development Kit).
2.5 – Exercícios
Mais sobre
Quando uma aplicação ou biblioteca Java é composta por diversos arquivos .class, podemos “empacotá-los” em um
único arquivo com a extensão .jar com o intuito de facilitar a distribuição da aplicação ou da biblioteca.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 17
3 AMBIENTE INTEGRADO DE DESENVOLVIMENTO -
ECLIPSE
3.1 O Eclipse
Na prática, alguma ferramenta de desenvolvimento é adotada para aumentar a produtividade. Essas
ferramentas são chamadas IDE (Integrated Development Environment - Ambiente de Desenvolvimento Integrado).Uma IDE é uma ferramenta que provê facilidades para o desenvolvedor realizar as principais tarefas relacionadas
ao desenvolvimento de um software.
No caso específico da plataforma Java, a IDE mais utilizada é o Eclipse. Essa ferramenta é bem
abrangente e oferece recursos sofisticados para o desenvolvimento de uma aplicação Java. Além disso, ela é
gratuita.
É a IDE líder de mercado. Formada por um consórcio liderado pela IBM, possui seu código livre.
As diversas distribuições do Eclipse podem ser obtidas através do site http://www.eclipse. org/.
Descompacte o arquivo e pronto; basta rodar o executável.
3.2 Característica e Ferramentas
A IDE Eclipse é um programa que reúne ferramentas de apoio ao desenvolvimento de software
possibilitando uma agilidade maior no processo de construção de um software.
Editor – edita o código-fonte do programa escrito
Compiler – compila o código-fonte transformando em código de máquina.
Linker – são os vários pedaços de códigos reunidos transformando em um executável.
Debugger – processo de se localizar erros(famosos bugs) .
Modelling - criação do modelo de classes, objetos, interfaces, associações e interações
dos artefatos envolvidos no software.
Geração de código - A IDE gera códigos(templates) comumente utilizados
possibilitando algumas soluções.
Deploy - auxilia no processo de criação do instalador do software. (no nosso caso os famosos
*.jar).
Automated tests - realiza testes no software de forma automatizada,
Refactoring - consiste na melhoria constante do código-fonte do software para construção
de código mais otimizado.
IMPORTANTE
Preciso pagar pela ferramenta Eclipse?
Não, é uma ferramenta OPEN SOURCE conforme mencionado acima é um software livre.
Porque o Eclipse faz tanto sucesso?
“Na prática ele cria um modelo de Open Innovation Network, onde empresas concorrentes podem criar redes de
inovação, cooperando no desenvolvimento de softwares Open Source...” - Cezar Taurion(IBM)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 18
3.3 Instalando o Eclipse
O Eclipse roda direto de um arquivo executável. Realize o download por meio do link
http://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/neonr e extraia o
pacote “.zip” do Eclipse (eclipse-java-neon-R-win32-x86_64.zip) para o diretório de sua preferência. Execute o
arquivo eclipse.exe para iniciar.
Ao iniciar o eclipse, você deve definir o workspace de trabalho (que é a pasta onde será mantido seu
espaço de trabalho – Figura 7).
Figura 7 – Configuração do workspace do Eclipse.
Figura 8 – Tela inicial do Eclipse.
3.4 Conhecendo o Eclipse
O eclipse possui uma interface amigável com as ferramentas agrupadas por perspectivas(Views e
Perspective). Iremos utilizar a perspectiva Java que apresenta os seguintes recursos:
1 - Package Explorer - janela contendo todos os projetos desenvolvidos, cada projeto representa um
programa ou aplicação;
2 - Problems - janela que indica erros contidos no código ordenados pela linha em que acontece;
3 - Console - janela responsável pela saída de padrão para mensagens proveniente qualquer
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 19
programa Java;
4 - Janela com código - janela onde aparecerá o código fonte do arquivo .java selecionado no
momento.Tal janela aparece automaticamente ou dando 2 cliques em algum arquivo .java presente na
janela Package Explorer.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 20
4 SINTAXE DA LINGUAGEM JAVA
4.1 Delimitadores em Java
Em um código-fonte Java, alguns símbolos são utilizados pelo compilador para diferenciar comandos,
blocos de comandos, métodos, classes, etc. Tais símbolos, chamados de delimitadores, são
enumerados abaixo:
Comentários
Comentários servem para identificar a função de um comando, um trecho de código, ou um
método. Além disso, os comentários podem ser utilizados para documentar aspectos de desenvolvimento
de um programa: como o nome da empresa que o desenvolveu, nome dos programadores, versão, etc.
Existem dois tipos de comentário: o simples e o de documentação.
O comentário simples é delimitado por duas barras // e termina ao final de uma linha, conforme
abaixo.
// comentário simples: não será incluído na documentação
// do programa (note que comentários simples exigem
// um par de barras para cada linha).
O comentário de bloco é delimitado por duas barras /* e termina com */ ao final de uma linha.
/* Comentário de bloco
utilizado para comentar
várias linhas de código */
O comentário de documentação é iniciado pelo símbolo /** e encerrado pelo símbolo */, podendo
conter várias linhas de texto e linhas em branco. Esse tipo de comentário será utilizado pela ferramenta
geradora de documentação javadoc, que acompanha o ambiente de desenvolvimento SDK.
Todo o texto entre os delimitadores de comentários do Javadoc é ignorado pelo compilador.
Permitem incorporar a documentação do programa diretamente nos programas. O programa utilitário
javadoc lê comentários no estilo Javadoc e utiliza-os para preparar a documentação do seu programa no
formato HTML.
Ponto e vírgula, blocos e espaços em branco: em Java, todo comando é terminado por um
ponto e vírgula (;).
Exemplo:
System.out.println ("note o ponto e vírgula no final ");
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 21
Um bloco é formado por um conjunto de instruções delimitadas por chaves, como no exemplo abaixo:
/** Exemplo de bloco */
{ // Chamamos essa chave de início de bloco
int ano; // Note o ponto e vírgula
ano = 2002; // sempre ao final de um comando Java
} // Chamamos essa chave de final de bloco
O espaço em branco, quebra de linha e caracteres de tabulação são permitidos em qualquer trecho do
código-fonte, devendo ser utilizados para realçar o aspecto visual de seu código.
IMPORTANTE
Apesar do aspecto visual do código-fonte não ter nenhum impacto no desempenho de um programa
Java, o uso de endentação é uma característica de bons códigos-fonte. Lembre-se que você não será o
único a ler o código-fonte de seus programas, portanto escreva-o da maneira mais organizada e legível
possível.
4.2 Identificadores e palavras reservadas
Em Java, um identificador é uma sequência de símbolos UNICODE (64K símbolos) que começa
com uma letra, um símbolo subscrito _, ou o caractere $. Os demais símbolos de um identificador podem
conter também números. Identificadores são case-sensitive e não tem um tamanho máximo estabelecido.
Apesar da tabela UNICODE ser bastante extensa, um bom hábito de programação é utilizar somente
letras do alfabeto (a-Z) e números para nomear identificadores.
Exemplo de identificadores válidos em Java:
data
_data
$data
data_do_mês
data1
uma_variável_pode_SER_bastante_extensa_e_conter_Numeros234876238476
data_public_class_NoteQueEsseIdentificadorContemPalavrasReservadas
Apesar desta "liberdade" de opções para nomes de identificadores, algumas palavras não são
permitidas. Tais palavras são ditas palavras reservadas, e representam o conjunto de comandos que
forma a sintaxe da linguagem Java. O conjunto de palavras reservadas em Java é o seguinte:
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICAPÁGINA 22
abstract double int strictfp
boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float package throw
char for private throws
class goto protected transient
const if public try
continue implements return void
default import short volatile
do instanceof static while
IMPORTANTE
Você não precisa se preocupar em memorizar o nome das palavras reservadas em Java. À medida que
você for praticando a programação em Java, isso se tornará natural. Além disso, o compilador acusa um
erro de nomenclatura quando você tenta utilizar uma palavra reservada para nomear uma variável, um
método ou uma classe.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 23
4.3 Declarando variáveis em Java
Uma variável é sempre declarada seguindo do seguinte esquema:
<tipo> + <espaço> + identificador + ;
ou
<tipo> + <espaço> + identificador + = + valor + ;
onde:
<tipo> é um tipo primitivo de dados ou o nome de uma classe ou interface
identificador é o nome da variável
valor é o valor atribuído à variável.
Exemplos:
int number1 = 10; // primeiro número a somar
int number2 = 20; // segundo número a somar
int sum; // soma de number1 e number2
IMPORTANTE
Caso você declare uma variável e não atribua nenhum valor, ela não poderá ser utilizada em um código
Java – a tentativa de utilizar uma variável não inicializada em Java gerará um erro de compilação.
IMPORTANTE
Veremos mais adiante que Java possui um mecanismo de inicialização de variáveis de seus tipos
primitivos, mas o aluno deve evitar considerar essa inicialização como prática de programação. De fato,
esta inicialização automática não funciona para variáveis de tipos agregados ou abstratos de dados e
também que o escopo das variáveis – de classe ou de instância - tem influência na sua inicialização. O
aluno é fortemente recomendado a pensar em variáveis como espaços alocados na memória RAM,
inicialmente podendo conter qualquer valor (conhecido como lixo na memória).
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 24
4.4 Tipos primitivos da linguagem Java
A linguagem Java utiliza oito tipos primitivos de dados e um tipo especial. Esses tipos primitivos
podem ser utilizados para declarar constantes ou variáveis utilizadas em programas Java. Os tipos
primitivos estão divididos em quatro categorias: lógicos, textuais, numéricos inteiros e numéricos de ponto
flutuante.
Tipos lógicos: boolean
Valores lógicos possuem dois estados, normalmente ditos verdadeiro/falso, sim/não e ligado/
desligado. Em Java um tipo lógico é definido pela palavra boolean, e pode assumir dois valores: true ou
false.
// Exemplo de variável que suporta valores booleanos
boolean anoBissexto = false;
boolean anoPar = true;
// Apesar de uma variável poder ser declarada
// sem receber um valor, ela só poderá ser usada
// após a atribuição de algum valor a ela.
boolean valido;
Tipos textuais: char e String
Caracteres simples são representados pelo tipo char. Um char representa um caracter UNICODE, ou
seja, um número inteiro sem sinal de 16 bits, no intervalo de 0 até 216-1. O valor de um literal char deve
ser delimitado por aspas simples:
// Exemplo de representação de caracteres UNICODE
char primeiraLetra = 'a';
char tabulacao = '\t';
// Código UNICODE para o caractere de interrogação
char unicode = '\u0A02';
// Lembre-se: Uma variável só poderá
// ser manipulada após receber um valor.
char inutil; // variável sem utilidade neste momento
inutil = '@'; // variável útil a partir de agora
Palavras são representadas por uma sequência de dados do tipo char, agrupadas em um tipo
“especial” de dados: a classe String. Apesar de ser uma classe, uma variável do tipo String suporta
operações como se fosse um tipo primitivo de dados. O valor de uma variável String deve ser delimitado
por aspas duplas "valor".
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 25
// Exemplo de uso de variáveis do tipo String
String curso = "Java Básico OO - LogusTI";
// Uma variável pode receber o valor de outra
String outraVariavel = curso;
// A concatenação de Strings pode ser feita através do operador de soma (+)
curso = "Java Básico OO " + " Java Web" ;
// Concatenação de String com outro tipo de dados:
curso = "Java Básico OO" + 'I';
curso = "Java Básico OO" + 1;
// Para comparar duas variáveis do tipo String devemos usar o método
equals():
// curso == "Java Básico OO..." INCORRETO
// curso.equals("Java Básico OO...") CORRETO
A concatenação de qualquer tipo de dado com um dado do tipo String resulta em um novo dado do tipo
String.
Tipos numéricos inteiros: byte, short, int e long
Existem quatro tipos primitivos de números em Java. Além disso, os valores numéricos podem
ser representados de forma decimal, octal ou hexadecimal:
Valores numéricos inteiros em Java:
2 decimal
077 um número que começa com zero está representado de forma octal
0xBABE representação hexadecimal
Todos os valores numéricos em Java tem sinal positivo ou negativo.
Um valor numérico é sempre considerado do tipo int, a menos que seja acompanhado do sufixo
L, que representa um valor do tipo long. A diferença de um inteiro para um longo é a capacidade de
dígitos que podem ser representados, conforme aparece no quadro abaixo.
Valores numéricos em Java, representados como long:
2L decimal
077L um número que começa com zero está representado de forma octal
0xBABEL representação hexadecimal
// Valores inteiros representáveis pelos tipos numéricos em Java:
byte a = 127; // -27 ... 27 -1
short b = 32767; // -215 ... 215 -1
int c = 2147483647; // -231 ... 231 -1
long d = 9223372036854775807L; // -263 ... 263 –1
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 26
Tipos numéricos de ponto flutuante: float e double
Um valor fracionário pode ser representado em Java através dos tipos float e double. A diferença
entre esses dois tipos é o tamanho de bits:
float 32 bits
double 64 bits
Para um número ser considerado do tipo ponto flutuante, é necessário a inc lusão de um ponto,
do caractere E (de expoente) ou do sufixo D ou F, conforme mostra o quadro abaixo:
// Representação de valores numéricos de ponto flutuante
float pi = 3.141516F;
float taxa = 15.02E23f;
double salario = 22521.20D;
// Quando não é definido o sufixo para um número decimal, o compilador entende
que o tipo é double
double valor= 122.4E+306;
double valorX= 99.22;
IMPORTANTE
Todo o valor numérico de ponto flutuante é considerado do tipo double, a menos que o programador o
declare explicitamente como float.
4.5 - Convenções de codificação
Em geral, as linguagens de programação possuem convenções para definir os nomes das
variáveis. Essas convenções ajudam o desenvolvimento de um código mais legível.
Classes – as classes devem ser designadas por nomes, começando por uma letra maiúscula e
depois minúsculas. Cada nova palavra que formar o nome da classe deve ser capitalizada.
Ex: class Calculadora, class PessoaFisica e class CalculadoraCientifica
Intefaces – igual às classes.
Ex: interface Calculo e interface EquacaoLogaritmica.
Métodos – métodos devem nomeados por verbos, seguindo o mesmo formato de capitalização
das classes. Entretanto, um método sempre deve começar comletra minúscula.
Ex: public void calcular(int numero), public void extrairRaiz(int numero), ...
Constantes – constantes devem ter todas as suas letras em maiúsculo, com o símbolo de
subscrito para separa as palavras.
Ex: final int ANO = 2002, final boolean VERDADE = true, ...
Variáveis – tal qual os métodos, as variáveis devem começar com uma letra minúscula e depois
alternar a cada palavra. Procure usar nomes significativos para variáveis. Evite declarar variáveis
usando apenas um a letra.
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 27
Mais Sobre
Em geral, as linguagens de programação possuem convenções para definir os nomes das variáveis.
Essas convenções ajudam o desenvolvimento de um código mais legível.
Na convenção de nomes da linguagem Java, os nomes das variáveis devem seguir o padrão camel case
com a primeira letra minúscula (lower camel case). Veja alguns exemplos:
nomeDoCliente
numeroDeAprovados
A convenção de nomes da linguagem Java pode ser consultada na seguinte url: http://www.
oracle.com/technetwork/java/codeconv-138413.html
4.6 Exercícios
a) Altere o programa AloMundo.Java para que ele imprima na tela todos os tipos primitivos de dados
suportados pela linguagem Java.
b) Altere o programa AloMundo para que ele imprima os parâmetros recebidos pela linha de comando de
execução do programa. (Dica: são os valores do array args: args[0], args[1], etc.)
c) Crie um programa que receba três argumentos da linha de comando e imprima-os na mesma linha, em
ordem inversa.
Exemplo:
java Programa a1 a2 a3
Saída: a3 a2 a1
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 28
5 EXPRESSÕES
Esta seção apresenta a manipulação de variáveis e implementação de tomada de decisões em
programas Java.
5.1 Operadores lógicos e aritméticos
Os operadores Java são similares em estilo e função aos operadores da linguagem C/C++. A
tabela abaixo enumera esses operadores.
Delimitadores . [] () ; , Servem para delimitar partes
distintas de um comando,
método ou classe.
Operador Função
++ Incrementa o valor da variável em uma unidade.
Exemplo: i++; contador++;
-- Incrementa o valor da variável em uma unidade.
Exemplo: i++; contador++;
+ - Operadores aritméticos
* / % Multiplicação, divisão, resto
<< >>
>>>
Operadores de deslocamento aritmético e lógico
== != Igualdade e desigualdade
^ Potência
&& AND
|| OR
?: Operador condicional.
Exemplo: i=0; (i>2?i=0:i --);
= *= %=
+= -=
<<= >>=
>>>= &=
^= |=
Operadores aplicados sobre a atribuição.
instance
of
Identificador de classes
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 29
5.2 Concatenação de Strings com o operador +
Quando o operador + é aplicado a dados do tipo String, ele cria um novo dado do tipo String,
concatenando os dois operandos.
/**
* Concatenação de Strings
*/
String sigla = "JOO";
String nome = "Java Orientado a Objetos";
String titulo = sigla + " - " + nome;
// Esse comando imprimirá na tela a frase:
// JOO – Java Orientado a Objetos
System.out.println(titulo);
int i = 10;
String legenda = "valor = ";
// campo é uma variável do tipo String
String campo = legenda + i;
Alguns métodos úteis em dados do tipo String:
String curso = "Java Orientado a Objetos";
System.out.println("curso: " + curso);
// Isolando um caractere:
System.out.print("primeiro caractere: ");
System.out.println(curso.charAt(0));
System.out.print("segundo caractere: ");
System.out.println(curso.charAt(1));
// O primeiro caractere de uma String tem o
// índice 0, o segundo o índice 1 e assim por diante
// letra = 's';
char letra = curso.charAt(2);
// substrings:
System.out.print("primeiras cinco letras: ");
System.out.println(curso.substring(0, 5));
System.out.print("letras a partir da quarta: ");
System.out.println(curso.substring(4));
// número de caracteres em uma String:
System.out.print("tamanho da frase: ");
System.out.println(curso.length() + " letras");
// usando os caracteres de tabulação e quebra
// de linha:
System.out.println(""
+ curso.length()
+ " letras"
+ " \n"
+ " Nova linha\ttabulação" );
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 30
5.3 Promoção e Casting
A linguagem Java não suporta atribuições arbitrárias entre variáveis de tipos diferentes. Por
exemplo, você não pode inicializar uma variável inteira com um valor de ponto flutuante sem explicitar
isso através de um processo que chamamos de casting.
Quando atribuímos um valor a uma variável, e esse valor é incompatível com o tipo de dado
definido para a variável, ocorrerá uma conversão. Em alguns casos, essa conversão será automática, em
outros o programador deve indicar de que forma o valor será convertido ao tipo de dado da variável.
Quando o processo de conversão for automático, dizemos que ocorreu uma promoção, ou seja,
um valor com um tipo de dado foi promovido a outro tipo de dado. Veja no exemplo abaixo:
//
// Promoção entre valores de tipos de dados distintos
// Apesar 6 ser um inteiro, o valor da variável grande
// continua sendo do tipo long
long grande = 6;
// Uma variável do tipo inteiro não possui
// espaço para armazenar um valor longo.
// A instrução abaixo é ilegal, e causará um erro de compilação.
int pequeno = 99L;
float a = 12.121F; // correto
float b = 12.121; // 12.121 é um double - incorreto
Como visto acima, algumas conversões não podem ser realizadas de forma automática, pois o
compilador não pode assumir que tipo de conversão ele deve realizar (o tamanho do tipo de dado a ser
recebido por uma variável é maior que o tamanho pré-definido para o tipo dessa variável, logo o
compilador não sabe como "ajustar" os bits excedentes). Nesse caso, o programador deve indicar ao
compilador que tipo de conversão deverá ocorrer, digitando o tipo de dado que o valor deverá assumir
entre parênteses:
//
// Casting entre valores de tipos de dados distintos
//
// Apesar 6 ser um inteiro, o valor da variável grande
// continua sendo do tipo long
long grande = 6;
int pequeno = (int)99L; // sem problemas
float a = 12.121F;
float b = (float)a; // sem problemas
Abaixo estão relacionados todos os casts possíveis na linguagem Java, mostrando quando
você quer converter de um valor para outro. A indicação Impl. quer dizer que aquele cast é implícito e
automático, ou seja, você não precisa indicar o cast explicitamente. (lembrando que o tipo boolean não
pode ser convertido para nenhum outro tipo).
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 31
5.4 Operadores de deslocamento (>>, <<, >>>)
Java provê operadores para a manipulação dos bits em variáveis de tipo numérico: o
deslocamento aritmético >> e o deslocamento lógico >>>.
O operador de deslocamento aritmético >> executa um deslocamento de um bit para a direita de
um número (na prática, o primeiro argumento desse operador é dividido por dois 'n' vezes – onde n é o
segundo argumento do operador):
8 >> 2 = 2
128 >> 1 = 64
256 >> 4 = 16
* Notação em complemento de dois: o operador >> mantém o sinal do bit mais significativo duranteo
deslocamento.
O operador de deslocamento lógico >>> executa um deslocamento no padrão dos bits ao invés do
significado aritmético de um valor numérico. Esse operador sempre adiciona o valor 0 ao bit mais
significativo:
1010 ... >> 2 = 111010 ...
1010 ... >>> 2 = 001010 ...
* Os operadores de deslocamento reduzem seus operandos à direita módulo 32 para um valor do tipo int
e módulo 64 para um tipo long. Dessa forma, para qualquer valor do tipo int:
int x x >>> 32 = x
O operador de deslocamento lógico >>> só pode ser aplicado a valores inteiros, e não é efetivo em
valores int e long. Se for aplicado a valor short ou byte, o valor será promovido a um int antes da
aplicação do operador. Por isso, um deslocamento sem sinal acaba se tornando um deslocamento com
sinal
5.5 Circuitos lógicos
Java possui três operadores básicos para implementar circuitos lógicos:
NOT: operador !
Pág.
5 EXPRESSÕES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 32
AND: operador &&
OR: operador ||
Esses operadores permitem a representação de expressões booleanas, que formam o argumento
para comandos de decisão (IF), seguindo a seguinte tabela:
AND: OR:
true && true = true; true || true = true;
true && false = false; true || false = true;
false && true = false; false || true = true;
false && false = false; false || false = false;
!true = false;
!false = true;
!(a && b) = !a || !b
!(a || b) = !a && !b
5.6 Exercícios
a) Implemente um programa para calcular a área de um trapézio, onde:
h = altura
b = base menor
B = base maior
Área = (h . (b + B)) / 2
b) Faça o programa acima calcular utilizando valores de ponto flutuante e depois imprima na tela duas
informações:
Valor exato da área:
Valor arredondado para inteiro:
c) Calcule o valor das seguintes equações:
a. 3 – 2 – 1 + 2 + 1 + 3
b. 2 * 3 – 4 * 5
c. 2 + 6 – 3 / 7 * 9
d. 3 % 4 – 8
d) Indique qual o valor verdade das seguintes expressões:
a. (1 > 2) // exemplo: false
b. (8 == 8) // exemplo: true
c. ((12 – 5) > 6)
d. (0 < 3) && (8 < 9)
e. ((i++) > i)
f. ((10 * 90 / 50 – 2) == 16)
Pág.
6 FLUXO DE CONTROLE
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 33
6 FLUXO DE CONTROLE
Esta seção demonstra como implementar tomada de decisões em códigos Java.
6.1 Ramificação if, else
A sintaxe básica para declarações if, else é a seguinte:
if (expressão_booleana)
{
// bloco de comandos
}
else
{
// bloco alternativo de comandos
}
Exemplo:
/**
* Usando if, else */
int maior = 10;
int menor = 5;
if (maior > menor)
{
// (10 > 5) = true
System.out.println(maior + ">" + menor);
}
else
{
// (10 > 5) != true
System.out.println(menor + ">" + maior);
}
// Lembre-se que o controle de fluxo é feito através
// do valor verdade de uma expressão booleana
boolean verdade = (10 > 5);
if (verdade)
{
// (10 > 5) = true
System.out.println(maior + ">" + menor);
}
Pág.
6 FLUXO DE CONTROLE
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 34
else
{
// (10 > 5) != true
System.out.println(menor + ">" + maior);
}
6.2 Ramificação switch
Switch é uma declaração semelhante ao if, mas que usa valores inteiros para a tomada de decisões ao invés
de expressões booleanas. (só pode ser usada em dados dos tipos short, int, byte ou char). Se o tipo de dado não
for inteiro, o comando switch irá executar uma promoção desse valor ao tipo int para somente depois
executar a ramificação.
A sintaxe básica para declarações switch é a seguinte:
Switch ((int)expressão)
{
// bloco de comandos
case ((int) valor_1):
// bloco de comandos break;
case ((int) valor_2):
// bloco de comandos break;
default :
// bloco de comandos padrão.
// Se nenhum dos valores acima corresponder à
// expressão definida no comando switch, então
// o programa executará o trecho default.
// o trecho default é opcional.
break;
}
Exemplo:
/**
* Usando switch
*/
// Considere valorDoTeclado() como um número
// inteiro digitado pelo usuário
int valor = valorDoTeclado();
switch (valor)
{
case 0:
Pág.
6 FLUXO DE CONTROLE
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 35
System.out.println("cadastro de produto");
break;
case 1:
System.out.println("emitir nota fiscal");
break;
case 2:
System.out.println("cancelar compra");
break;
default:
System.out.println("efetuar venda");
break;
}
6.3 Repetição for
A declaração for é utilizada para definir que um bloco de comandos deve ser executado 'n' vezes, onde 'n' é
um número inteiro. A sintaxe do comando for é a seguinte:
for (int i = 0; i < 10; i++)
{
// bloco de comandos
}
Exemplo:
/**
* repetição de comandos usando FOR
*/
// Calculando o fatorial de um número:
int numero = 10;
int fatorial = 1;
for (int i = numero; i > 0; i--)
{
fatorial = fatorial * i;
}
System.out.println("fatorial de " + numero + " = " + fatorial);
// Imprimindo os dias do ano:
for (int mes = 1; mes < 12; mes++)
{
switch (mes)
{
case 1:
System.out.println("janeiro");
break;
case 2:
System.out.println("março");
break;
case 3:
System.out.println("abril");
break;
// escreva aqui os demais comandos
Pág.
6 FLUXO DE CONTROLE
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 36
}
}
6.4 Repetição while
A declaração while é utilizada para definir que um bloco de comandos e deve ser executado enquanto uma
expressão booleana (condição de parada) não seja verdade. A sintaxe do comando while é a seguinte:
While (expressão_booleana)
{
// bloco de comandos executados enquanto a
// expressão boolena tiver valor verdade = true
}
ou
do
{
// bloco de comandos executados pelo menos uma vez
} While (expressão_booleana);
Exemplo:
public static void main(String[] args) {
/**
* repetição de comandos usando FOR
*/
// Calculando o fatorial de um número:
int numero = 10;
int fatorial = 1;
int i = numero;
while (i > 0)
{
fatorial = fatorial * i;
i--;
}
System.out.println("O fatorial de " + numero + " = " + fatorial);
// Lendo a condição de parada do teclado:
numero = 0;
while (numero < 10)
{
System.out.println("Digite um número: ");
numero = valorDoTeclado();
}
Pág.
6 FLUXO DE CONTROLE
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 37
System.out.println("O usuário digitou um número maior que 10");
}
6.5 Comandos especiais de controle de fluxo: break, continue e label
Os comandos de repetição em Java suportam dois tipos de desvios: o break e o continue. O break faz com
que um laço seja interrompido, enquanto o continue é usado para "pular" uma execução e continuar a partir da
próxima.
Exemplo:
// pulando a execução No 10 e parando na No 15
for (int i=0; i<20; i++)
{
if(i== 10)
{
continue;
}
else if(i == 15)
{
break;
}
System.out.println("contador: " + i);
}
Além disso, esse desvio pode ser direcionado, ou seja, o programador pode indicar para qual linha do código
a execução do programa deve ser desviada (uma espécie de GOTO em Java). Essa prática é altamente
desaconselhada, e foi mantida no Java por motivos de compatibilidade com a linguagem C.
Um label em Java só pode ser usado para identificar um comando for, while ou do.
Exemplo:
desvio: for (int i=0; i<20; i++)
{
if(i == 10)
{
continue desvio;
}
else if(i == 15)
{
// Essa linha nunca será executada
// pois o laço sempre será reiniciado
// quando o valor de i for igual a 10
break desvio;
}
System.out.println("contador: " + i);
}
Pág.
6 FLUXO DE CONTROLE
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 38
6.6 Lendo valores do teclado
Nem sempre é necessário fazer entrada byte a byte. Nestes casos, normalmente, é mais simples utilizar a classe
Scanner do pacote java.util do Java. Essa classe possui métodos mais sofisticados para obter os dados de uma
entrada.
// Criando objeto de entrada de dados
InputStream entrada = System.in;
Scanner scanner = new Scanner (entrada) ;
// Realizando a leitura
String linha = scanner.nextLine () ;
// Imprimindo a informação lida
System.out.println(linha);
6.7 Exercícios
1. Escreva um programa que imprima na tela a soma dos números ímpares entre 0 e 20 e a multiplicação dos
números pares entre 0 e 20.
2. Faça um programa para ler um número do teclado e imprimir na tela se ele é par ou ímpar.
3. O valor pago por um Hotel da Praia de Iracema para seus porteiros é de R$ 10,25 por hora de trabalho. Faça um
programa que pergunte ao usuário quantas horas ele trabalhou e imprima na tela o valor do salário a ser recebido
por ele.
4. Modifique o programa anterior para que o sistema imprima uma mensagem de alerta quando o valor a ser pago
ao funcionário seja inferior a R$ 50,00: "Atenção, dirija-se à direção do Hotel!".
5. Sabendo que na LogusTI a média mínima é 7,0 e a tolerância de faltas é 15 % da carga horária do curso, faça
uma classe com o método main que peça as informações necessárias e informe a situação do usuário.
6. Implemente uma classe java “Calculos” com um método”calcularMedia” que receba três números e calcule a
média e imprima na tela essa média. O método “calcularMaior”, deverá receber também três números e retornar o
maior número e o método “calcularMenor”, deverá receber três números e retornar o melhor número. Implemente a
classe com o método main e instancie a classe Calculos executando todos os seus métodos.
7. Construa uma classe que peça o Nome, Endereço, Sexo, Cidade, Estado, Idade dos funcionários. Além disto,
dado o Salário Bruto do funcionário, calcule o seu Salário Líquido. Considere que os descontos podem ser o Vale
Transporte (2%), Vale Alimentação (5%) e Plano de Saúde (10%).
Pág.
7 AGRUPAMENTO DE DADOS (ARRAYS)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 39
7 AGRUPAMENTO DE DADOS (ARRAYS)
Nesta seção analisaremos o agrupamento de dados, uma estrutura simples mas essencial para a compreensão de
como Java manipula dados na memória.
7.1 Declarando e criando Arrays
Suponha que o sistema do banco tenha que gerar listas com os números das contas de uma agência.
Poderíamos declarar uma variável para cada número
int numero1;
int numero2;
int numero3;
Contudo, não seria uma abordagem prática, pois uma agência pode ter uma quantidade muito grande de
contas. Além disso, novas contas podem ser abertas todos os dias. Isso implicaria em alterações constantes no
código fonte.
Quando desejamos armazenar uma grande quantidade de valores de um determinado tipo, po-demos utilizar
arrays. Um array é um objeto que pode armazenar muitos valores de um determinado tipo.
Podemos imaginar um array como sendo um armário com um determinado número de gavetas. E cada
gaveta possui um rótulo com um número de identificação.
Arrays são tipos indexados de dados que permitem a representação de agrupamento de dados como vetores
e matrizes.
Pág.
7 AGRUPAMENTO DE DADOS (ARRAYS)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 40
Podemos declarar arrays de qualquer tipo de dado suportado em Java (primitivo ou agregado – tipos
agregados de dados serão discutidos posteriormente). Essa declaração é feita pela adição do símbolo [] a um tipo de
dado, que pode aparecer antes ou após o identificador da variável:
char[] arrayDeCaracteres;
String[] arrayDePalavras;
Ponto[] arrayDeObjetosDoTipoPonto;
int números[];
Na memória, um array é um agrupamento de dados, indexados pelo tamanho do tipo de dado que o array
suporta:
O primeiro índice de um array é sempre 0, e o último índice é o N-1, onde N é o número de elementos do
array.
IMPORTANTE
Apesar da posição do símbolo [] poder ser no início ou no final do nome da variável, é fortemente recomendado que
você sempre aplique o [] após o tipo da variável. Isso torna o código muito mais legível.
Para criar um array, usamos a palavra chave new:
int[] números = new int[50];
A quantidade de elementos de um array sempre deve ser um valor inteiro. O comprimento de um array é dado pelo
método length:
// Imprimindo o comprimento de um array
char [] alfabeto = new char[24];
int tamanhoDoAlfabeto = alfabeto.length;
System.out.println("alfabeto com " + tamanhoDoAlfabeto " letras");
IMPORTANTE
Um array de 10 elementos tem os índices de 0 a 9.
Pág.
7 AGRUPAMENTO DE DADOS (ARRAYS)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 41
7.2 Modificando o conteúdo de um array
Para modificar o conteúdo de um array, devemos escolher uma ou mais posições que devem ser alteradas e utilizar
a sintaxe abaixo:
int [] numeros = new int [100];
numeros [0] = 136;
numeros [99] = 17;
IMPORTANTE
Quando um array é criado com o comando new, todas as posições são inicializadas com os valores padrão
(números são inicializados com 0, booleanos com false e referências com null).
Também podemos definir os valores de cada posição de um array no momento da sua criação utilizando as
sintaxes abaixo:
int [] numeros1 = new int []{100 ,87};
int [] numeros2 = {100 ,87};
7.3 Acessando o conteúdo de um array
Para acessar o conteúdo de um array, devemos escolher uma ou mais posições e utilizar a sintaxe abaixo:
int [] numeros1 = new int []{100 ,87};
int [] numeros2 = {100 ,87};
System.out.println(numeros2[0]);
System.out.println(numeros1[1]);
IMPORTANTE
Acessar posições fora do intervalo de índices de um array gera erro de execução. Mais especificamente, em Java,
ocorrerá a exception ArrayIndexOutOfBoundsException.
Pág.
7 AGRUPAMENTO DE DADOS (ARRAYS)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 42
7.4 Percorrendo um Array
Quando trabalhamos com um array, uma das tarefas mais comuns é acessarmos todas ou algumas de suas
posições sistematicamente. Geralmente, fazemos isso para resgatar todos ou alguns dos valores armazenados e
realizar algum processamento sobre tais informações.Para percorrermos um array, utilizaremos a instrução de repetição for. Podemos utilizar a instrução while
também. Porém, logo perceberemos que a sintaxe da instrução for, em geral, é mais apropriada quando estamos
trabalhando com arrays.
int [] numeros = new int [100];
for ( int i = 0; i < 100; i ++) {
numeros [ i ] = i ;
}
Para percorrer um array, é necessário saber a quantidade de posições do mesmo. Essa quantidade é
definida quando o array é criado através do comando new. Nem sempre essa informação está explícita no código.
Por exemplo, considere um método que imprima na saída padrão os valores armazenados em um array.
Provavelmente, esse método receberá como parâmetro um array e a quantidade de posições desse array não estará
explícita no código fonte.
public void imprimirArray(int[] numeros) {
// Implementação do Array
}
Podemos imprimir todos os elementos do array utilizando o for e atributo length.
public void imprimirArray(int[] numeros) {
for (int i = 0; i < numeros.length; i++) {
// Imprimindo cada elemento do array
System.out.println(numeros[i]);
}
}
Para acessar todos os elementos de um array, é possível aplicar o comando for com uma sintaxe um pouco
diferente, utilizando o laço foreach.
public static void imprimirArray2(int[] numeros){
for(int numero:numeros) {
System.out.println(numero);
}
Pág.
7 AGRUPAMENTO DE DADOS (ARRAYS)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 43
}
7.5 Operações com Arrays
Nas bibliotecas da plataforma Java, existem métodos que realizam algumas tarefas úteis relacionadas a arrays.
Veremos esses métodos a seguir.
7.5.1 Ordenando um Array
Considere um array de String criado para armazenar nomes de pessoas. Podemos ordenar esses nomes através
do método Arrays.sort().
String [] nomes = new String []{ "João Paulo" , "Gabriel Jesus" , "André Santos", "Paulo
Henrique" };
Arrays.sort(nomes);
for (String nome:nomes) {
System.out.println (nome);
}
Analogamente, também podemos ordenar números.
7.5.2 Duplicando um Array
Para copiar o conteúdo de um array para outro com maior capacidade, podemos utilizar o mé-todo
Arrays.copyOf().
String [] nomes = new String []{"Neymar" , "Gabriel Jesus" , "Gabigol" };
String [] nomesDuplicados = Arrays.copyOf(nomes,10);
7.5.3 Preenchendo um Array
Podemos preencher todas as posições de um array com um valor específico utilizando o método Arrays.fill().
int [] numeros2 = new int [10];
java . util . Arrays . fill ( numeros2 , 5) ;
Pág.
7 AGRUPAMENTO DE DADOS (ARRAYS)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 44
7.6 Arrays multidimensionais
Quando declaramos um array através do símbolo [], estamos de fato criando um array unidimensional (vetor).
Além de vetores, a linguagem Java permite a declaração de arrays n-dimensionais, conforme os exemplos abaixo:
// array unidimensional (VETOR)
String[] frases = new String[5];
// array bidimensional (MATRIZ)
String[][] tabela = new String[5][15];
// array n-dimensional
double [][][] densidade;
densidade = new double[10][10][10];
// observe que nem todos os valores de um array
// precisam estar preenchidos. Sempre que você for
// usar o valor contido em uma posição de um array
// você deve ter certeza que essa posição
// foi inicializada
densidade[0][0][0] = 35.034;
densidade[1][0][0] = 30.876;
System.out.println("densidade na coordenada 1,0,0 = "
+ densidade[1][0][0]);
7.7 Array esparso
Java permite a declaração de estruturas esparsas, ou seja, um agrupamento indexado de dados onde nem
todas as dimensões são iguais:
// Matrizes esparsas podem ser representadas em Java
// através de arrays com dimensões heterogêneas:
int[][] esparso = new int[4][];
esparso[0] = new int[10];
esparso[1] = new int[2];
esparso[2] = new int[5];
esparso[3] = new int[1];
// Na memória, o espaço de dados ocupado pelo
// array acima seria aproximadametne assim:
// [ | | | | | | | | | ]
// [ | ]
// [ | | | | ]
// [ ]
Pág.
7 AGRUPAMENTO DE DADOS (ARRAYS)
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 45
7.8 Exercícios
1) Crie um programa que imprima na tela os argumentos passados na linha de comando para o método main.
Compile e execute a classe ImprimeArgumentos. Na execução, não esqueça de passar alguns parâmetros na linha
de comando.
2) Faça um programa que ordene o array de strings recebido na linha de comando.Compile e execute a classe
Ordena. Na execução, não esqueça de passar alguns parâmetros na linha de comando.
3) Faça um programa que calcule a média dos elementos recebidos na linha de comando. Dica: para converter
strings para double utilize o método parseDouble()
4) Faça um programa que leia cinco nomes do teclado, e depois imprima esses nomes na ordem inversa em
que foram digitados pelo usuário.
5) O tempo que um determinado avião dispensa para percorrer o trecho entre duas localidades distintas está
disponível através da seguinte tabela:
A B C D E F G
02 11 06 15 11 01
02 07 12 04 02 15
11 07 11 08 03 13
06 12 11 10 02 01
15 04 08 10 05 13
11 02 03 02 05 14
01 15 13 01 13 14
a) Construa uma classe java que leia a tabela anterior e informe ao usuário o tempo necessário para percorrer duas
cidades por ele fornecidas, até o momento em que ele fornecer duas cidades iguais (origem e destino).
b) Elabore uma classe que imprima a tabela sem repetições(apenas o triângulo superior ou o triângulo inferior).
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 46
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
8.1 Fundamentos da Programação Orientada a Objetos
A Orientação a Objetos é uma tecnologia que enxerga os sistemas como sendo coleção de objetos
integrantes. Ela permite melhorar a reusabilidade e extensibilidade dos softwares.
A tecnologia orientada a objetos é fundamentada no que, coletivamente, chamamos de modelo de objetos,
que engloba os princípios da abstração, hierarquização, encapsulamento, classificação, modularização,
relacionamento, simultaneidade e persistência
8.2. Paradigma Orientado por Objetos
A proposta da orientação a Objetos é representar o mais fielmente possível as situações do mundo real nos
sistemas computacionais. Nós entendemos o mundo como um todo composto por vários objetos que interagem uns
com os outros. Da mesma maneira, a Orientação a Objetos consiste em considerar os sistemas computacionais não
como uma coleção estruturada de processos, mas sim como uma coleção de objetos que interagem entre si.
Os programas Orientados a objetos são programas estruturados em módulos que agrupam um estado e
operações sobre este estado. Apresentam ênfase em reutilização de código.
Um dos grandes diferenciais da programação orientada a objetos em relação a outros paradigmas de
programação que também permitem a definição de estruturas e operações sobre essas estruturas está no conceito
de herança, mecanismo através do qual definições existentes podem ser facilmente estendidas. Juntamente com a
herança deve ser enfatizada aimportância do polimorfismo, que permite selecionar funcionalidades que um
programa irá utilizar de forma dinâmica, durante sua execução.
“Orientação a Objetos consiste em considerar os sistemas computacionais como uma
coleção de objetos que interagem de maneira organizada. ”
8.3 Principais conceitos de POO
8.3.1 Objetos
Usamos o termo objeto para representar um determinado elemento do mundo real. Mas somente
analisaremos os objetos que tem relevância para a solução de um determinado problema. Portanto, o objeto é uma
entidade do mundo real que merece representação para o ambiente estudado.
Objetos são instâncias de classes, que determinam qual informação um objeto contém e como ele pode
manipulá-la. É uma entidade capaz de reter um estado (informação) e que oferece uma série de operações
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 47
(comportamento) ou para examinar ou para afetar este estado. É através deles que praticamente todo o
processamento ocorre em sistemas implementados com linguagens de programação orientadas a objetos.
Como exemplos de objetos, podemos citar os objetos físicos (um livro, uma mercadoria), funções de pessoas para os
sistemas (cliente, vendedor), eventos (uma compra, um telefonema), interações entre outros objetos (um item de
uma nota fiscal é uma interação entre uma compra e um produto do estoque) e lugares (loja matriz, revenda norte).
Por exemplo, vamos considerar um cachorro(Bob) como nosso “objeto” para facilitar o entendimento acerca
do conceito de OO:
Analisando este objeto, o cachorro, podemos deduzir que o mesmo possui algumas características que
pertencem apenas a ele próprio. Por exemplo, um cachorro possui:
Um nome,
Uma idade,
Um comprimento de pêlos,
Uma cor dos pelos,
Uma cor dos olhos,
Um peso,
....
“As características que descrevem um objeto são chamadas de atributos”.
Além do conjunto de características que descrevem o cachorro, podemos também identificar um conjunto de ações
que ele é capaz de executar:
Latir,
Babar,
Correr em círculos,
Pegar a bola,
Sentar,
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 48
Comer,
Dormir.
“As ações que um objeto pode executar são chamadas de métodos ou serviços”.
A única maneira de interagir com os objetos é através dos métodos que ele disponibiliza. Para interagir com
o cachorro, utilizamos os métodos que relacionamos acima: para alimentá-lo, utilizamos o método “comer”, para
brincar com ele, utilizamos o método “pegar a bola”, etc.
“Chamamos de interface ao conjunto de métodos disponíveis em um objeto.”
8.3.2 Atributos e métodos
Vimos então que os objetos são compostos de atributos e métodos, mas afinal, o que são atributos e o que são
métodos?
8.3.2.1 Atributos
Os objetos do mundo real possuem propriedades que possuem valores. Estes valores definem o estado do
objeto. As propriedades recebem o nome de atributos em OO.
Podemos dizer que os atributos dos objetos são “variáveis” ou “campos” que armazenam os diferentes
valores que as características dos objetos podem conter.
O estado de um objeto é o conjunto de valores de seus atributos em um determinado instante. O
comportamento de um objeto é como ele age e reage em termos de suas mudanças de estado e troca de
mensagens com outros objetos.
O cachorro(Bob) do nosso exemplo poderia ser representado pelos seguintes atributos:
CACHORRO
Nome Bob
Idade 10 meses
Cor dos pelos Bege
Peso 4 kg
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 49
Um outro objeto “cachorro” apresentaria valores diferentes para os mesmos atributos, por exemplo:
CACHORRO
Nome Lulu
Idade 2 anos
Cor dos pelos Laranja
Peso 3 kg
Os atributos de um objeto somente mudam de valor através de estímulos externos ou internos. A única forma
de modificar os atributos dos objetos é disparando eventos que provocam a transição desses estados no objeto.
8.3.2.2 Métodos
Os métodos são procedimentos ou funções que realizam as ações próprias do objeto. Assim, os métodos
são as ações que o objeto pode realizar. Tudo que o objeto faz é realizado através de seus métodos, pois é através
dos seus métodos que um objeto se manifesta, e através deles que o objeto interage com os outros objetos.
Um objeto exibe algum comportamento (executa uma operação) quando recebe um estímulo de outro objeto.
Um objeto requisita a ação de algum outro objeto, enviando uma mensagem para ele. Esta mensagem é uma
solicitação a um objeto para que seja executada as rotinas que chamamos de Método da classe.
Os métodos são responsáveis por acessar ou alterar os atributos de um objeto. Imaginando os métodos do
nosso objeto de estudo, o cachorro, enumeramos métodos (ações) como latir, babar, comer sentar, etc.
8.3.3 Classes
Uma classe representa um conjunto de objetos que possuem características e comportamentos comuns e de
agora em diante, diremos que um objeto é uma instância de uma determinada classe, ou seja, criaremos nossos
objetos baseados nas características definidas nas classes. A ênfase da metodologia orientada a objetos é dada na
criação das classes, e não dos objetos, como se poderia pensar pelo nome. Olhando os dois cães do exemplo
anterior, vemos que os dois possuem exatamente o mesmo conjunto de atributos. Isso acontece porque se trata de
dois objetos da mesma classe, ou categoria. Isso significa que os dois possuem exatamente o mesmo conjunto de
atributos e métodos, embora cada objeto possa ter valores diferentes para os seus atributos.
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 50
Classe Cachorro
Objetos de mesma classe possuem a mesma definição tanto para métodos quanto para atributos.
Tomemos uma classe gatos formada de objetos “gato”. Estes objetos possuem as seguintes características:
nome, idade, peso, cor de pelos, cor de olhos e comprimento de pelos. Além disso, o objeto possui as seguintes
ações: miar, comer, dormir, subir na árvore.
Classe Gato
Muitos objetos do mundo real possuem características comuns e podem ser agrupados de acordo com elas.
Uma classe representa um gabarito para muitos objetos e descreve como estes objetos estão estruturados
internamente.
As classes Cães e Gatos possuem características e métodos comuns, por exemplo: Características comuns
(nome, idade, peso, cor de pelos, cor de olhos e comprimento de pelos), Métodos comuns (pegar a bola, comer,
dormir).
8.3.3 Instanciação
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 51
A instanciação é quando a classe produz um objeto, como se ela fosse uma espécie de modelo ou gabarito
para a criação de objetos. Conforme a teoria da orientação a objetos, dizemos que um objeto é, nada mais nada
menos, que a instância de uma classe.
Pelo exemplo que estamos estudando, cada cachorro que for armazenado é um novo objeto, uma nova
instância da classe “Cachorro”. A classe serve de modelo para a criação de novos objetos.8.4 - Exercício - Conceitos OO
Para atender as necessidades de informação de uma biblioteca universitária foi proposto um sistema que deve
atender as seguintes características:
O cadastro dos usuários da biblioteca com endereço completo. Os usuários podem ser classificados em três
grupos: Professores, Alunos e Funcionários. Para os Alunos é necessário conhecer o curso ao qual
pertencem. Dos Professores e funcionários, é necessário conhecer o Departamento ao qual estão sempre
vinculados.
O cadastro das obras da biblioteca, que podem ser classificadas em: Livros científicos, periódicos científicos,
periódicos informativos, periódicos diversos, entretenimento, etc.
A língua em que se encontra o exemplar da obra.
A mídia onde se encontra o exemplar da obra.
Os autores da obra com o controle da nacionalidade do autor.
As editoras dos exemplares com o ano de edição de cada exemplar.
O histórico dos empréstimos.
Identifique as possíveis classes e objetos com seus respectivos atributos e métodos.
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 52
8.5 – Classes e Objetos em Java
O conceito de classe apresentado anteriormente é genérico e pode ser aplicado em diversas linguagens de
programação. Mostraremos como a classe Conta poderia ser escrita utilizando a linguagem Java. Inicialmente,
discutiremos apenas sobre os atributos. Os métodos serão abordados posteriormente.
class Conta {
double saldo;
double limite;
int numero;
}
A classe Java Conta é declarada utilizando a palavra reservada class. No corpo dessa classe, são
declaradas três variáveis que são os atributos que os objetos possuirão. Como a linguagem Java é estaticamente
tipada, os tipos dos atributos são definidos no código. Os atributos saldo e limite são do tipo double, que permite
armazenar números com casas decimais, e o atributo número é do tipo int, que permite armazenar números inteiros.
Importante
Por convenção, os nomes das classes na linguagem C# devem seguir o padrão “Camel Case” com a primeira letra
maiúscula.
8.5.1 Criando objetos em Java
Após definir a classe Conta, podemos criar objetos a partir dela. Esses objetos devem ser alocados na
memória RAM do computador. Felizmente, todo o processo de alocação do objeto na memória é gerenciado pela
máquina virtual. O gerenciamento da memória é um dos recursos mais importantes oferecidos pela máquina virtual.
Do ponto de vista da aplicação, basta utilizar um comando especial para criar objetos e a máquina virtual se
encarrega do resto. O comando para criar objetos é o new.
class TestaConta {
public static void main (String [] args ) {
// criando um objeto
new Conta () ;
}
}
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 53
A linha com o comando new poderia ser repetida cada vez que desejássemos criar (instanciar) um objeto da
classe Conta. A classe TestaConta serve apenas para colocarmos o método main, que é o ponto de partida da
aplicação.
class TestaConta {
public static void main (String [] args ) {
// criando três objetos
new Conta () ;
new Conta () ;
new Conta () ;
}
}
Analogia
Chamar o comando new passando uma classe Java é como se estivéssemos contratando uma construtora passando a
planta da casa que queremos construir. A construtora se encarrega de construir a casa para nós de acordo com a planta.
Assim como a máquina virtual se encarrega de construir o objeto na memória do computador.
8.5.2 Referências
Todo objeto possui uma referência. A referência de um objeto é a única maneira de acessar os seus atributos e
métodos. Dessa forma, devemos guardar as referências dos objetos que desejamos utilizar.
Referências em Java
Ao utilizar o comando new, um objeto é alocado em algum lugar da memória. Para que possamos acessar esse
objeto, precisamos de sua referência. O comando new devolve a referência do objeto que foi criado.
Para guardar as referências devolvidas pelo comando new, devemos utilizar variáveis não primitivas.
Conta referencia = new Conta () ;
No código Java acima, a variável referencia receberá a referência do objeto criado pelo comando new. Essa
variável é do tipo Conta. Isso significa que ela só pode armazenar referências de objetos do tipo Conta.
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 54
8.5.3 Manipulando Atributos
Podemos alterar ou acessar os valores guardados nos atributos de um objeto se tivermos a referência a esse
objeto. Os atributos são acessados pelo nome. No caso específico da linguagem Java, a sintaxe para acessar um
atributo utiliza o operador ".".
public class TesteOO {
public static void main (String [] args ) {
Conta referencia = new Conta () ;
referencia.saldo = 5000;
referencia.limite = 10000;
referencia.numero = 1;
System.out.println ( referencia . saldo ) ;
System.out.println ( referencia . limite ) ;
System.out.println ( referencia . numero ) ;
}
}
No código acima, o atributo saldo recebe o valor 5000. O atributo limite recebe o valor 10000 e o número recebe
o valor 1. Depois, os valores são impressos na tela através do comando System.out.println.
8.5.4 Valores Padrão
Poderíamos instanciar uma classe para criar um objeto e utilizar seus atributos sem inicializá-los explicitamente,
pois os atributos são inicializados com valores padrão. Os atributos de tipos numéricos são inicializados com 0, os
atributos do tipo boolean são inicializados com false e os demais atributos com null (referência vazia).
class Conta {
double limite ;
}
class TestaConta {
public static void main ( String [] args ) {
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 55
Conta conta = new Conta () ;
// imprime 0
System . out . println ( conta . limite ) ;
}
}
A inicialização dos atributos com os valores padrão ocorre na instanciação, ou seja, quando o comando new é
utilizado. Dessa forma, todo objeto “nasce” com os valores padrão. Em alguns casos, é necessário trocar esses
valores. Para trocar o valor padrão de um atributo, devemos inicializá-lo na declaração. Por exemplo, suponha que o
limite padrão das contas de um banco seja R$ 2500. Nesse caso, seria interessante definir esse valor como padrão
para o atributo limite.
class Conta {
double limite = 2500;
}
class TestaConta {
public static void main ( String [] args ) {
Conta conta = new Conta () ;
// imprime 2500
System . out . println ( conta . limite ) ;
}
}
Pág.
8 ORIENTAÇÃO A OBJETOS(OO) BÁSICA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 56
8.6 Exercícios Complementares
a) Implemente uma classe chamada Aluno para definir os objetos que representarão os alunos de uma escola.
Essa classe deve declarar três atributos: o primeiro para o nome, o segundo para o RG e o terceiro para o CPF dos
alunos.b) Faça uma classe chamada TestaAluno e crie dois objetos da classe Aluno atribuindo valores a eles. A classe
também deve mostrar na tela as informações desses objetos.
c) Em uma escola, além dos alunos temos os funcionários, que também precisam ser representados em nossa
aplicação. Então implemente outra classe chamada Funcionario que contenha dois atributos: o primeiro para o cargo
e o segundo para o salário dos funcionários.
d) Faça uma classe chamada TestaFuncionario e crie dois objetos da classe Funcionario atribuindo valores a
eles. Mostre na tela as informações desses objetos.
e) Em uma escola, os alunos precisam ser divididos por turmas, que devem ser representadas den-tro da
aplicação. Implemente uma classe chamada Turma que contenha quatro atributos: o primeiro para o período, o
segundo para definir a série, o terceiro para sigla e o quarto para o tipo de ensino.
f) Faça uma classe chamada TestaTurma para criar dois objetos da classe Turma. Adicione informações a eles
e depois mostre essas informações na tela.
Pág.
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 57
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
9.1 Objetos e Construtor
Objetos e Construtor
Objetos são criados através da declaração new, seguida de um método construtor. Exemplo:
Automovel gol1 = new Automovel(“Gol V”);
Uma classe pode ter construtores especializados ou somente o construtor default (gerado pelo compilador).
Um construtor recebe sempre o mesmo nome da sua classe.
O método construtor gera uma instância do objeto em memória e o seu código é executado imediatamente após a
criação do objeto provendo-lhe um estado inicial. Quando declaramos variáveis de qualquer tipo primitivo (boolean,
byte, short, char, int, long, float, ou double) o espaço em memória (na área de dados) é alocado como parte da
operação. A declaração de uma variável referência a um objeto não aloca espaço em memória.
A alocação de memória (no heap) é feita somente quando o objeto é criado.
Considere o exemplo abaixo:
Automovel gol;
gol = new Automovel();
• O primeiro comando, a declaração, aloca apenas o espaço suficiente para a referência. O segundo, aloca o
espaço para os atributos do objeto gol.
• Somente após a criação do objeto é que seus membros (atributos e métodos) podem ser referenciados.
9.2 Herança
Herança significa ser capaz incorporar os dados e métodos de uma classe previamente definida. Assim como
a herança de todas as operações e dados, você pode especializar métodos da classe ancestral e especificar novos
operações e dados, para refinar, especializar, substituir ou estender a funcionalidade da classe progenitora.
Você pode fazer sempre com que um objeto mais geral armazene um objeto mais especializado, mas
o contrário não é verdadeiro sem uma conversão explícita de tipos.
Pág.
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 58
Veja o exemplo abaixo:
Herança - terminologia
• estender = criar uma nova classe que herda todo o conteúdo da classe existente.
• superclasse = uma classe progenitora ou “base”.
• subclasse = uma classe filha que herda, ou estende, uma superclasse.
Em Java, a classe “Object” é raiz de todas as classes:
Pág.
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 59
this é uma palavra-chave usada num método como referência para o objeto corrente.
• ela tem o significado de: “o objeto para o qual este trecho de código está sendo executado”.
//Classe ponto
public class Ponto
{
private float x,y;
public Ponto(float x,float y)
{
this.x=x; this.y=y;
}
public void move(float dx,float dy)
{
this.x+=dx; this.y+=dy;
}
public float retorna_x()
{
return x;
}
public void mostra()
{
System.out.println( "(" + this.x + "," + this.y + ")" );
}
}
super é uma palavra chave usada numa subclasse como referência para membros da superclasse.
• ela tem o significado de: “a superclasse da classe corrente”.
9.3 Polimorfismo
Existem dois tipos de polimorfismo que são conhecidos como sobrecarga (overload) e sobreposição
(override).
Ocorre quando uma classe possui um método com o mesmo nome e assinatura (número, tipo e ordem de
parâmetros) de um método na sua superclasse. Toda vez que isto ocorrer, a máquina virtual irá executar o método
da classe mais especializada (a subclasse) e não o método da superclasse. Note que esta decisão ocorre em tempo
de execução.
Pág.
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 60
Polimorfismo ocorre também quando existem dois métodos com mesmo nome, na mesma classe com e
assinaturas diferentes. O método será escolhido de acordo com o número de parâmetros, tipo ou valor de retorno
esperado. Note que esta decisão ocorre em tempo de compilação.
Membros com mesmos identificadores substituem membros herdados.
• Os membros definidos na superclasse podem ser acessados na subclasse através do qualificador super.
• Métodos declarados como final não podem ser redefinidos.
• Métodos abstratos devem ser redefinidos ou declarados como abstratos.
9.3.1 Polimorfismo - Sobreescrita
A sobrescrita (ou override) está diretamente relacionada à orientação a objetos, mais especificamente com a
herança. Com a sobrescrita, conseguimos especializar os métodos herdados das superclasses, alterando o seu
comportamento nas subclasses por um mais específico.
A sobrescrita de métodos consiste basicamente em criar um novo método na classe filha contendo a mesma
assinatura e mesmo tipo de retorno do método sobrescrito.
Substituir a implementação de um método herdado por uma implementação própria da subclasse.
public class Super
{
...
public void metodo1()
{
a = b * c;
}
}
public class Sub extends Super
{
...
public void metodo1()
{
x = y + z;
}
}
Pág.
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 61
9.3.2 Polimorfismo – Sobrecarga
A sobrecarga (overload) consiste em permitir, dentro da mesma classe, mais de um método com o mesmo
nome. A sobrecarga de métodos (overload) é um conceito do polimorfismo que consiste basicamente em criar
variações de um mesmo método, ou seja, a criação de dois ou mais métodos com nomes totalmente iguais em uma
classe. A Sobrecarga permite que utilizemos o mesmo nome em mais de um método contanto que suas listas de
argumentos sejam diferentes para que seja feita a separação dos mesmos.
public class Fruta
{
int gramas;
int calorias_por_grama;
public Fruta()
{
gramas=55;
calorias_por_grama=0;
}
public Fruta(int g, int c)
{
this.gramas =g;
this.calorias_por_grama =c;
}
}
public class Feira
{
public static void main(String args[])
{
Fruta melancia = new Fruta(4000, 5);
Fruta manga = new Fruta ();
manga.gramas=100;
manga.calorias_por_grama=100;
System.out.println(“manga “+ manga.gramas + “ gs “ + manga.calorias_por_grama);
}
}
Pág.
9 OO - HERANÇA, POLIMORFISMOE INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 62
9.4 Exercício - Polimorfismo
1) Crie duas classes que definam os seguintes atributos e métodos para objetos do tipo:
Ao final crie um objeto da classe Empregado e um objeto da classe Gerente, atribuindo valores para seus
salários e comissão para o gerente. Ao final execute os métodos getSalario() de ambos objetos. Lembrar que o
salário do gerente é composto do salário + comissão.
Pág.
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 63
9.5 Interfaces
Interface pode ser considerada como a forma com que um objeto se apresenta para outros, no que diz
respeito aos seus atributos e métodos (sua funcionalidade).
* É a representação externa de um objeto.
* Na nossa vida, estamos acostumados a lidar com objetos através de sua interface, ignorando sua
complexidade.
• Criadas com a palavra reservada interface.
• São sempre públicas.
• Implementadas pelas classes com a palavra reservada implements.
Exemplo Interface
public interface ControleRemoto
{
public void ligaTV();
public void desligaTV();
public void mudaCanalTV(int canalNovo);
Pág.
9 OO - HERANÇA, POLIMORFISMO E INTERFACES
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 64
}
public class TV implements ControleRemoto
{
public void ligaTV() {...}
public void desligaTV() {...}
public void mudaCanalTV(int canalNovo) {...}
}
Pág.
10 OO - CLASSES ABSTRATAS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 65
10 OO - CLASSES ABSTRATAS
Por vezes, no desenvolvimento de bibliotecas, pode ser útil criar e definir métodos para uma classe que
represente algum comportamento fundamental. Entretanto o comportamento não será implementado nessa classe.
Em vez disso, os métodos serão implementados nas subclasses.
Por exemplo, considere uma classe para representar uma venda. O valor de uma venda é subdividido entre
valor da mercadoria + valor do imposto. Nossa classe genérica não conhece todos os tipos de imposto, mas as
subclasses podem conhecer. Por exemplo uma classe que representa venda à vista sabe que o imposto para este
tipo de venda é 1% e outra classe que representa venda à prazo, sabe que o tipo de imposto para este tipo de venda
é de 2%. Então a superclasse Venda pode delegar às suas subclasses a tarefa de descobrir a taxa do seu imposto.
Regras para classes abstratas
Classes abstratas funcionam de forma muito semelhante às classes normais e praticamente tudo o que é
possível fazer com classes normais, também pode ser feito com classes abstratas.
- Elas são identificadas pela palavra chave abstract na definição da classe.
- Seus métodos abstratos também são identificados pela palavra chave abstract na definição da classe.
- Não é possível construir uma instância de uma classe abstract, a não ser indiretamente, construindo
uma instância de uma subclasse dela.
- As subclasses das classes abstratas devem fornecer implementações para todos os métodos abstratos
das respectivas classes pai. Caso contrário, elas também serão classes abstratas. Portanto qualquer
subclasse da classe Venda que não forneça uma implementação para retornar o taxa do imposto
também será abstrata.
- Métodos abstratos não podem ser privados nem estáticos.
public abstract class Venda(
...
public abstract double getTaxaImposto();
...
}
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 66
11 MODIFICADORES JAVA
11.1 Introdução
Os modificadores são utilizados para modificar os comportamentos das classes, métodos ou atributos. Os
modificadores Java são public, protected, private, static, abstract, final, native, synchronized, transient e
volatile.
Alguns modificadores podem ser classificados como pertencentes a um grupo chamado modificadores de
acesso, tais modificadores (public, protected, private) ditam como membros de uma classe são visíveis por outras
classes. Os outros modificadores não possuem uma organização clara e serão explicados um a um.
Para cada modificador será explicado o resultado de aplicá-lo sobre cada um dos seguintes elementos da
linguagem: variáveis, métodos, construtores e classes.
11.2 Modificadores de Acesso
Os modificadores de acesso são padrões de visibilidade de acessos às classes, atributos e métodos.
Esses modificadores são palavras-chaves reservadas pelo Java, ou seja, palavras reservadas não podem ser usadas
como nome de métodos, classes ou atributos.
Como boas práticas (best practices) do Java, na maioria das declarações de variáveis de instância são
definidos os seus atributos com a palavra-chave private, para garantir a segurança de alterações acidentais, sendo
somente acessíveis através dos métodos. Essa ação tem como efeito ajudar no encapsulamento dos dados,
preservando ainda mais a segurança e a aplicação de programação orientada a objetos do Java.
Por exemplo, quando um programa cria (instancia) um objeto da classe Banco, a variável senha é
encapsulada (ocultada) no objeto onde pode ser acessada apenas por métodos da classe do objeto, os
métodos getters e setters, que manipulam a variável de instância. Vejamos abaixo a explicação sobre cada um.
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 67
11.2.1 Private
O modificador de acesso private e o mais restritivo de todos, variáveis, métodos e construtores com esse
modificador são visíveis somente dentro da definição da própria classe, acessando-o diretamente ou através de uma
instância da mesma classe.
O modificador private pode ser usado em variáveis, métodos e construtores. Em classes, seu uso é restrito a
classes internas, ou seja, classes declaradas dentro de outras classes.
Da forma como nossa classe ContaCorrente foi construída, por mais que modifiquemos o atributo saldo
através do método sacar, é possível atribuir qualquer valor ao atributo saldo.
public class ContaCorrente {
int numero;
double saldo;
boolean sacar(float valor){
if (saldo>=valor) {
saldo = saldo - valor;
return true;
}
else return false;
}
}
public class Teste2 {
public static void main(String[] args) {
// Criando um objeto passando dois parâmetros(número e saldo inicial) em seu
método construtor.
ContaCorrente conta = new ContaCorrente(100,5500.00);
// Realizando o saque por meio do método sacar
conta.sacar(1000);
// Alterando diretamente o atributo saldo do objeto conta
conta.saldo = -100;
}
}
A melhor forma de resolver isso seria forçar quem usa a classe a chamar sempre o método sacar e não
permitir que seja atribuído um valor diretamente ao atributo saldo. Para fazer isso em Java, basta declarar que os
atributos não podem ser acessados fora da classe usando a palavra chave private.
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 68
Isso é importante,pois pode ser que um valor inválido seja atribuído ao valor do saldo. A melhor forma de
resolver isso seria forçar quem usa a classe ContaCorrente a chamar sempre o método sacar e não permitir que seja
atribuído um valor diretamente ao atributo saldo. Para fazer isso em Java, basta declarar que os atributos não podem
ser acessados fora da classe usando a palavra chave private. Assim, toda conversa de um objeto com outro é feita
através de troca de mensagem (acessando seus métodos). Veja exemplo abaixo.
public class ContaCorrente {
private int numero;
private double saldo;
// Método construtor da classe ContaCorrente
public ContaCorrente(int numero, double saldoInicial){
// Atribuindo os valores recebidos no método construtor para os atributos da
classe.
this.numero = numero;
this.saldo = saldo;
}
// Método para realizar o saque
public boolean sacar(float valor){
if (saldo>=valor) {
saldo = saldo - valor;
return true;
}
else return false;
}
}
public class Teste2 {
public static void main(String[] args) {
// Criando um objeto passando dois parâmetros(número e saldo inicial) em seu
método construtor.
ContaCorrente conta = new ContaCorrente(100,5500.00);
// Realizando o saque por meio do método sacar
conta.sacar(1000);
}
}
11.2.2 Protected
O modificador de acesso protected define que variáveis, métodos e construtores com esse modificador
podem somente ser acessados por classes no mesmo pacote ou subclasses da classe onde o elemento foi definido,
é importante notar que para os elementos serem acessados na subclasse não é preciso estar no mesmo pacote da
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 69
classe pai. O modificador protected pode ser aplicado somente em variáveis, métodos e construtores, o seu uso em
classes não é permitido.
11.2.3 Public
O mais abrangente de todos os tipos de acesso, o modificador public declara que elementos com esse
modificador são acessíveis de qualquer classe Java. Este modificador é aplicável a variáveis, métodos, construtores
e classes.
11.2.4 Default (padrão)
A classe e/ou seus membros são acessíveis somente por classes do mesmo pacote, na sua declaração não
é definido nenhum tipo de modificador, sendo este identificado pelo compilador.
public class ModificadorDefault {
public static void main(String[] args) {
String nome = "Roberto Carlos";
System.out.printf("Nome.: %s",nome);
}
}
A tabela a seguir apresenta um resumo dos modificadores de acesso.
Tabela dos modificadores de acesso
Escopo de acesso private default protected public
mesma classe sim sim sim sim
mesmo pacote não sim sim sim
pacotes diferentes (subclasses) não não sim sim
pacotes diferentes (sem subclasses) não não não sim
11.3 Outros Modificadores
11.3.1 Final
O modificador final pode ser aplicado a variáveis, métodos e classes. O comportamento descrito pelo
operador final varia de elemento para elemento, mas tem um conceito em comum, o conceito de imutabilidade, isto é,
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 70
elementos final não podem ser mudados. Você pode desejar declarar classes que implementam seus algoritmos
como classes final.
11.3.2Abstract
O modificador abstract pode ser aplicado somente a classes e métodos. Classes abstratas provem um
modo de adiar a implementação de métodos para subclasses. Uma classe abstrata não pode ser instanciada, ou
seja, não podemos chamar seus construtores.
11.3.3 Static
Este modificador pode ser aplicado a variáveis, métodos e a uma porção de código que não está dentro de
nenhum método, geralmente referenciado como bloco estático.
A ideia geral sobre o modificador static é que elementos com esse modificador estão associados com a
classe e não com instâncias dessa classe.
Uma variável estática é compartilhada por todas as instâncias de uma classe, ou seja, ao invés de cada
instância da classe ter uma cópia dessa variável ela é uma única variável compartilhada por todos as instâncias. Para
a existência de uma variável estática não é preciso nem mesmo a criação de uma instância da classe que contenha a
variável, é necessário somente que a classe seja carregada na Máquina Virtual Java, já que está é criada e
inicializada no momento de carga da classe.
Em relação a métodos as mesmas explicações são verdadeiras, ou seja, métodos podem ser chamados
mesmo sem nenhuma instância da classe ter sido construída. Um bom exemplo de métodos estáticos existe em toda
aplicação Java, o método main() é invocado sem a existência de nenhuma instância.
Métodos e variáveis podem ser referenciados além da forma padrão (através do nome do objeto) através do
nome da classe. Embora as duas formas sejam corretas e trabalham exatamente da mesma forma a primeira pode
tornar-se confusa quando referenciando métodos e variáveis estáticas, levando o programador a pensar que este
método ou variável é não estático. Por esse motivo e conveniente sempre referenciar variáveis estáticas através do
nome da classe para evitar confusões.
É importante dizer que métodos estáticos podem somente acessar variáveis também estáticas, ou seja, é
proibido o uso de variáveis não estáticas dentro de blocos estáticos, com exceção de variáveis criadas dentro do
próprio bloco é claro. Essa restrição se deve ao fato de que é possível fazer uma chamada a um método estático
mesmo sem haver nenhuma instância dessa classe, ou seja, a provável variável a ser referenciada dentro do método
pode nem mesmo ter sido criada ainda.
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 71
Outra importante característica é que não podemos usar a palavra chave this com métodos e variáveis
estáticas, já que este é uma referência para o objeto que contém o método o qual não é verdadeiro para métodos e
variáveis estáticas já que estes não pertencem a um objeto em particular, mas sim a classe.
11.3.4 Transient
É aplicado somente a variáveis. Quando uma variável é declarada transient ela não é guardada como parte
do estado de persistência do objeto.
11.3.5 Synchronized
Esse modificador é usado para sincronizar o acesso a código em ambientes paralelos. Este modificador será
visto detalhadamento onde veremos threads e métodos de sincronização.
11.3.6 Volatile
São aplicados somente a variáveis. Volatile permite que várias threads acessem simultaneamente a mesma
variável.
11.3.7 Native
Esse modificador é usado somente em métodos. Algumas vezes é necessário executar código não Java em
aplicações. Quando desejamos acessar chamadas do Sistema Operacional, interfacear com dispositivos de
hardware, reusar código não Java, implementar código onde o tempo é um parâmetro crítico e etc...
11.4 Encapsulamento
Uma das ideias mais importantes da orientação a objetos é o encapsulamento. Encapsular significa esconder
a implementação dos objetos. O encapsulamento favorece principalmente dois aspectos de um sistema: a
manutenção e o desenvolvimento.
A manutenção é favorecida pois, uma vez aplicado o encapsulamento, quando o funcionamento de um objeto
deve ser alterado, em geral, basta modificar a classe do mesmo.
O desenvolvimento é favorecido pois, uma vez aplicado o encapsulamento, conseguimos determinar
precisamente as responsabilidades de cada classe da aplicação.
OBJETIVOS DO ENCAPSULAMENTOServe para ocultar os dados; evita que o usuário acesse membros que ele não precisa manipular; permite a
modificação interna de uma classe sem alterar a sua funcionalidade e o modo como é acessada e é utilizado em
Java através dos modificadores de acesso.
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 72
11.4.1 Métodos Getters e Setters
Na linguagem Java, há uma convenção de nomenclatura para os métodos que têm como finalidade acessar
ou alterar as propriedades de um objeto.
Segundo essa convenção, os nomes dos métodos que permitem a consulta das propriedades de um objeto
devem possuir o prefixo get. Analogamente, os nomes dos métodos que permitem a alteração das propriedades de
um objeto devem possuir o prefixo set.
Na maioria dos casos, é muito conveniente seguir essa convenção, pois os desenvolvedores Java já estão
acostumados com essas regras de nomenclatura e o funcionamento de muitas bibliotecas do Java depende
fortemente desse padrão.
class Cliente {
// Atributos da classe
private String nome;
private String cpf;
// Métodos acessadores para os atributos da classe
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
}
IMPORTANTE
Os métodos gets e sets são utilizados para permitir o acesso aos atributos (já que eles são private) de uma
maneira controlada, a prática mais comum é criar dois métodos
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 73
11.5 Exercício
1) Julgue V ou F os seguintes itens a seguir acerca dos modificadores de Java.
( ) public: Uma classe declarada como pública dá as outras classes, de todos os pacotes, acesso aos seus membros
que forem públicos também.
( ) private: O membro da classe não pode ser acessado por nenhuma outra classe, quando é declarado private.
Como não é visto pelas subclasses, não se aplica regras de overriding. Esse modificador não se aplica a classes,
somente a seus membros (métodos e atributos).
( ) protected: Quando um membro da classe é declarado assim, ele se torna acessível por classes do mesmo pacote
ou através de herança.
( ) abstract: Quando é aplicado à classe não permite estendê-la, nos métodos impede que o mesmo seja sobrescrito
(overriding) na subclasse, já nas variáveis impossibilita que essa seja reinicializada com outro valor.
( ) final: Classes declaradas como abstratas provém um modo de adiar a implementação de métodos também
declarados como abstratos para subclasses. Uma classe abstrata não pode ser instanciada, ou seja, não podemos
chamar os seus construtores.
( ) static: Variáveis e métodos marcados como static pertencem à classe, ao invés de alguma instância dessa, esse
modificador não se aplica a classes.
( ) public : É o mais restritivo de todos. Atributos e métodos declarados como public em uma classe podem ser
acessados pelos métodos da própria classe, por classes derivadas desta e por qualquer outra classe em qualquer
outro pacote.
( ) protected : Atributos e métodos definidos como protected são acessíveis pelos métodos da própria classe e pelas
classes derivadas.
( ) private : É o mais restritivo. Atributos e métodos declarados como private só podem ser acessados pelos
métodos da própria classe.
( ) A instrução final indica que a classe, método ou variável assim declarada têm uma única atribuição que se
mantém constante, ou seja, não pode ser alterada no decorrer do processamento.
Pág.
11 MODIFICADORES JAVA
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 74
( ) O nível de acesso protected é mais restritivo do que o nível de acesso private.
( ) Os métodos declarados como public só podem ser acessados a partir dos métodos da própria classe ou de
classes derivadas.
2) Porque esse código não compila?
class Teste {
int x = 37;
public static void main(String [] args) {
System.out.println(x);
}
}
R =
3) Defina uma classe Funcionário com os atributos nome, cargo e salário. Na mesma classe, defina os métodos
acessadores para garantir o encapsulamento dos atributos. Defina outra classe com o método main para
criar objetos da classe Funcionário e executar os seus métodos.
Pág.
12 EXCEÇÕES – CONTROLANDO OS ERROS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 75
12 EXCEÇÕES – CONTROLANDO OS ERROS
Exceção é uma indicação de um problema que ocorre durante a execução de um programa. O nome
“exceção” significa que o problema não ocorre frequentemente. Com o tratamento de exceções, um programa
pode continuar executando (em vez de encerrar) depois de lidar com um problema. Uma exceção é um sinal que
indica que algum tipo de condição excepcional ocorreu durante a execução do programa. Assim, exceções estão
associadas a condições de erro que não tinham como ser verificadas durante a compilação do programa.
As duas atividades associadas à manipulação de uma exceção são:
geração: a sinalização de que uma condição excepcional (por exemplo, um erro) ocorreu, e
captura: a manipulação (tratamento) da situação excepcional, onde as ações necessárias para a recuperação
da situação de erro são definidas.
Para cada exceção que pode ocorrer durante a execução do código, um bloco de ações de tratamento (um
exception handler) deve ser especificado. O compilador Java verifica e enforça que toda exceção “não-trivial” tenha
um bloco de tratamento associado.
O mecanismo de manipulação de exceções em Java, embora apresente suas particularidades, teve seu
projeto inspirado no mecanismo equivalente de C++, que por sua vez foi inspirado em Ada. É um mecanismo
adequado à manipulação de erros síncronos, para situações onde a recuperação do erro é possível.
A sinalização da exceção é propagada a partir do bloco de código onde ela ocorreu através de toda a pilha
de invocações de métodos até que a exceção seja capturada por um bloco manipulador de exceção. Eventualmente,
se tal bloco não existir em nenhum ponto da pilha de invocações de métodos, a sinalização da exceção atinge o
método main(), fazendo com que o interpretador Java apresente uma mensagem de erro e aborte sua execução.
12.1 Tratamento de exceções
A captura e o tratamento de exceções em Java se dá através da especificação de blocos try, catch e finally,
definidos através destas mesmas palavras reservadas da linguagem.
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) {
Pág.
12 EXCEÇÕES – CONTROLANDO OS ERROS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 76
// 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 quesempre 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 valor real por 0 não gera uma exceção (o resultado é o valor infinito);
NumberFormatException: indica que tentou-se a conversão de uma string para um formato numérico, mas seu
conteúdo não representava adequadamente um número para aquele formato. É uma subclasse de
IllegalArgumentException;
IndexOutOfBounds: indica a tentativa de acesso a um elemento de um agregado aquém ou além dos limites
válidos. É a superclasse de ArrayIndexOutOfBoundsException, para arranjos, e de StringIndexOutOfBounds, para
strings;
NullPointerException: indica que a aplicação tentou usar uma referência a um objeto que não foi ainda definida;
ClassNotFoundException: indica que a máquina virtual Java tentou carregar uma classe mas não foi possível
encontrá-la durante a execução da aplicação.
Além disso, outros pacotes especificam suas exceçõ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 exceção mais específicas desse pacote, tais como EOFException (fim de
Pág.
12 EXCEÇÕES – CONTROLANDO OS ERROS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 77
arquivo ou stream), FileNotFoundException (arquivo especificado não foi encontrado) e InterruptedIOException
(operação de entrada ou saída foi interrompida).
Uma exceção contém pelo menos uma string que a descreve, que pode ser obtida pela 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 exceção é a seqüência de métodos no
momento da exceção, obtenível a partir do método printStackTrace().
Como exceções fazem parte de uma hierarquia de classes, exceçõ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 exceções são derivadas de Exception. Se dois blocos catch especificam exceções em um mesmo ramo
da hierarquia, a especificação do tratamento da exceção derivada deve preceder aquela da mais genérica.
12.2 Erros e Exceções de runtime
Exceções consistem de um caso particular de um objeto da classe Throwable. Apenas objetos dessa classe
ou de suas classes derivadas podem ser gerados, propagados e capturados através do mecanismo de tratamento de
exceções.
Além de Exception, outra classe derivada de Throwable é a classe Error, que é a raiz das classes que
indicam situações que a aplicação não tem como ou não deve tentar tratar. Usualmente indica situações anormais,
que não deveriam ocorrer. Entre os erros definidos em Java, no pacote java.lang, estão StackOverflowError e
OutOfMemoryError. São situações onde não é possível uma correção a partir de um tratamento realizado pelo
próprio programa que está executando.
Há também exceções que não precisam ser explicitamente capturadas e tratadas. São aquelas derivadas de
RuntimeException, uma classe derivada diretamente de Exception. São exceções que podem ser geradas durante a
operação normal de uma aplicação para as quais o compilador Java não irá exigir que o programador proceda a
algum tratamento (ou que propague a exceção, como descrito na Seção 2.6.3). Entre essas incluem-se
ArithmeticException, IllegalArgumentException, IndexOutOfBoundsException e NullPointerException.
12.3 Propagando exceções
Embora toda exceção que não seja derivada de RuntimeException deva ser tratada, nem sempre é possível
tratar uma exceção no mesmo escopo do método cuja invocação gerou a exceção. Nessas situações, é possível
propagar a exceção para um nível acima na pilha de invocações. Para tanto, o método que está deixando de capturar
e tratar a exceção faz uso da cláusula throws na sua declaração:
Pág.
12 EXCEÇÕES – CONTROLANDO OS ERROS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 78
void métodoQueNãoTrataExceção() throws Exception {
invoca.métodoQuePodeGerarExceção();
}
Nesse caso, métodoQueNãoTrataExceção() reconhece que em seu corpo há a possibilidade de haver a
geração de uma exceção mas não se preocupa em realizar o tratamento dessa exceção em seu escopo. Ao
contrário, ele repassa essa responsabilidade para o método anterior na pilha de chamadas.
Eventualmente, também o outro método pode repassar a exceção adiante. Porém, pelo menos no método
main() as exceções deverão ser tratadas ou o programa pode ter sua interpretação interrompida.
12.4 Definindo e gerando exceçoes
Exceções são classes. Assim, é possível que uma aplicação defina suas próprias exceções através do
mecanismo de definição de classes.
Por exemplo, considere que fosse importante para uma aplicação diferenciar a condição de divisão por zero
de outras condições de exceções artiméticas. Neste caso, uma classe DivideByZeroException poderia ser criada:
public class DivideByZeroExceptionextends ArithmeticException {
public DivideByZeroException() {
super("O denominador na divisão inteira tem valor zero");
}
}
Neste caso, o argumento para o construtor da superclasse especifica a mensagem que seria impressa
quando o método getMessage() fosse invocado para essa exceção. Essa é a mesma mensagem que é apresentada
para um RuntimeException que não é capturado e tratado.
Para gerar uma condição de exceção durante a execução de um método, um objeto dessa classe deve ser
criado e, através do comando throw, propagado para os métodos anteriores na pilha de execução:
public double calculaDivisao (double numerador, int denominador)
throws DivideByZeroException {
if (denominador == 0)
throw new DivideByZeroException();
return numerador / denominador;
}
Pág.
12 EXCEÇÕES – CONTROLANDO OS ERROS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 79
O mesmo comando throw pode ser utilizado para repassar uma exceção após sua captura—por exemplo,
após um tratamento parcial da condição de exceção:
public void usaDivisao() throws DivideByZeroException {
...
try {
d = calculaDivisao(x, y);
}
catch (DivideByZeroException dbze) {
...
throw dbze;
}
...
}
Nesse caso, a informação associada à exceção (comoo seu ponto de origem, registrado internamente no
atributo do objeto que contém a pilha de invocações) é preservada. Caso fosse desejado mudar essa informação,
uma nova exceção poderia ser gerada ou, caso a exceção seja a mesma, o método fillInStackTrace() poderia ser
utilizado, como em
throw dbze.fillInStackTrace();
12.5 Hierarquia de exceções Java
As classes de exceção herdam direta ou indiretamente da classe Exception, formando uma
hierarquia de herança. Pode estender essa hierarquia com suas próprias classes de exceção.A figura
abaixo mostra uma pequena parte da hierarquia de herança da classe Throwable (uma subclasse de
Object), que é a superclasse da classe Exception. Somente objetos Throwable podem ser utilizados com o
mecanismo de tratamento de exceções. A classe Throwable tem duas subclasses: Exception e Error. A
classe Exception e suas subclasses representam situações excepcionais que podem ocorrer em um
programa Java. Essas subclasses podem ser capturadas e tratadas pelo aplicativo. A classe Error e suas
subclasses representam situações anormais que podem acontecer na JVM.
Pág.
12 EXCEÇÕES – CONTROLANDO OS ERROS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 80
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 81
13 THREADS
13.1 Conceito de Threads
Se pensarmos nos programas que utilizamos comumente no dia a dia, conseguiremos chegar a seguinte
conclusão: um programa executa um conjunto de tarefas relativamente independentes entre si. Por exemplo, um
navegador pode baixar vários arquivos diferentes além de permitir a navegação. Um software de visualização de
vídeos além de reproduzir imagens também reproduzir sons.
Se pensarmos em sistemas corporativos, também chegamos na mesma conclusão: um sistema corporativo
executa um conjunto de tarefas relativamente independentes entre si. Por exemplo, dois ou mais usuários acessando
o mesmo sistema para fazer coisas diferentes.
Neste sentido uma thread trabalha como um subsistema, sendo uma forma de um processo se autodividir em
duas ou mais tarefas. É o termo em inglês para Linha ou Encadeamento de Execução.
O conceito de thread está intimamente ligado ao conceito de processo, assim é fundamental entender o que são
processos, como eles são representados e colocados em execução pelo Sistema Operacional, para em seguida
entender as threads.
Dessa forma segue uma breve definição de Processo e posteriormente a de Thread.
Definição de Processo
“Um processo é basicamente um programa em execução, sendo constituído do código executável, dos dados
referentes ao código, da pilha de execução, do valor do contador de programa (registrador PC), do valor do
apontador do apontador de pilha (registrador SP), dos valores dos demais registradores do hardware, além de um
conjunto de outras informações necessárias à execução dos programas.” Tanenbaum
Definição de Thread
“Thread, ou processo leve, é a unidade básica de utilização da CPU, consistindo de : contador de programa, conjunto de
registradores e uma pilha de execução. Thread são estruturas de execução pertencentes a um processo e assim compartilham os
segmentos de código e dados e os recursos alocados ao sistema operacional pelo processo. O conjunto de threads de um
processo é chamado de Task e um processo tradicional possui uma Task com apenas uma thread.” Silberschatz
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 82
Paralelismo x Concorrência
Threads podem executar suas funções de forma paralela ou concorrente, onde quando as threads são
paralelas elas desempenham o seus papeis independente uma das outras. Já na execução concorrente, as threads
atuam sobre objetos compartilhados de forma necessitando de sincronismo no acesso a esses objetos, assim deve
ser garantido o direito de atomicidade e exclusão mútua nas operações das threads sobre objetos compartilhados.
13.2 Ciclo de Vida de uma Thread
Durante a vida de uma thread ela pode estar em vários estados, conforme pode ser visto abaixo.
13.2.1 Criando Threads
A criação de uma thread é feita através do chamado ao seu construtor colocando a thread no estado Nova, o
qual representa uma thread vazia, ou seja, nenhum recurso do sistema foi alocado para ela ainda. Quando uma
thread está nesse estado a única operação que pode ser realizada é a inicialização dessa thread através do método
start(), se qualquer outro método for chamado com a thread no estado Nova irá acontecer uma exceção
(IllegalThreadStateException), assim como, quando qualquer método for chamado e sua ação não for condizente
com o estado atual da thread.
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 83
13.2.2 Iniciando Threads
A inicialização de uma thread é feita através do método start() e nesse momento os recursos necessários
para execução da mesma são alocados, tais como recursos para execução, escalonamento e chamada do método
run da thread.
13.2.3 Fazendo Thread Esperar
Uma thread irá para o estado Esperando quando:
O método sleep (faz a thread esperar por um determinada tempo) for chamado;
O método wait (faz a thread esperar por uma determinada condição) for chamado;
Quando realizar solicitação de I/O.
13.2.4 Finalizando Threads
Uma Thread é finalizada quando acabar a execução do seu método run, e então ela vai para o estado Morta,
onde o Sistema de Execução Java poderá liberar seus recursos e eliminá-la .
13.2.5 Verificando se Threads estão Executando/Pronta/Esperando ou Novas/Mortas
A classe Thread possui o método isAlive, o qual permite verificar se uma thread está nos estado
Executando/Pronta/Esperando ou nos estados Nova/Morta. Quando o retorno do método for true a thread esta
participando do processo de escalonamento e o retorno for false a thread está fora do processo de escalonamento.
Não é possível diferenciar entre Executando, Pronta ou Esperando, assim também como não é possível diferenciar
entre Nova ou Morta.
13.3 Implementando Threads em java
Podemos, em Java, facilmente criar uma classe que tem um método que vai ser executado
concorrentemente com o seu main. Para isso, você precisa implementar a interface Runnable, que define o método
run.
class ThreadTeste
{
public static void main (String args[])
{
ThreadInterface tiJ = new ThreadInterface();
Thread thread = new Thread(tiJ);
thread.start();
}
}
// Classe que implementa a interface Runnable
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 84
public class ThreadInterface implements Runnable {
public void run()
{
for (int i=0; i<100; i++) {
System.out.println(" Contador --> "+i);
}
}
}
Como a classe Thread implementa Runnable, é possível criar uma subclasse de Threads e reescrever o run,
que na classe Thread não faz nada, conforme exemplo abaixo:
package threads;
class MinhaThread extends Thread
{
public MinhaThread(String nome){
super(nome);
}
public void run(){
for (int i=0; i<10; i++)
{
System.out.println(getName()+ " - " +i );
}
}
}
package threads;
public class Teste {
public static void main(String args[]){
MinhaThread a,b;
a = new MinhaThread("Joao");
b = new MinhaThread("Jose");
a.start();b.start();
}
}
Threads: Alguns métodos
• public static native void yield()
– faz uma suspensão temporária da execução da Thread e permite que outra execute.
• public static native void sleep(long millis) throws InterruptedException
– faz a corrente threat em execução “dormir” por um período de tempo (cessa a execução temporariamente) por um
número de milisegundos específico.
– Throws: caso outra thread tenha interrompido esta thread.
• public native synchronized void start()
– causa o início da execução da thread. A Java Virutal Machine chama o método run para a thread.
– Throws: IilegalThreadStateException ocorre caso a thread já tenha sido iniciada.
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 85
• public void run()
– Se essa thread tenha sido construída usando um objeto Runnable, então o método run deste objeto será chamado.
Caso contrário nada é executado e retorna.
• public final void stop()
– força a thread para a execução.
• public final void setPriority (int newPriority)
– muda a prioridade de uma thread.
• public final int getPriority()
– retorna a prioridade da thread
• public final void setName (String name)
– muda o nome da thread para o novo nome
• public final String getName()
– retorna o nome da thread
Threads Daemon
São threads que rodam em background e realizam tarefas de limpeza ou manutenção, as quais devem rodar
enquanto a aplicação estiver em execução, as threads daemons somente morrerem quando a aplicação for
encerrada. Threads daemons são denominadas de Threads de Serviço e as não daemon são denominadas de
Threads de Usuário.
Os métodos para manipulação de threads daemon são:
public final void setDaemon(boolean) Torna ou não uma thread daemon
public final boolean isDaemon() Verifica se uma thread é daemon
13.4 Escalonamento de Threads
O escalonamento é fundamental quando é possível a execução paralela de threads, pois, certamente
existirão mais threads a serem executadas que processadores, assim a execução paralela de threads é simulada
através de mecanismos do escalonamento dessas threads, onde os processadores disponíveis são alternados pelas
diversas threads em execução. O mecanismo de escalonamento utilizado pelo Sistema de Execução Java é bastante
simples e determinístico, e utiliza um algoritmo conhecido como Escalonamento com Prioridades Fixas, o qual
escalona threads baseado na sua prioridade. As threads escalonáveis são aquelas que estão nos estados
Executando ou Pronta, para isso toda thread possui uma prioridade, a qual pode ser um valor inteiro no intervalo
[MIN_PRIORITY ... MAX_PRIORITY], (estas são constantes definidas na classe Thread), e quanto maior o valor do
inteiro maior a prioridade da thread. Cada thread Nova recebe a mesma prioridade da thread que a criou e a
prioridade de uma thread pode ser alterada através do método setPriority(int priority).
Exemplo de aplicação usando threads com diferentes prioridades
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 86
Observe que essa corrida não é justa pois os sapos 4 e 5 possuem prioridades máximas e com certeza
ganharão a corrida.
Exemplo1:
/* Aplicação que simula uma corrida de sapos usando threads */
public class CorridaDeSapos {
final static int NUM_SAPOS = 5; // QTE. de sapos na corrida
final static int DISTANCIA = 500; // Distância da corrida em cm
public static void main (String[] args) {
/* Criando as threads para representar os sapos correndo */
SapoCorrendoThread sapo_1 = new SapoCorrendoThread("SAPO_01", DISTANCIA);
SapoCorrendoThread sapo_2 = new SapoCorrendoThread("SAPO_02", DISTANCIA);
SapoCorrendoThread sapo_3 = new SapoCorrendoThread("SAPO_03", DISTANCIA);
SapoCorrendoThread sapo_4 = new SapoCorrendoThread("SAPO_04", DISTANCIA);
SapoCorrendoThread sapo_5 = new SapoCorrendoThread("SAPO_05", DISTANCIA);
/* Estabelecendo prioridades para as threads */
sapo_1.setPriority(Thread.MIN_PRIORITY);
sapo_2.setPriority(Thread.MIN_PRIORITY);
sapo_3.setPriority(Thread.NORM_PRIORITY);
sapo_4.setPriority(Thread.MAX_PRIORITY);
sapo_5.setPriority(Thread.MAX_PRIORITY);
/* Iniciando as threads */
sapo_1.start();
sapo_2.start();
sapo_3.start();
sapo_4.start();
sapo_5.start();
}
}
Simulação de uma Corridas de Sapos, onde cada sapo na corrida é representado por uma
thread.
Exemplo2:
public class CorridaDeSapos2 {
final static int NUM_SAPOS = 5; // QTE. de sapos na corrida
final static int DISTANCIA = 500; // Distância da corrida em cm
public static void main (String[] args) {
/* colocando sapos na corrida */
for (int i = 1; i <= NUM_SAPOS; i++) {
new SapoCorrendoThread("SAPO_" + i, DISTANCIA).start();
}
}
}
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 87
Classe SapoCorrendoThread utilizada pelas duas classes dos exemplos acima.
class SapoCorrendoThread extends Thread {
String nome; // nome do sapo
int distanciaCorrida = 0; // distância já corrida pelo sapo
int distanciaTotalCorrida; // distância a ser corrida pelo sapo
int pulo = 0; // pulo do sapo em cm
int pulos = 0; // quantidades de pulos dados na corrida
static int colocacao = 0; // colocação do sapo ao final da corrida
final static int PULO_MAXIMO = 50; // pulo máximo em cm que um sapo pode dar
/** Construtor da classe. Parâmtros : Nome do Sapo e Distância da Corrida */
public SapoCorrendoThread (String nome, int distanciaTotalCorrida) {
/* chamando o construtor de Thread passando o nome do sapo como parâmetro */
super(nome);
this.distanciaTotalCorrida = distanciaTotalCorrida;
this.nome = nome;
}
/** Imprime o último pulo do sapo e a distância percorrida */
public void sapoImprimindoSituacao () {
System.out.println("O " + nome + " pulou " + pulo + "cm \t e já percorreu " +
distanciaCorrida + "cm");
}
/** Faz o sapo pular */
public void sapoPulando() {
pulos++;
pulo = (int) (Math.random() * PULO_MAXIMO);
distanciaCorrida += pulo;
if (distanciaCorrida > distanciaTotalCorrida) {
distanciaCorrida = distanciaTotalCorrida;
}
}
/** Representando o descanso do sapo */
public void sapoDescansando () {
/* Método que passa vez a outras threads */
yield();
}
/** Imprime a colocação do sapo ao final da corrida */
public void colocacaoSapo () {
colocacao++;
System.out.println(nome + " foi o " + colocacao + "º colocado com " + pulos + "
pulos");
}
/** Método run da thread Corrida de Sapos */
public void run () {
while (distanciaCorrida < distanciaTotalCorrida) {
Pág.
THREADS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 88
sapoPulando();
sapoImprimindoSituacao();
sapoDescansando();
}
colocacaoSapo();
}
}
13.5 Exercícios
a) Defina a classe Contador como uma subclasse de Thread, que imprime números de 0 a 10. Crie a classe
TesteContador que deve definir o método main que cria e inicia a execução do thread Contador. Teste o
resultado executando a classe TesteContador.
b) Altere as classes Contador e TesteContador de modo que a classe Contador seja definida como uma
implementação da interface Runnable. Teste o resultado.
Pág.
14 API JAVA - JAVA.IO
JAVA OO LOGUSTI – TREINAMENTOEM INFORMÁTICA PÁGINA 89
14 API JAVA - JAVA.IO
A linguagem Java é capaz de processar arquivos que requisitam grandes quantidades de dados persistentes.
Esses são os dados que ficam armazenados dentro dos arquivos, sendo que a sua duração vai além da finalização
de um programa. Esse processamento de arquivos é uma capacidade que o Java oferece para ler e gravar dados na
memória, arquivos e conexões de rede.
Quando existe um dispositivo de entrada de dados ativo, para obter dados deste dispositivo é usada uma
ação conhecida como read(). E para enviar um dado para um dispositivo de saída é utilizado o método write().
Para trabalhar com entrada e saída de dados são utilizadas as classes que estão dentro do java.io. Essas
classes oferecem algumas funcionalidades como:
Manipulação de entrada e saída de bytes – transferência de dados binários;
Manipulação de entrada e saída de caracteres – transferência de textos;
Buffers - melhoram a eficiência da velocidade de leitura e escrita;
Conversão de formatos – texto e formato interno de dados binários.
As entradas e saídas de dados são manipuladas como sequência de bytes, através das classes
InputStream e OutputStream e as classes dependentes.
14.1 Classe InputStream
É uma classe abstrata que oferece a funcionalidade básica para a leitura de um byte ou de uma sequência
de bytes a partir de alguma fonte.
Pág.
14 API JAVA - JAVA.IO
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 90
14.2 Lendo um arquivo
Os métodos read() oferecem a leitura de bytes. O valor de retorno desse método é um inteiro, que pode ser o
byte lido do próprio método ou número de bytes lidos do método read(byte[] b) sendo que quando o retorno for o
valor de -1, é informado que o final do arquivo foi atingindo.
InputStream is = new FileInputStream("arquivo.txt");
int valor = is.read();
Exemplo 1
No exemplo acima, a classe abstrata InputStream é declarada inicializando uma classe dependente, a
FileInputStream. Essa classe recebe uma String como argumento no construtor. Esse argumento é a definição de
onde está localizado o arquivo.
Pág.
14 API JAVA - JAVA.IO
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 91
Então as principais subclasses de InputStream são:
ByteArrayInputStream – Valores são originários de um arranjo de bytes;
FileInputStream – Bytes com originalidade de um arquivo.
FilterInputStream – Filtra os dados de um InputStream.
BufferedInputStream – Faz a leitura de grandes volumes de bytes que armazena em um buffer interno.
DataInputStream – Permite a leitura de representações binárias dos tipos primitivos de Java.
ObjectInputStream – Oferece o método readObject para a leitura de objetos que foram serializados para um
ObjectOutputStream.
PipedInputStream – Faz a leitura de um pipe de bytes cuja origem está associada a um objeto
PipedOutputStream.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class TestaEntrada {
public static void main(String[] args) throws IOException{
InputStream is = System.in;
System.out.print("Digite um texto: ");
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String digitado = br.readLine();
while(digitado != null){
System.out.println("Texto Digitado = "+digitado);
digitado = br.readLine();
}
}
}
Exemplo 2
Pág.
14 API JAVA - JAVA.IO
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 92
14.3 OutputStream
É uma classe abstrata que transfere sequencialmente os bytes para algum destino. Os métodos write(), tem
a função de escrever em forma de bytes para o destino onde vai enviar.
Subclasses OutputStream
As classes abstratas Reader e Writer se envolvem na manipulação de arquivos (leitura e escrita) que
contém caracteres.
14.4 Reader
É uma classe abstrata sendo igual à InputStream, é voltada para a manipulação de caracteres. Nessa classe
não é possível criar objetos diretos dela. Para criar objetos é necessário instanciar uma das subclasses concretas
para ter o acesso à funcionalidade especificada por Reader.
14.5 Writer
É uma classe abstrata que escreve stream de caracteres. Os únicos métodos que uma subclasse writer deve
implementar são: write(char [], int, int), flush () e close ().
Subclasses da classe Writer
Pág.
14 API JAVA - JAVA.IO
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 93
14.6 Buffers
São entidades intermediárias entre duas ou mais entidades que produzem e consomem elementos. No Buffer
existe uma área de memória que é utilizada para armazenamento temporário dos elementos que foram produzidos
mas ainda não foram consumidos.
Para aprendizado abaixo é mostrado um exemplo do que o código faz a criação e leitura do arquivo
declarado dentro do construtor da classe File.
A classe abaixo cria e lê o arquivo texto "ArquivoCriado.txt".
import java.io.File;
import java.io.IOException;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedWriter;
import java.io.BufferedReader;
class Cria_e_Le_Arquivo {
public static void main(String args[]) {
File f = new File("ArquivoCriado.txt");
try {
FileWriter fw = new FileWriter(f);
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Esse texto está sendo inserido");
//INSERE UMA NOVA LINHA
bw.newLine();
bw.write("Continua sendo inserido em uma nova linha");
bw.newLine();
bw.write("Continua sendo inserido em uma 3ª linha");
bw.flush();
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
//EFETUANDO A LEITURA
try {
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
String s;
Pág.
14 API JAVA - JAVA.IO
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 94
//ENQUANTO EXISTE DADOS CONTINUA IMPRIMINDO
while ((s = br.readLine()) != null) {
System.out.println(s);
}
} catch (IOException e) {
System.out.println("###### Erro: "+e.getMessage());
e.printStackTrace();
}
}
}
Apenas vale lembrar que quando executado o código mostrado acima, é criado um arquivo chamado
ArquivoCriado.txt dentro do projeto e com as saídas que foram dadas ao BufferedWriter. Efetue o teste achando esse
arquivo e consulte se os valores que foram inseridos no programa são os mesmo que estão no arquivo.
IMPORTANTE
A partir do Java 5, foi criada a classe java.util.Scanner, que facilita bastante o trabalho de ler de um InputStream.
Além disso, a classe PrintStream possui um construtor que já recebe o nome de um arquivo como argumento. Dessa
forma, a leitura do teclado com saída para um arquivo ficou muito simples:
Scanner s = new Scanner(System.in);
PrintStream ps = new PrintStream("arquivo.txt");
while (s.hasNextLine()) {
ps.println(s.nextLine());
}
A classe Scanner é do pacote java.util. Ela possui métodos muito úteis para trabalhar com Strings, em especial,
diversos métodos já preparados para pegar números e palavras já formatadas através de expressões regulares. Fica
fácil parsear um arquivo com qualquer formato dado.
14.7 Exercíciosa) Faça um programa em Java que leia um texto informado pelo usuário no console e que salve o texto
informado em um arquivo qualquer.
Pág.
15 COLLECTIONS FRAMEWORK
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 95
15 COLLECTIONS FRAMEWORK
15.1 – Introdução
Quando uma aplicação precisa manipular uma quantidade grande de dados, ela deve utilizaralguma estrutura
de dados. Podemos dizer que a estrutura de dados mais básica do Java são os arrays. Entretanto, trabalhar
diretamente com arrays não é simples dado as diversas limitações que eles possuem. A limitação principal é a
capacidade fixa, um array não pode ser redimensionado. Se todas as posições de umarray estiverem ocupadas não
podemos adicionar mais elementos. Normalmente, criamos um outro array com maior capacidade e transferimos os
elementos do array antigo para o novo.
Além disso, adicionar ou remover elementos provavelmente gera a necessidade de deslocar parte do
conteúdo do array.
Para facilitar a manipulação de dados por meio das estruturas de dados, java possui a API Collection.
15.2 – Tipos de Coleções
Existem várias coleções diferentes. Elas diferem, por exemplo, nos mecanismos de armazenagem usados,
na maneira que acessam, dados e nas regras sobre quais dados podem ser armazenados. A API Collections
oferecem uma variedade de interfaces e algumas classes de implementação concreta cobrindo essas variações.
Uma interface geral, java.util.Collection, define a estrutura básica de coleções. Essa interface estipula os
métodos que permitem a você acrescentar itens, remover itens, determinar se eles estão na coleção e contar a
quantidade de itens na coleção.
Algumas coleções são ordenadas; isto é, há uma clara noção de um item seguindo um outro. Uma coleção
desse tipo, normalmente é conhecida como uma lista ou uma seqüência. Em algumas listas, a ordem é uma ordem
em que os itens são acrescentados à coleção; em outras os próprios elementos parecem ter uma ordem natural, e
aquela ordem é entendida pela lista. Na API Collections de Java, a interface java.util.List define uma estrutura
básica para coleções desse tipo.
Se uma coleção impõe a condição específica que ela não pode conter o mesmo valor mais do que uma vez,
então ela é conhecida como um set(conjunto). A interface java.util.Set define a estrutura básica desse tipo de
coleção.
O tipo final de comportamento especializado, diretamente suportado pelas API Collectiosn é conhecido como
uma map(mapa), java.util.Map. Um mapa usa um conjunto de valores-chave para buscar, ou indexar, os dados
armazenados. Por exemplo, se você armazenar um objeto representando uma pessoa, então como valor chave você
Pág.
15 COLLECTIONS FRAMEWORK
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 96
pode usar o nome daquela pessoa ou algum outro identificador único, como um número de seguro social ou um
número de identificação de funcionário. É uma exigência para um mapa que a chave seja única, e por esse motivo,
se você estiver armazenando dados sobre uma pessoa em um mapa, o nome não é uma chave muito boa – é bem
possível que duas pessoas tenham o mesmo nome. A interface Map não herda a interface Collection!
Collection
Set – Sem repetição
List – Com repetição/ordenação
Coleção Map – Par/Valor
Tanto a interface List como a interface Set herdam a interface Collection que define métodos para adicionar e
remover um elemento, verificar se ele está na coleção e outras operações, alguns métodos da interface collection:
Nome do Método Descrição
boolean add(Object) Adiciona um elemento na coleção. Como algumas coleções não suportam
elementos duplicados, este método retorna true ou false indicando se a
adição foi efetuada com sucesso.
boolean remove(Object) Remove determinado elemento da coleção. Se ele não existia, retorna
false.
int size() Retorna a quantidade de elementos existentes na coleção.
boolean contains(Object) Procura por determinado elemento na coleção, e retorna verdadeiro caso
ele exista. Esta comparação é feita baseando-se no método equals() do
objeto, e não através do operador ==.
Iterator iterator() Retorna um objeto que possibilita percorrer os elementos daquela
coleção.
Antes de começarmos a codificar alguns exemplos de como utilizar as collections, vamos tomar como base a
classe abaixo:
public class Livro {
// Atributos da classe
private String titulo;
private String editora;
Pág.
15 COLLECTIONS FRAMEWORK
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 97
// Método construtor sem parâmetros
Livro() { }
// Método construtor com parâmetros
Livro(String titulo, String editora) {
this.titulo = titulo;
this.editora = editora;
}
// Métodos acessadores
public String getEditora() {
return this.editora;
}
public void setEditora(String editora) {
this.editora = editora;
}
public String getTitulo() {
return this.titulo;
}
public void setTitulo(String editora) {
this.editora = editora;
}
}
Exemplo utilizando os Arrays
public class TesteArray {
public static void main(String args[]) {
// Criando o array com três posições
Livro[] livros = new Livro[3];
// Populando o array
livros[0] = new Livro("Java: Como Programar", "Bookman");
livros[1] = new Livro("Tutorial do JEE", "Campus");
livros[2] = new Livro("Core Java 2: Fundaments", "Makron Books");
// Percorrendo e imprimindo os elementos do array
for( int i = 0; i < livros.length ; i++ ) {
System.out.println("Titulo: " + livros[i].getTitulo() + "Editora: " +
livros[i].getEditora() );
}
}
}
Pág.
15 COLLECTIONS FRAMEWORK
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 98
15.2.1 – Lista
É uma coleção que permite elementos duplicados e mantendo uma ordenação específica entre os
elementos. Você tem garantia de que quando percorrer a lista, os elementos serão encontrados em uma ordem pré-
determinada, definida na hora da inserção dos elementos.
A implementação mais famosa da interface List é a ArrayList, ela trabalha com um array interna para gerar uma lista
portanto ela é mais rápida que sua concorrente, a LinkedList que é mais rápida na inserção e remoção de itens nas
pontas.
Exemplo utilizando uma ArrayList
import java.util.ArrayList;
public class TesteArrayList {
public static void main(String[] args) {
ArrayList<Livro> list = new ArrayList<Livro>();
list.add(new Livro("Java: Como Programar", "Bookman"));
list.add(new Livro("Tutorial do JEE", "Campus"));
list.add(new Livro("Core Java 2: Fundaments", "Makron Books"));
for( int i = 0; i < list.size() ; i++ ) {
Livro tempLivro = (Livro) list.get(i);
System.out.println(tempLivro.getTitulo() );
}
}
}
IMPORTANTE
A partir do Java 5 existe o suporte à Generics que evitam alguns erros de casting e facilitam muito a vida do
desenvolvedor. A interface Collection agora é parametrizada. Isto é, temos uma Collection<Tipo> que indica
qual é o tipo que estamos trabalhando com essa coleção. Com isso definimos o que os métodos vão receber
e devolver. Uma
Collection<Tipo> tem métodos como contains(Tipo o) e add(Tipo o), o que nos da uma enorme segurança em
tempo de compilação, evitando castings. No exemplo acima, o tipo definido para o Arraylist foi da classe
Livro.Pág.
15 COLLECTIONS FRAMEWORK
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 99
15.2.2 – Conjunto
Uma das principais características de um conjunto(Set) é o fato de que a ordem em que os elementos são
armazenados.
A ordem vai variar de implementação para implementação, as principais implementações de uma interface
Set são as classes HashSet e ThreeSet.
Quantos elementos serão adicionados no Set chamado conjunto no exemplo abaixo?
package collections;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
public class TesteConjunto {
public static void main(String[] args) {
// Criando a estrutura de conjunto
Set conjunto = new HashSet();
// Populando a estrutura criada
conjunto.add("Elemento 1");
conjunto.add("Elemento 2");
conjunto.add("Elemento 3");
conjunto.add("Elemento 3");
conjunto.add("Elemento 4");
}
}
15.2.3 – Mapas
Os mapas trabalham associando chaves a valores, para quem já tem uma certa experiência com Java e já
trabalho com arquivos properties vai ficar fácil assimilar esta interface. As principais implementações da interface
Map são o HashMap e o HashTable.
Exemplo utilizando um HashMap
import java.util.HashMap;
import java.util.Map;
public class ExemploMapas {
public static void main(String args[]) {
Pág.
15 COLLECTIONS FRAMEWORK
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 100
// Criando a estrutura de mapas
Map<String, String> mapa = new HashMap<>();
// Variável auxiliar
String pessoaNome;
// Populando o mapa
mapa.put( "pessoa.nome", "Gleidson Porto");
mapa.put( "pessoa.idade", "35") ;
mapa.put( "pessoa.email", "gleidsonporto@gmail.com");
mapa.put( "pessoa.site", "www.logusti.com.br") ;
// Pegando o nome da chave pessoa.nome do mapa
pessoaNome = (String)mapa.get("pessoa.nome");
System.out.println("Nome: " + pessoaNome);
}
}}
O método put(Object, Object) da interface Map recebe a chave e o valor de uma nova associação, caso já
exista uma associação para esta chave o método irá retornar o objeto associado a esta chave, e irá trocar o este
objeto pelo novo objeto passado no método put.
SAIBA MAIS
Um mapa importante é a tradicional classe Properties, que mapeia strings e é muito utilizada para a configuração
de aplicações.
A Properties possui, também, métodos para ler e gravar o mapeamento com base em um arquivo texto,
facilitando muito a sua persistência.
Properties config = new Properties();
config.setProperty("database.login", "logusti");
config.setProperty("database.password", "g1o4a1");
config.setProperty("database.url","jdbc:mysql:/localhost/teste");
// muitas linhas depois...
String login = config.getProperty("database.login");
String password = config.getProperty("database.password");
String url = config.getProperty("database.url");
DriverManager.getConnection(url, login, password);
Repare que não houve a necessidade do casting para String no momento de recuperar os objetos associados.
Isto porque a classe Properties foi desenhada com o propósito de trabalhar com a associação entre Strings.
Pág.
15 COLLECTIONS FRAMEWORK
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 101
15.3 – Exercício
a) Implemente uma classe em Java com as funcionalidades de uma agenda telefônica, associando um nome a
um número telefônico. A classe deve possuir a interface abaixo:
b) Crie um programa em Java para testar a classe AgendaTelefonica desenvolvida no exercício anterior. Teste
a classe com pelo menos 5 contatos diferentes na agenda de telefones.
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 102
RESPOSTAS DO EXERCÍCIOS
LISTA DE EXERCÍCIOS 4.6
a) Altere o programa AloMundo.Java para que ele imprima na tela todos os tipos primitivos de dados suportados pela
linguagem Java.
public class Exercicio_4_6_A {
public static void main(String[] args) {
System.out.println("*** Tipos primitivos do Java ****");
System.out.println();
System.out.println("Tipo - Bits - Bytes ");
System.out.println("byte - 8 - 1 ");
System.out.println("short - 16 - 2 ");
System.out.println("int - 32 - 4 ");
System.out.println("long - 64 - 8 ");
System.out.println("float - 32 - 4 ");
System.out.println("double - 64 - 8 ");
System.out.println("char - 16 - 2 ");
System.out.println("boolean - 1 - - ");
}
}
b) Altere o programa AloMundo para que ele imprima os parâmetros recebidos pela linha de comando de execução
do programa. (Dica: são os valores do array args: args[0], args[1], etc.)
public class Exercicio_4_6_B {
public static void main(String[] args) {
// Considerando que neste momento pelo conteúdo apresentado, pressupõe-se que
tenha conhecimento
// em estruturas de laço de repetição. Sendo assim, o exercício será realizado da
forma mais simples.
// Nos capítulos seguintes o aluno, descobrirá outra forma para eficiente para
resolução deste exercício.
// Recebendo os três argumentos.
// Observe que o primeiro elemento do array começa na posição 0(zero).
String parametroRecebido1= args[0];
String parametroRecebido2= args[1];
String parametroRecebido3= args[2];
// Imprimindo os parâmetros recebidos
System.out.println(parametroRecebido1);
System.out.println(parametroRecebido2);
System.out.println(parametroRecebido3);
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 103
}
}
c) Crie um programa que receba três argumentos da linha de comando e imprima-os na mesma linha, em ordem
inversa.
Exemplo:
java Programa a1 a2 a3
Saída: a3 a2 a1
public class Exercicio_4_6_C {
public static void main(String[] args) {
// Considerando que neste momento pelo conteúdo apresentado, pressupõe-se que
tenha conhecimento
// em estruturas d e laço de repetição. Sendo assim, o exercício será realizado
da forma mais simples.
// Nos capítulos seguintes o aluno, descobrirá outra forma para eficiente para
resolução deste exercício.
// Recebendo os três argumentos.
// Observe que o primeiro elemento do array começa na posição 0(zero).
String parametroRecebido1= args[0];
String parametroRecebido2= args[1];
String parametroRecebido3= args[2];
// Imprimindo os parâmetros recebidos na ordem invertida
System.out.println(parametroRecebido3);
System.out.println(parametroRecebido2);
System.out.println(parametroRecebido1);
}
}
LISTA DE EXERCÍCIO 5.6
a) Implemente um programa para calcular a área de um trapézio, onde:
h = altura
b = base menor
B = base maior
Área = (h . (b + B)) / 2
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_5_6_A {
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 104
public static void main(String[] args) {
// Para leitura do parâmetros do cálculo, utilizaremos a classe Scanner.
// Você verá em detalhes este recurso no tópico 6.6 Lendovalores do teclado da
apostila.
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
// Objeto para captura das informações
System.out.println("Cálculo da Área do Trapézio");
Scanner linha = new Scanner(entrada);
// Realizando a leitura da altura.
System.out.print("Forneça a altura: ");
double altura = linha.nextDouble();
// Realizando a leitura da base menor.
System.out.print("Forneça a base menor: ");
double baseMenor = linha.nextDouble();
// Realizando a leitura da base maior.
System.out.print("Forneça a base maior: ");
double baseMaior = linha.nextDouble();
// Calculando a fórmula para obter a área do trapézio
double area = (altura * (baseMenor + baseMaior))/2;
// Imprimindo a área calculada
System.out.println("A área do trapézio é " + area);
}
}
b) Faça o programa acima calcular utilizando valores de ponto flutuante e depois imprima na tela duas
informações:
Valor exato da área:
Valor arredondado para inteiro:
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_5_6_B {
public static void main(String[] args) {
// Para leitura do parâmetros do cálculo, utilizaremos a classe Scanner.
// Você verá em detalhes este recurso no tópico 6.6 Lendo valores do teclado da
apostila.
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 105
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
// Objeto para captura das informações
System.out.println("Cálculo da Área do Trapézio");
Scanner linha = new Scanner(entrada);
// Realizando a leitura da altura.
System.out.print("Forneça a altura: ");
double altura = linha.nextDouble();
// Realizando a leitura da base menor.
System.out.print("Forneça a base menor: ");
double baseMenor = linha.nextDouble();
// Realizando a leitura da base maior.
System.out.print("Forneça a base maior: ");
double baseMaior = linha.nextDouble();
// Calculando a fórmula para obter a área do trapézio
double area = (altura * (baseMenor + baseMaior))/2;
// Imprimindo a área EXATA calculada do trapézio
System.out.println("A área exata do trapézio é " + area);
// Imprimindo a área calculada do trapézio arredondada
System.out.println("A área exata arredondada do trapézio é " + (int)area);
}
}
c) Calcule o valor das seguintes equações:
a. 3 – 2 – 1 + 2 + 1 + 3
b. 2 * 3 – 4 * 5
c. 2 + 6 – 3 / 7 * 9
d. 3 % 4 – 8
public class Exercicio_5_6_C {
public static void main(String[] args) {
// Realizando os cálculos das equações
double resultadoA = 3 - 2 - 1 + 2 + 1 + 3;
double resultadoB = 2 * 3 - 4 * 5;
double resultadoC = 2 + 6 - 3 / 7 * 9;
double resultadoD = 3 % 4 - 8;
// Imprimindo o resultado das equações
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 106
System.out.println("Resultado das Equações");
System.out.println(" a) 3 – 2 – 1 + 2 + 1 + 3 = " + resultadoA);
System.out.println(" b) 2 * 3 – 4 * 5 = " + resultadoB);
System.out.println(" c) 2 + 6 – 3 / 7 * 9 = " + resultadoC);
System.out.println(" d) 3 % 4 – 8 = " + resultadoD);
//Resultado da Execução
/*Resultado das Equações
a) 3 – 2 – 1 + 2 + 1 + 3 = 6.0
b) 2 * 3 – 4 * 5 = -14.0
c) 2 + 6 – 3 / 7 * 9 = 8.0
d) 3 % 4 – 8 = -5.0*/
}
}
d) Indique qual o valor verdade das seguintes expressões:
a. (1 > 2) // exemplo: false
b. (8 == 8) // exemplo: true
c. ((12 – 5) > 6) - FALSE
d. (0 < 3) && (8 < 9) - TRUE
e. ((i++) > i) - FALSE
f. ((10 * 90 / 50 – 2) == 16) TRUE
LISTA DE EXERCÍCIO 6.7
1. Escreva um programa que imprima na tela a soma dos números ímpares entre 0 e 20 e a multiplicação dos
números pares entre 0 e 20.
public class Exercicio_6_7_1 {
public static void main(String[] args) {
// Variáveis criadas para armazenar os valores dos cálculos
int totalImpares=0;
// Será utilizado o tipo double porque o int possui limitação de tamanho
double totalPares=1;
// Laço de repetição de 0 a 20.
for (int numero=1; numero <= 19;numero++){
// Número par
if (numero % 2 == 0){
// Multiplicando os números pares
totalPares = totalPares * numero;
} else
// Somando os números ímpares
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 107
totalImpares = totalImpares + numero;
}
System.out.println("Total da soma dos números ímpares de 0 a 20: " +
totalImpares);
System.out.println("Total da multiplicação dos números pares de 0 a 20: " +
totalPares);
}
}
Execução
Total da soma dos números ímpares de 0 a 20: 100
Total da multiplicação dos números pares de 0 a 20: 1.8579456E8
2. Faça um programa para ler um número do teclado e imprimir na tela se ele é par ou ímpar.
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_6_7_2 {
public static void main(String[] args) {
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
// Objeto para captura das informações
System.out.println("Digite um número");
int numero = linha.nextInt();
// Verificando se o número é par
if (numero % 2 == 0){
System.out.println( numero + " é um número par. ");
} else
System.out.println( numero + " é um número ímpar. ");
}
}
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 108
3. O valor pago por um Hotel da Praia de Iracema para seus porteiros é de R$ 10,25 por hora de trabalho. Faça um
programa que pergunte ao usuário quantas horas ele trabalhou e imprima na tela o valor do salário a ser recebido
por ele.
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_6_7_3 {
public static void main(String[] args) {
// Valor da hora de trabalho
double valorHora = 10.25;
System.out.println("** Cálculo de Salário de Porteiro - Hotel da Praia de Iracema
**");
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
// Objeto para captura das informações
System.out.println("Digite a quantidade de horas: ");
// Capturando a quantidade de horas
double horas = linha.nextDouble();
// Cálculo do salário
double salario = horas * valorHora;
// Imprimindo o salário
System.out.println( " Valor do salário: " + salario);
}
}
4. Modifique o programa anterior para que o sistema imprima uma mensagem de alerta quando o valor a ser pago
ao funcionário seja inferior a R$ 50,00: "Atenção, dirija-se à direção do Hotel!".
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_6_7_4 {
public static void main(String[] args) {
// Valor da hora de trabalho
double valorHora = 10.25;
System.out.println("** Cálculo de Salário de Porteiro - Hotel da Praia de Iracema
**");
// Oobjeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 109
Scanner linha = new Scanner(entrada);
// Objeto para captura das informações
System.out.println("Digite a quantidade de horas: ");
// Capturando a quantidade de horas
double horas = linha.nextDouble();
// Cálculo do salário
double salario = horas * valorHora;
// Condição estabelecida no exercício
if (salario <50 )
System.out.println("Atenção, dirija-se à direção do Hotel!");
else System.out.println( " Valor do salário: " + salario);
}
}
5. Sabendo que na LogusTI a média mínima é 7,0 e a tolerância de faltas é 15 % da carga horária do curso, faça
uma classe com o método main que peça as informações necessárias e informe a situação do usuário.
public class Exercicio_6_7_5 {
public static void main(String[] args) {
String situacao;
System.out.println("** RENDIMENTO DE ALUNO - LOGUSTI **");
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
// Capturando as informações para cálculo do rendimento
System.out.print("Digite o nome do aluno: ");
String nome = linha.nextLine();
System.out.print("Digite a nota de média do aluno: ");
double nota = linha.nextDouble();
System.out.print("Digite o percentual(%) de falta do aluno: ");
double percFalta = linha.nextDouble();
// Verificação do rendimento escolar
if (nota>=7.0 && percFalta<=15)
situacao = "APROVADO";
else situacao = "REPROVADO";
System.out.println("\n** RENDIMENTO DO ALUNO ** ");
System.out.println("Nome............: " + nome);
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 110
System.out.println("Nota de Média...: " + nota);
System.out.println("Faltas(%).......: " + percFalta);
System.out.println("Situação........: " + situacao );
}
}
Exemplo da execução
** RENDIMENTO DE ALUNO - LOGUSTI **
Digite o nome do aluno: Gleidson Porto
Digite a nota de média do aluno: 10
Digite o percentual(%) de falta do aluno: 0
** RENDIMENTO DO ALUNO **
Nome............: Gleidson Porto
Nota de Média...: 10.0
Faltas(%).......: 0.0
Situação........: APROVADO
6. Implemente uma classe java “Calculos” com um método”calcularMedia” que receba três números e calcule a
média e imprima na tela essa média. O método “calcularMaior”, deverá receber também três números e retornar o
maior número e o método “calcularMenor”, deverá receber três números e retornar o melhor número. Implemente a
classe com o método main e instancie a classe Calculos executando todos os seus métodos.
public class Calculos {
public double calcularMedia(double num1, double num2, double num3){
// Calculando a média
double media = (num1 + num2 + num3)/3.0;
// Retornando a média
return media;
}
public double calcularMaior(double num1, double num2, double num3){
double maior;
// Comparando para identificar o maior número
if (num1>num2 && num1>num3)
maior = num1;
else if (num2>num3)
maior = num2;
else maior = num3;
return maior;
}
public double calcularMenor(double num1, double num2, double num3){
double menor;
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 111
// Comparando para identificar o maior número
if (num1<num2 && num1<num3)
menor = num1;
else if (num2<num3)
menor = num2;
else menor = num3;
return menor;
}
}
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_6_7_6 {
public static void main(String[] args) {
// Criando o objeto da classe Cálculo
Calculos objCalculo = new Calculos();
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
// Capturando os números
System.out.print("Número 1...: ");
double num1 = linha.nextDouble();
System.out.print("Número 2...: ");
double num2 = linha.nextDouble();
System.out.print("Número 3...: ");
double num3 = linha.nextDouble();
// Calcular maior número
System.out.println("Maior número........: " + objCalculo.calcularMaior(num1, num2,
num3));
// Calcular média
System.out.println("Média dos números...: " + objCalculo.calcularMedia(num1, num2,
num3));
// Calcular menor número
System.out.println("Menor número........: " + objCalculo.calcularMenor(num1, num2,
num3));
}
}
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 112
Execução
Número 1...: 2,2
Número 2...: 9
Número 3...: 4,5
Maior número........: 9.0
Média dos números...: 5.233333333333333
Menor número........: 2.2
7. Construa uma classe que peça o Nome, Endereço, Sexo, Cidade, Estado, Idade dos funcionários. Além disto,
dado o Salário Bruto do funcionário, calcule o seu Salário Líquido. Considere que os descontos podem ser o Vale
Transporte (2%), Vale Alimentação (5%) e Plano de Saúde (10%).
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_6_7_7 {
public static void main(String[] args) {
String situacao;
System.out.println("** CALCULO DE SALÁRIO **");
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
// Capturando as informações do funcionário
System.out.print("Nome.........: ");
String nome = linha.nextLine();
System.out.print("Idade.......: ");
int idade = Integer.parseInt(linha.nextLine());
System.out.print("Endereço....: ");
String endereco = linha.nextLine();
System.out.print("Sexo........: ");
String sexo = linha.nextLine();
System.out.print("Cidade......: ");
String cidade = linha.nextLine();
System.out.print("Estado......: ");
String estado = linha.nextLine();
System.out.print("Salário Bruto...: ");
double salarioBruto = linha.nextDouble();
// Calculando o salário
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 113
// Calculando os descontos Vale Transporte (2%), Vale Alimentação (5%) e Plano de
Saúde (10%).
double valeTransporte = salarioBruto * (2/100.0);
double valeAlimentacao = salarioBruto * (5/100.0);
double planoSaude = salarioBruto * (10/100.0);
// Calculando o salário líquido
double salarioLiquido = salarioBruto - valeTransporte - valeAlimentacao -
planoSaude;
System.out.println("** DEMONSTRATIVO DE SALÁRIO *** ");
System.out.println("Nome............: " + nome);
System.out.println("Salário Bruto...: " + salarioBruto);
System.out.println("Salário Líquido.: " + salarioLiquido);
}
}
Exemplo da Execução
** CALCULO DE SALÁRIO **
Nome.........: Roberto Carlos
Idade.......: 37
Endereço....: SGAS 916 LT 32
Sexo........: M
Cidade......: BRASILIA
Estado......: DF
Salário Bruto...: 22500,50
** DEMONSTRATIVODE SALÁRIO ***
Nome............: Roberto Carlos
Salário Bruto...: 22500.5
Salário Líquido.: 18675.415
LISTA DE EXERCÍCIOS 7.8
1) Crie um programa que imprima na tela os argumentos passados na linha de comando para o método main.
Compile e execute a classe ImprimeArgumentos. Na execução, não esqueça de passar alguns parâmetros na linha
de comando.
public class Exercicio_7_8_1 {
public static void main(String[] parametros) {
// Imprimindo todos os parametros recebidos
for (int i = 0; i < parametros.length; i++) {
System.out.print(parametros[i] + " ");
}
}
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 114
}
2) Faça um programa que ordene o array de strings recebido na linha de comando. Compile e execute a classe
Ordena. Na execução, não esqueça de passar alguns parâmetros na linha de comando.
import java.util.Arrays;
//2) Faça um programa que ordene o array de strings recebido na linha de comando. Compile e
execute a classe Ordena.
//Na execução, não esqueça de passar alguns parâmetros na linha de comando.
public class Exercicio_7_8_2 {
public static void main(String[] parametros) {
// Ordenando os elementos numéricos do arrays
Arrays.sort(parametros);
// Imprimindo os elementos ordenados
System.out.println("Valores ordenados" + Arrays.toString(parametros));
}
}
Execução
Valores digitados como parâmetros: 9 2 1 0 3 5
Valores ordenados[0, 1, 2, 3, 5, 9]
3) Faça um programa que calcule a média dos elementos recebidos na linha de comando. Dica: para converter
strings para double utilize o método parseDouble()
public class Exercicio_7_8_3 {
public static void main(String[] numerosRecebidos) {
// Variável auxiliar para soma
double soma =0;
// Percorrendo o array e realizando o somatório dos valores informados
for (int i = 0; i < numerosRecebidos.length; i++) {
soma = Double.parseDouble(numerosRecebidos[i]) + soma;
}
// Calculando a média dos valores recebidos
double media = soma/numerosRecebidos.length;
System.out.println("Média dos valores " + media);
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 115
}
}
4) Faça um programa que leia cinco nomes do teclado, e depois imprima esses nomes na ordem inversa em
que foram digitados pelo usuário.
public class Exercicio_7_8_4 {
public static void main(String[] numerosRecebidos) {
// Percorrendo o array e imprimindo os elementos na ordem inversa
for (int i = numerosRecebidos.length-1; i >= 0; i--) {
System.out.println(numerosRecebidos[i]);
}
}
}
5) O tempo que um determinado avião dispensa para percorrer o trecho entre duas localidades distintas está
disponível através da seguinte tabela:
A B C D E F G
02 11 06 15 11 01
02 07 12 04 02 15
11 07 11 08 03 13
06 12 11 10 02 01
15 04 08 10 05 13
11 02 03 02 05 14
01 15 13 01 13 14
a) Construa uma classe java que leia a tabela anterior e informe ao usuário o tempo necessário para percorrer duas cidades
por ele fornecidas, até o momento em que ele fornecer duas cidades iguais (origem e destino).
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_7_8_5 {
public static void main(String[] args) {
// Carregando a matriz com os valores pré-definidos
int[][] matriz = new int[7][7];
// Distâncias da linha 0 ou cidade A
matriz[0][0] = 0;
matriz[0][1] = 2;
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 116
matriz[0][2] = 11;
matriz[0][3] = 6;
matriz[0][4] = 15;
matriz[0][5] = 11;
matriz[0][6] = 1;
// Distâncias da linha 1 ou cidade B
matriz[1][0] = 2;
matriz[1][1] = 0;
matriz[1][2] = 7;
matriz[1][3] = 12;
matriz[1][4] = 4;
matriz[1][5] = 2;
matriz[1][6] = 15;
// Distâncias da linha 2 ou cidade C
matriz[2][0] = 11;
matriz[2][1] = 7;
matriz[2][2] = 0;
matriz[2][3] = 11;
matriz[2][4] = 8;
matriz[2][5] = 3;
matriz[2][6] = 13;
matriz[3][0] = 6;
matriz[3][1] = 12;
matriz[3][2] = 11;
matriz[3][3] = 0;
matriz[3][4] = 10;
matriz[3][5] = 2;
matriz[3][6] = 1;
matriz[4][0] = 15;
matriz[4][1] = 4;
matriz[4][2] = 8;
matriz[4][3] = 10;
matriz[4][4] = 0;
matriz[4][5] = 5;
matriz[4][6] = 13;
matriz[5][0] = 11;
matriz[5][1] = 2;
matriz[5][2] = 3;
matriz[5][3] = 2;
matriz[5][4] = 5;
matriz[5][5] = 0;
matriz[5][6] = 14;
matriz[6][0] = 1;
matriz[6][1] = 15;
matriz[6][2] = 13;
matriz[6][3] = 1;
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 117
matriz[6][4] = 13;
matriz[6][5] = 14;
matriz[6][6] = 0;
System.out.println("*** Calculo de Distância de Cidades A B C D E F G ***
");
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
System.out.println("Cidade origem(A, B, C , D, E, F ou G): ");
String cidadeOrigem = linha.next();
System.out.println("Cidade destino(A, B, C , D, E, F ou G): ");
String cidadeDestino = linha.next();
// Realizando o de - para para identificar a linha e coluna da matriz
int lin=0;
if (cidadeOrigem.toUpperCase().equals("A"))
lin = 0;
else if (cidadeOrigem.toUpperCase().equals("B"))
lin = 1;
else if (cidadeOrigem.toUpperCase().equals("C"))
lin = 2;
else if (cidadeOrigem.toUpperCase().equals("D"))
lin = 3;
else if (cidadeOrigem.toUpperCase().equals("E"))
lin = 4;
else if (cidadeOrigem.toUpperCase().equals("F"))
lin = 5;
else if (cidadeOrigem.toUpperCase().equals("G"))
lin = 6;
int col=0;
if (cidadeDestino.toUpperCase().equals("A"))
col = 0;
else if (cidadeDestino.toUpperCase().equals("B"))
col = 1;
else if (cidadeDestino.toUpperCase().equals("C"))
col = 2;
else if (cidadeDestino.toUpperCase().equals("D"))
col = 3;
else if (cidadeDestino.toUpperCase().equals("E"))
col = 4;
else if (cidadeDestino.toUpperCase().equals("F"))
col = 5;
else if (cidadeDestino.toUpperCase().equals("G"))
col = 6;
System.out.println("A distância entre as cidades " + cidadeOrigem + " e " + cidadeDestino +
"é " + matriz[lin][col]);
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 118
}
}
*** Calculo de Distância de Cidades A B C D E F G ***
Cidade origem(A, B, C , D, E, F ou G):
A
Cidade destino(A, B, C , D, E, F ou G):
F
A distância entre as cidades A e F é 11
b) Elabore uma classe que imprima a tabela sem repetições(apenas o triângulo superior ou o triângulo inferior).
import java.io.InputStream;
import java.util.Scanner;
public class Exercicio_7_8_5 {
public static void main(String[] args) {
// Carregandoa matriz com os valores pré-definidos
int[][] matriz = new int[7][7];
// Distâncias da linha 0 ou cidade A
matriz[0][0] = 0;
matriz[0][1] = 2;
matriz[0][2] = 11;
matriz[0][3] = 6;
matriz[0][4] = 15;
matriz[0][5] = 11;
matriz[0][6] = 1;
// Distâncias da linha 1 ou cidade B
matriz[1][0] = 2;
matriz[1][1] = 0;
matriz[1][2] = 7;
matriz[1][3] = 12;
matriz[1][4] = 4;
matriz[1][5] = 2;
matriz[1][6] = 15;
// Distâncias da linha 2 ou cidade C
matriz[2][0] = 11;
matriz[2][1] = 7;
matriz[2][2] = 0;
matriz[2][3] = 11;
matriz[2][4] = 8;
matriz[2][5] = 3;
matriz[2][6] = 13;
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 119
matriz[3][0] = 6;
matriz[3][1] = 12;
matriz[3][2] = 11;
matriz[3][3] = 0;
matriz[3][4] = 10;
matriz[3][5] = 2;
matriz[3][6] = 1;
matriz[4][0] = 15;
matriz[4][1] = 4;
matriz[4][2] = 8;
matriz[4][3] = 10;
matriz[4][4] = 0;
matriz[4][5] = 5;
matriz[4][6] = 13;
matriz[5][0] = 11;
matriz[5][1] = 2;
matriz[5][2] = 3;
matriz[5][3] = 2;
matriz[5][4] = 5;
matriz[5][5] = 0;
matriz[5][6] = 14;
matriz[6][0] = 1;
matriz[6][1] = 15;
matriz[6][2] = 13;
matriz[6][3] = 1;
matriz[6][4] = 13;
matriz[6][5] = 14;
matriz[6][6] = 0;
System.out.println("*** Calculo de Distância de Cidades A B C D E F G ***
");
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
System.out.println("Cidade origem(A, B, C , D, E, F ou G): ");
String cidadeOrigem = linha.next();
System.out.println("Cidade destino(A, B, C , D, E, F ou G): ");
String cidadeDestino = linha.next();
// Realizando o de - para para identificar a linha e coluna da matriz
int lin=0;
if (cidadeOrigem.toUpperCase().equals("A"))
lin = 0;
else if (cidadeOrigem.toUpperCase().equals("B"))
lin = 1;
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 120
else if (cidadeOrigem.toUpperCase().equals("C"))
lin = 2;
else if (cidadeOrigem.toUpperCase().equals("D"))
lin = 3;
else if (cidadeOrigem.toUpperCase().equals("E"))
lin = 4;
else if (cidadeOrigem.toUpperCase().equals("F"))
lin = 5;
else if (cidadeOrigem.toUpperCase().equals("G"))
lin = 6;
int col=0;
if (cidadeDestino.toUpperCase().equals("A"))
col = 0;
else if (cidadeDestino.toUpperCase().equals("B"))
col = 1;
else if (cidadeDestino.toUpperCase().equals("C"))
col = 2;
else if (cidadeDestino.toUpperCase().equals("D"))
col = 3;
else if (cidadeDestino.toUpperCase().equals("E"))
col = 4;
else if (cidadeDestino.toUpperCase().equals("F"))
col = 5;
else if (cidadeDestino.toUpperCase().equals("G"))
col = 6;
System.out.println("A distância entre as cidades " + cidadeOrigem + " e " + cidadeDestino +
" é " + matriz[lin][col]);
imprimirTrianguloInferior(matriz);
}
public static void imprimirTrianguloInferior(int[][] matriz){
for (int lin = 0; lin < matriz.length; lin++) {
for (int col = 0; col < matriz.length; col++) {
if (lin==col)
{ System.out.println();
break;
}
System.out.print(matriz[lin][col] + " ");
}
}
}
}
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 121
Execução
*** Calculo de Distância de Cidades A B C D E F G ***
Cidade origem(A, B, C , D, E, F ou G):
a
Cidade destino(A, B, C , D, E, F ou G):
b
A distância entre as cidades a e b é 2
2
11 7
6 12 11
15 4 8 10
11 2 3 2 5
1 15 13 1 13 14
LISTA DE EXERCÍCIO 8.4
Para atender as necessidades de informação de uma biblioteca universitária foi proposto um sistema que deve
atender as seguintes características:
O cadastro dos usuários da biblioteca com endereço completo. Os usuários podem ser classificados em três
grupos: Professores, Alunos e Funcionários. Para os Alunos é necessário conhecer o curso ao qual
pertencem. Dos Professores e funcionários, é necessário conhecer o Departamento ao qual estão sempre
vinculados.
O cadastro das obras da biblioteca, que podem ser classificadas em: Livros científicos, periódicos científicos,
periódicos informativos, periódicos diversos, entretenimento, etc.
A língua em que se encontra o exemplar da obra.
A mídia onde se encontra o exemplar da obra.
Os autores da obra com o controle da nacionalidade do autor.
As editoras dos exemplares com o ano de edição de cada exemplar.
O histórico dos empréstimos.
Identifique as possíveis classes e objetos com seus respectivos atributos e métodos.
LISTA DE EXERCÍCIO 8.6
a) Implemente uma classe chamada Aluno para definir os objetos que representarão os alunos de uma escola.
Essa classe deve declarar três atributos: o primeiro para o nome, o segundo para o RG e o terceiro para o CPF dos
alunos.
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 122
public class Aluno {
// Definindo os atributos da classe
private String nome;
private String rg;
private String cpf;
// Definindo os métodos acessadores para garantir o encapsulamento
// Método para recuperar o nome
public String getNome() {
return nome;
}
// Método para atualizar o nome
public void setNome(String nome) {
this.nome = nome;
}
// Método para recuperar o RG
public String getRg() {
return rg;
}
// Método para atualizar o RG
public void setRg(String rg) {
this.rg = rg;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = cpf;
}
}
b) Faça uma classe chamada TestaAluno e crie dois objetos da classe Aluno atribuindo valores a eles. A classe
também deve mostrar na tela as informações desses objetos.
public class TestaAluno {
public static void main(String[] args) {
// Criando objeto 1 da classe aluno
Aluno obj1 = new Aluno();
// Populando o objeto criado
obj1.setNome("Gleidson Porto");
obj1.setRg("888.888-8");
obj1.setCpf("888.888.888-88");
// Criando objeto 2 da classe aluno
Aluno obj2 = new Aluno();
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 123
// Populando o objeto criado
obj2.setNome("Roberto Carlos");
obj2.setRg("999.999-9");
obj2.setCpf("999.999.999-99");
// Imprimindo informações dos objetos criados
System.out.println(" NOME - RG - CPF ");
System.out.println(obj1.getNome() + " - " + obj1.getRg() + " - " + obj1.getCpf());
System.out.println(obj2.getNome() + " - " + obj2.getRg() + " - " + obj2.getCpf());
}
}
Execução:
NOME - RG - CPF
Gleidson Porto - 888.888-8 - 888.888.888-88
Roberto Carlos - 999.999-9 - 999.999.999-99
c) Em uma escola, além dos alunos temosos funcionários, que também precisam ser representados em nossa
aplicação. Então implemente outra classe chamada Funcionario que contenha dois atributos: o primeiro para o cargo
e o segundo para o salário dos funcionários.
public class Funcionario {
// Definindo os atributos da classe
private String cargo;
private double salario;
// Definindo os métodos acessadores
public String getCargo() {
return cargo;
}
public void setCargo(String cargo) {
this.cargo = cargo;
}
public double getSalario() {
return salario;
}
public void setSalario(double salario) {
this.salario = salario;
}
}
d) Faça uma classe chamada TestaFuncionario e crie dois objetos da classe Funcionario atribuindo valores a
eles. Mostre na tela as informações desses objetos.
public class TestaFuncionario {
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 124
public static void main(String[] args) {
// Criando objeto 1 da classe Funcionario
Funcionario obj1 = new Funcionario();
// Populando o objeto criado
obj1.setCargo("Professor");
obj1.setSalario(10500);
// Criando objeto 2 da classe Funcionario
Funcionario obj2 = new Funcionario();
// Populando o objeto criado
obj2.setCargo("Diretor");
obj2.setSalario(20500);
// Imprimindo informações dos objetos criados
System.out.println(" CARGO - SALÁRIO");
System.out.println(obj1.getCargo() + " - " + obj1.getSalario());
System.out.println(obj2.getCargo() + " - " + obj2.getSalario());
}
}
Execução
CARGO - SALÁRIO
Professor - 10500.0
Diretor - 20500.0
e) Em uma escola, os alunos precisam ser divididos por turmas, que devem ser representadas dentro da
aplicação. Implemente uma classe chamada Turma que contenha quatro atributos: o primeiro para o período, o
segundo para definir a série, o terceiro para sigla e o quarto para o tipo de ensino.
public class Turma {
// Definindo os atributos da classe
private String período;
private String serie;
private String sigla;
private String tipoEnsino;
// Definindo os métodos acessadores para garantir o encapsulamento
// Método para recuperar o período
public String getPeríodo() {
return período;
}
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 125
// Método para atualizar o período
public void setPeríodo(String período) {
this.período = período;
}
public String getSerie() {
return serie;
}
public void setSerie(String serie) {
this.serie = serie;
}
public String getSigla() {
return sigla;
}
public void setSigla(String sigla) {
this.sigla = sigla;
}
public String getTipoEnsino() {
return tipoEnsino;
}
public void setTipoEnsino(String tipoEnsino) {
this.tipoEnsino = tipoEnsino;
}
}
f) Faça uma classe chamada TestaTurma para criar dois objetos da classe Turma. Adicione informações a eles
e depois mostre essas informações na tela.
public class TestaTurma {
public static void main(String[] args) {
// Criando objeto 1 da classe Turma
Turma obj1 = new Turma();
// Populando o objeto criado
obj1.setPeríodo("2016.2");
obj1.setSerie("7a Série");
obj1.setSigla("7A");
obj1.setTipoEnsino("Ensino Médio");
// Criando objeto 2 da classe aluno
Turma obj2 = new Turma();
// Populando o objeto criado
obj2.setPeríodo("2016.1");
obj2.setSerie("6a Série");
obj2.setSigla("6A");
obj2.setTipoEnsino("Ensino Médio");
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 126
// Imprimindo informações dos objetos criados - obj 1
System.out.println("Período.......: " + obj1.getPeríodo());
System.out.println("Série.........: " + obj1.getSerie());
System.out.println("Sigla.........: " + obj1.getSigla());
System.out.println("Tipo Ensino...: " + obj1.getTipoEnsino());
System.out.println("-------------------------------------");
// Imprimindo informações dos objetos criados - obj 2
System.out.println("Período.......: " + obj2.getPeríodo());
System.out.println("Série.........: " + obj2.getSerie());
System.out.println("Sigla.........: " + obj2.getSigla());
System.out.println("Tipo Ensino...: " + obj2.getTipoEnsino());
}
}
Execução
Período.......: 2016.2
Série.........: 7a Série
Sigla.........: 7A
Tipo Ensino...: Ensino Médio
-------------------------------------
Período.......: 2016.1
Série.........: 6a Série
Sigla.........: 6A
Tipo Ensino...: Ensino Médio
LISTA DE EXERCÍCIO 9.4
1) Crie duas classes que definam os seguintes atributos e métodos para objetos do tipo:
Ao final crie um objeto da classe Empregado e um objeto da classe Gerente, atribuindo valores para seus
salários e comissão para o gerente. Ao final execute os métodos getSalario() de ambos objetos. Lembrar que o
salário do gerente é composto do salário + comissão.
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 127
public class Empregado {
// Atributos da classe empregado
private String nome;
private float salario;
// Métodos acessadores
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public float getSalario() {
return salario;
}
public void setSalario(float salario) {
this.salario = salario;
}
}
public class Gerente extends Empregado {
// Atributo da classe
private float comissao;
public float getComissao() {
return comissao;
}
public void setComissao(float comissao) {
this.comissao = comissao;
}
// Método getSalario sobeescrito da classe Empregado. Pois o salário do Gerente é
composto do salário + comissão.
public float getSalario() {
// A palavra reservada super faz referência ao método da super classe.
return super.getSalario() + comissao;
}
}
public class Exercicio_9_4_1 {
public static void main(String[] args) {
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 128
Empregado empregado = new Empregado();
empregado.setNome("Carlos Alberto");
empregado.setSalario(5600);
Gerente gerente = new Gerente();
gerente.setNome("Carlos Alberto");
gerente.setSalario(8000);
gerente.setComissao(1000);
System.out.println("Empregado...: " + empregado.getNome());
System.out.println("Salário.....: " + empregado.getSalario());
System.out.println("---------------------------------");
System.out.println("Gerente................: " + gerente.getNome());
System.out.println("Salário + comissão.....: " + gerente.getSalario());
}
}
Empregado...: Carlos Alberto
Salário.....: 5600.0
---------------------------------
Gerente................: Carlos Alberto
Salário + comissão.....: 9000.0
LISTA DE EXERCÍCIO 11.5
1) Julgue V ou F os seguintes itens a seguir acerca dos modificadores de Java.
(V) public: Uma classe declarada como pública dá as outras classes, de todos os pacotes, acesso aos seus membros
que forem públicos também.
(V) private: O membro da classe não pode ser acessado por nenhuma outraclasse, quando é declarado private.
Como não é visto pelas subclasses, não se aplica regras de overriding. Esse modificador não se aplica a classes,
somente a seus membros (métodos e atributos).
(V) protected: Quando um membro da classe é declarado assim, ele se torna acessível por classes do mesmo pacote
ou através de herança.
(F) abstract: Quando é aplicado à classe não permite estendê-la, nos métodos impede que o mesmo seja sobrescrito
(overriding) na subclasse, já nas variáveis impossibilita que essa seja reinicializada com outro valor.
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 129
(F) final: Classes declaradas como abstratas provém um modo de adiar a implementação de métodos também
declarados como abstratos para subclasses. Uma classe abstrata não pode ser instanciada, ou seja, não podemos
chamar os seus construtores.
(V) static: Variáveis e métodos marcados como static pertencem à classe, ao invés de alguma instância dessa, esse
modificador não se aplica a classes.
(F) public : É o mais restritivo de todos. Atributos e métodos declarados como public em uma classe podem ser
acessados pelos métodos da própria classe, por classes derivadas desta e por qualquer outra classe em qualquer
outro pacote.
(V) protected : Atributos e métodos definidos como protected são acessíveis pelos métodos da própria classe e pelas
classes derivadas.
(V) private : É o mais restritivo. Atributos e métodos declarados como private só podem ser acessados pelos métodos
da própria classe.
(V) A instrução final indica que a classe, método ou variável assim declarada têm uma única atribuição que se
mantém constante, ou seja, não pode ser alterada no decorrer do processamento.
(F) O nível de acesso protected é mais restritivo do que o nível de acesso private.
(F ) Os métodos declarados como public só podem ser acessados a partir dos métodos da própria classe ou de
classes derivadas.
2) Porque esse código não compila?
class Teste {
int x = 37;
public static void main(String [] args) {
System.out.println(x);
}
}
R = O código não compila porque o atributo X não é estático, pois métodos estáticos podem somente acessar
variáveis também estáticas, ou seja, é proibido o uso de variáveis não estáticas dentro de blocos estáticos, com
exceção de variáveis criadas dentro do próprio bloco é claro. Essa restrição se deve ao fato de que é possível fazer
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 130
uma chamada a um método estático mesmo sem haver nenhuma instância dessa classe, ou seja, a provável variável
a ser referenciada dentro do método pode nem mesmo ter sido criada ainda.
3) Defina uma classe Funcionário com os atributos nome, cargo e salário. Na mesma classe, defina os métodos
acessadores para garantir o encapsulamento dos atributos. Defina outra classe com o método main para
criar objetos da classe Funcionário e executar os seus métodos.
public class Funcionario {
// Definindo os atributos da classe
private String nome;
private String cargo;
private double salario;
// Definindo os métodos acessadores
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCargo() {
return cargo;
}
public void setCargo(String cargo) {
this.cargo = cargo;
}
public double getSalario() {
return salario;
}
public void setSalario(double salario) {
this.salario = salario;
}
}
public class TesteFuncionario11_5 {
public static void main(String[] args) {
// Criando objeto 1 da classe Funcionario
Funcionario obj1 = new Funcionario();
// Populando o objeto criado
obj1.setNome("Joao da Silva");
obj1.setCargo("Professor");
obj1.setSalario(10500);
// Imprimindo informações dos objetos criados
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 131
System.out.println(" CARGO - SALÁRIO");
System.out.println("Nome......: " + obj1.getNome());
System.out.println("Cargo.....: " + obj1.getCargo());
System.out.println("Salário...: " + obj1.getSalario());
}
}
Execução
CARGO - SALÁRIO
Nome......: Joao da Silva
Cargo.....: Professor
Salário...: 10500.0
LISTA DE EXERCÍCIO 13.5
a) Defina a classe Contador como uma subclasse de Thread, que imprime números de 0 a 10. Crie a classe
TesteContador que deve definir o método main que cria e inicia a execução do thread Contador. Teste o resultado
executando a classe TesteContador.
public class Contador extends Thread {
// Definição do método construtor atribuindo o nome para Thread
public Contador(String nome)
{
super(nome);
}
// Método de execução da Thread
public void run(){
for (int i=0; i<=10; i++)
{
System.out.println(getName()+ " - " +i );
}
}
}
public class TesteContador {
public static void main(String[] args) {
// Criando os objetos da classe contador
Contador contaA = new Contador("ContadorA");
Contador contaB = new Contador("ContadorB");
// Iniciando as Threads
contaA.start();
contaB.start();
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 132
}
}
b) Altere as classes Contador e TesteContador de modo que a classe Contador seja definida como uma
implementação da interface Runnable. Teste o resultado.
public class Contador implements Runnable {
public void run() {
for (int i=0; i<=10; i++)
{
System.out.println(" Contador --> "+i);
}
}
}
public class TesteContador {
public static void main(String[] args) {
// Criando os objetos da classe contador
Contador contaAInterface = new Contador();
Contador contaBInterface = new Contador();
Thread threadContaA = new Thread(contaAInterface);
Thread threadContaB = new Thread(contaBInterface);
// Iniciando as Threads
threadContaA.start();
threadContaB.start();
}
}
LISTA DE EXERCÍCIO 14.7
a) Faça um programa em Java que leia um texto informado pelo usuário no console e que salve o texto informado em
um arquivo qualquer.
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 133
import java.io.PrintWriter;
import java.util.Scanner;
public class Exercicio_14_7_A {
public static void main(String[] args) {
System.out.println("**** Gravação em arquivo texto **** \n\n");
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
// Capturando os números
System.out.print("Informe o texto......: ");
String texto = linha.nextLine();
FileWriter arq;
try {
arq = new FileWriter("c:\\temp\\teste.txt");
PrintWriter gravarArq = new PrintWriter(arq);
gravarArq.printf(texto);
arq.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.print("\nTexto gravado do sucessono arquivo " +
"c:\\temp\\teste.txt");
}
}
LISTA DE EXERCÍCIO 15.3
a) Implemente uma classe em Java com as funcionalidades de uma agenda telefônica, associando um nome a
um número telefônico. A classe deve possuir a interface abaixo:
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 134
import java.util.HashMap;
import java.util.Map;
public class AgendaTelefonica {
// Criação da estrutura de dados HashMap para os contatos
Map<String, String> contatos = new HashMap<String, String>();
// Método para inserir o nome e número na agenda de contatos
public void inserir(String nome, String numero){
contatos.put(nome, numero);
System.out.println("Nome e número inseridos com sucesso! ");
}
// Método para buscar o número do contato
public String buscarNumero(String nome){
return contatos.get(nome);
}
// Método para remover o contato
public void remover(String nome){
if (contatos.remove(nome)!=null)
System.out.println(nome + " removido com sucesso da agenda! ");
else System.out.println(nome + " não encontrado na agenda. ");
}
// Método para retornar o número de contatos cadastrados
public int tamanho(){
return contatos.size();
}
}
b) Crie um programa em Java para testar a classe AgendaTelefonica desenvolvida no exercício anterior. Teste
a classe com pelo menos 5 contatos diferentes na agenda de telefones.
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 135
import java.io.InputStream;
import java.util.Scanner;
public class AppAgendaTelefonica {
public static void main(String[] args) {
AgendaTelefonica agenda = new AgendaTelefonica();
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
String nome;
String numero;
int opcao = mostrarOpcoes();
while (opcao!=0) {
switch (opcao) {
// Inserir contato
case 1:
System.out.println("*** 1 - Cadastro de Contato *** ");
System.out.print("Digite o nome: ");
nome = linha.nextLine();
System.out.print("Digite o número: ");
numero = linha.nextLine();
agenda.inserir(nome, numero);
break;
// Localizar número
case 2:
System.out.println("*** 2 - Localização de Número **** ");
System.out.print("Digite o contato: ");
nome = linha.nextLine();
String numeroEncontrado = agenda.buscarNumero(nome);
if (numeroEncontrado!=null)
System.out.println(" Telefone " + numeroEncontrado + " do
contato " + nome);
else System.out.println(" Telefone não encontrado para o contato " +
nome);
break;
//Excluir contato
case 3:
System.out.println("*** 3 - Exclusão de Número *** ");
System.out.println("Digite o contato para exclusão: ");
nome = linha.nextLine();
agenda.remover(nome);
Pág.
RESPOSTAS DO EXERCÍCIOS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 136
break;
// Quantidade de contatos
case 4:
System.out.println("*** 4 - Quantidade de Contatos *** ");
System.out.println(agenda.tamanho() + " contato(s) cadastrados na
agenda. ");
break;
// Sair do sistema
case 0:
System.exit(0);
break;
}
opcao = mostrarOpcoes();
}
}
public static int mostrarOpcoes(){
System.out.println("\n*** AGENDA TELEFÔNICA *** \n");
// apresentando as opções do menu ao usuário
System.out.println("1 - Incluir Contato ");
System.out.println("2 - Localizar Número ");
System.out.println("3 - Excluir Contato ");
System.out.println("4 - Quantidade de contatos ");
System.out.println("0 - Sair ");
System.out.print("\n Digite a opção: ");
// O objeto System.in possibilita a leitura do que se escreve no teclado
InputStream entrada = System.in;
Scanner linha = new Scanner(entrada);
// capturando a opçao do usuário
int opcao = linha.nextInt();
// retornando a opção
return opcao;
}
}
*** AGENDA TELEFÔNICA ***
1 - Incluir Contato
2 - Localizar Número
3 - Excluir Contato
4 - Quantidade de contatos
0 - Sair
Digite a opção:
Pág.
REFERÊNCIAS
JAVA OO LOGUSTI – TREINAMENTO EM INFORMÁTICA PÁGINA 137
REFERÊNCIAS
Liang, Daniel, Eclipse Tutorial: a Supplement J, 2005.
Eclipse, In: Eclipse Foundation: Disponível em: http://www.eclipse.org.
Eclipse(IDE), In: Wikipédia: a enciclopédia livre.
Erickson, Marc (IBM), What is Eclipse, and how do I use it?
Paul Deitel Harvey Deitel. Java Como Programar. oitava edição. ISBN-10: 8576055635. Pearson, 2010.
Bertrand Meyer. Object-Oriented Software Construction. segunda edição. ISBN-10: 0136291554. Prentice
Hall, 1997.
Heller, Philip. Guia Completo de Estudos para Certificação em Java.
Silveira, Paulo. Um pouco sobre o pacote java.util.
Rogers Cadenhead & Laura Lemay. Aprenda em 21 dias java.
Cornell, Gary. Core Java.
Documentação oficial – Java/Oracle.
Outros sites especializados em Java.