Prévia do material em texto
Programador Java:
Nível Básico
Daniela Costa Terra
Formação Inicial e
Continuada
+ IFMG
Daniela Costa Terra
Programador Java: Nível Básico
1ª Edição
Belo Horizonte
Instituto Federal de Minas Gerais
2021
FICHA CATALOGRÁFICA
Dados Internacionais de Catalogação na Publicação (CIP)
T323p Terra, Daniela Costa.
Programador Java: nível básico [recurso eletrônico] /
Daniela Costa Terra. – Belo Horizonte : Instituto Federal de
Minas Gerais, 2021.
138 p. : il. color.
E-book, no formato PDF.
Material didático para Formação Inicial e Continuada.
ISBN: 978-65-5876-075-7
1. Java (linguagem de programação de computadores). 2.
Lógica de programação. 3. Programação orientada a objetos. I.
Título.
CDU: 004.43
Catalogação: Rosângela Marques de Souza - CRB-6/2126
Índice para catálogo sistemático:
Linguagem de Programação – 004.43
Pró-reitor de Extensão
Diretor de Programas de Extensão
Coordenação do curso
Arte gráfica
Diagramação
Carlos Bernardes Rosa Júnior
Niltom Vieira Junior
Daniela Costa Terra
Ângela Bacon
Eduardo dos Santos Oliveira
© 2021 by Instituto Federal de Minas Gerais
Todos os direitos autorais reservados. Nenhuma parte desta publicação poderá ser
reproduzida ou transmitida de qualquer modo ou por qualquer outro meio, eletrônico
ou mecânico. Incluindo fotocópia, gravação ou qualquer outro tipo de sistema de
armazenamento e transmissão de informação, sem prévia autorização por escrito do
Instituto Federal de Minas Gerais.
2021
Direitos exclusivos cedidos ao
Instituto Federal de Minas Gerais
Avenida Mário Werneck, 2590,
CEP: 30575-180, Buritis, Belo Horizonte – MG,
Telefone: (31) 2513-5157
Sobre o material
Este curso é autoexplicativo e não possui tutoria. O material didático, incluindo suas
videoaulas, foi projetado para que você consiga evoluir de forma autônoma e suficiente.
Caso opte por imprimir este e-book, você não perderá a possiblidade de acessar os
materiais multimídia e complementares. Os links podem ser acessados usando o seu celular,
por meio do glossário de Códigos QR disponível no fim deste livro.
Embora o material passe por revisão, somos gratos em receber suas sugestões para
possíveis correções (erros ortográficos, conceituais, links inativos etc.). A sua participação é
muito importante para a nossa constante melhoria. Acesse, a qualquer momento, o
Formulário “Sugestões para Correção do Material Didático” clicando nesse link ou
acessando o QR Code a seguir:
Para saber mais sobre a Plataforma +IFMG acesse
https://mais.ifmg.edu.br
Formulário de
Sugestões
http://forms.gle/b873EGYtkvK99Vaw7
https://mais.ifmg.edu.br/
Palavra do autor
Prezado estudante, bem-vindo ao curso “Programador Java: Nível Básico”!
A linguagem Java acabou de completar 25 anos desde que foi apresentada pela Sun
Microsystems em maio de 1995. De o seu lançamento até hoje, ela desperta interesse de
milhares de desenvolvedores. O Java permaneceu, em 2020, entre as três principais
linguagens de programação de acordo com os índices mais importantes: Tiobe (TIOBE,
2020), RedMonk (REDMONK, 2020) e PyPL (PYPL, 2020). Em cinco anos esteve em
primeiro lugar nas estatísticas do Tiobe. Apenas em 2020 foi ultrapassada pela linguagem
C devido o amplo uso de C em equipamentos médicos e à urgência da pandemia do COVID-
19 (INFOWORLD, 2020).
Java é largamente empregada no desenvolvimento de aplicações cliente/servidor
para ambiente Web. É base no desenvolvimento Android para a criação de aplicativos e é
utilizada no desenvolvimento de aplicações para desktop e para sistemas embarcados. A
popularidade da linguagem é confirmada pela alta requisição de profissionais. Numa busca
pelo termo “vagas java”, no Google, ou por “Java”, no Indeed, são retornados mais de 1000
postos em aberto no país.
Este Curso tem o propósito de apresentar a você a sintaxe básica da linguagem Java,
plataforma Java SE. Trata-se de uma iniciação à programação em Java anterior à
abordagem orientada a objetos, própria da linguagem. O curso também serve de conteúdo
em lógica de programação de computadores para iniciantes na área. A abordagem inclui os
comandos básicos para controle de fluxo, as estruturas de dados indexadas, uma introdução
à decomposição funcional e breve antecipação dos conceitos de classe e objeto.
A divisão em módulos e sua realização em quatro semanas demandarão tempo para
estudos e prática. Persistência e dedicação são características imprescindíveis para o
desenvolvimento desse perfil profissional. Lembre-se disso, faça todas as atividades
propostas e a cada conteúdo novo, copie, altere, compile e execute os trechos de código
exemplificados. Afinal “programar só se aprende programando”.
Bons estudos!
A autora.
Bons estudos!
Nome do autor.
Apresentação do curso
Este curso está dividido em quatro semanas, cujos objetivos de cada uma são apresentados,
sucintamente, a seguir.
SEMANA 1
Introdução à linguagem Java: conceitos e plataforma. Estrutura de
um programa em Java. Tipos de dados primitivos, declaração de
variáveis e constantes e entrada/saída para console.
SEMANA 2
Operadores aritméticos e suas precedências. Operadores
relacionais e lógicos e o comando de decisão (if simples e
composto). Seleção entre múltiplas escolhas usando if encadeado e
switch.
SEMANA 3
Laços de repetição determinados e indeterminados usando os
comandos: while, do-while e for. Variáveis indexadas (vetores):
sintaxe e manipulação.
SEMANA 4
Definindo funções e procedimentos em métodos estáticos Java.
Treinando sintaxe Java em aplicações com interface gráfica
(javax.swing). Introdução aos conceitos e à sintaxe para definição de
classes e objetos.
Carga horária: 40 horas.
Estudo proposto: 2h por dia em cinco dias por semana (10 horas semanais).
Apresentação dos Ícones
Os ícones são elementos gráficos para facilitar os estudos, fique atento quando eles
aparecem no texto. Veja aqui o seu significado:
Atenção: indica pontos de maior importância no texto.
Dica do professor: novas informações ou curiosidades
relacionadas ao tema em estudo.
Atividade: sugestão de tarefas e atividades para o
desenvolvimento da aprendizagem.
Mídia digital: sugestão de recursos audiovisuais para
enriquecer a aprendizagem.
Sumário
Semana 1 – Introdução à linguagem Java ..........................................................................15
1.1. Linguagem e Plataforma Java ................................................................................15
1.1.1. Bytecodes e o Ambiente de Execução ...................................................................17
1.2. Introdução à Programação em Java .......................................................................20
1.2.1. Palavras-chave, identificadores, comentários e convenções .................................22
1.2.2. Variáveis, constantes e tipos primitivos ..................................................................25
1.2.3. Entrada e Saída padrão .........................................................................................33
1.2.4. Pratique ..................................................................................................................36
Semana 2 – Instruções de sequência ................................................................................392.1. Operadores de atribuição, aritméticos e suas precedências ..................................39
2.1.1. Outras funções matemáticas e a linearização de expressões aritméticas .............43
2.1.2. Exercícios resolvidos ..............................................................................................45
2.1.3. Pratique ..................................................................................................................47
2.2. Controlando o fluxo de execução ...........................................................................48
2.2.1. Operadores relacionais e lógicos ...........................................................................48
2.2.2. Exercícios resolvidos ..............................................................................................52
2.2.3. Pratique ..................................................................................................................52
2.2.4. O comando IF simples ............................................................................................53
2.2.5. Exercícios resolvidos ..............................................................................................54
2.2.6. Pratique ..................................................................................................................55
2.2.7. IF composto ............................................................................................................55
2.2.8. Exercícios resolvidos ..............................................................................................57
2.2.9. Pratique ..................................................................................................................58
2.3 Comando de decisão: IF’s encadeados .................................................................59
2.4 Comando de seleção: switch ..................................................................................63
2.5 Exercícios resolvidos ..............................................................................................66
2.6 Pratique ..................................................................................................................67
Semana 3 – Laços de repetição e Vetores ..........................................................................69
3.1 Laços de repetição .................................................................................................69
3.1.1 O comando while ....................................................................................................70
3.1.2 O comando do..while ..............................................................................................73
3.1.3 Break e continue.....................................................................................................75
file:///C:/Users/niltom.vieira/Downloads/(EBook+IFMG)%20-%20Programador%20Java%20nivel%20básico%20-.docx%23_Toc84427464
file:///C:/Users/niltom.vieira/Downloads/(EBook+IFMG)%20-%20Programador%20Java%20nivel%20básico%20-.docx%23_Toc84427473
file:///C:/Users/niltom.vieira/Downloads/(EBook+IFMG)%20-%20Programador%20Java%20nivel%20básico%20-.docx%23_Toc84427497
3.1.4 Laços com o comando For .....................................................................................77
3.2 Exercícios resolvidos ..............................................................................................79
3.3 Pratique ..................................................................................................................82
3.4 Estruturas de dados indexadas: vetores ................................................................84
3.5 Exercícios resolvidos ..............................................................................................88
3.6 Pratique ..................................................................................................................92
Semana 4 – Modularização: uma introdução ......................................................................93
4.1 Evolução da programação ......................................................................................93
4.2 Sub-rotinas e os desvios no fluxo de execução .....................................................94
4.3 Procedimentos e funções em métodos estáticos ...................................................97
4.4 Exercícios resolvidos ............................................................................................101
4.5 Pratique ................................................................................................................103
4.6 POO, classes e objetos ........................................................................................105
4.7 Pratique ................................................................................................................109
Referências .......................................................................................................................111
Apêndice I – Manuais de instalação ..................................................................................113
Introdução ..........................................................................................................................113
Instalando o Oracle JDK 8 no Windows ............................................................................114
Instalando o OpenJDK 8 no Windows ...............................................................................117
Instalando o Apache NetBeans no Windows .....................................................................123
Instalando o OpenJDK 8 no Linux Ubuntu.........................................................................125
Instalando o Apache NetBeans no Linux Ubuntu ..............................................................127
Apêndice II – Tutorial rápido do NetBeans ........................................................................129
Criando um projeto Java....................................................................................................129
Inserindo Classes a um projeto .........................................................................................131
Executando um programa no NetBeans ............................................................................132
Currículo do autor ..............................................................................................................135
Glossário de códigos QR (Quick Response) .....................................................................137
file:///C:/Users/niltom.vieira/Downloads/(EBook+IFMG)%20-%20Programador%20Java%20nivel%20básico%20-.docx%23_Toc84427510
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
15
Mídia digital: assista ao vídeo “Aula 1 - Apresentação do
Curso”.
1.1. Linguagem e Plataforma Java
A linguagem Java acaba de completar 25 anos desde que foi apresentada pela Sun
Microsystems em 23 de maio de 1995. O projeto foi liderado pela equipe de James Gosling
com a linguagem originalmente batizada de “Oak”1, posteriormente Java, em alusão ao Java
Coffee, o café da ilha de Java na Indonésia.
A linguagem teve concepção baseada no paradigma orientado a objetos,
caracterizada pela simplicidade com sintaxe baseada na linguagem C. Desde o início
possuía recursos de programação voltados para o acesso à rede e ambientes distribuídos,
sendo independente de arquitetura e portável, oferecendo robustez e segurança na
execução dos códigos. Já naquela época o projeto foi norteado pela motivação de viabilizar
uma espécie de “Internet das coisas” uma vez que a equipe buscava uma linguagem para a
criação de softwares para serem embutidos aos dispositivos eletrônicos dos consumidores,
como fornos micro-ondas e controles remotos. A intenção inicial mostrou-se um pouco à
frente daquele tempo. Felizmente a linguagem seriacompletamente apropriada ao ambiente
Web2 da Internet que estava surgindo naquele momento.
Lembre-se, a Internet é frequentada por vários tipos de computadores equipados com
diferentes arquiteturas de CPU3 onde executam diferentes sistemas operacionais. A
linguagem Java foi assim impulsionada para a dianteira porque a Web dependia de
programas para deixá-la mais dinâmica, e esses programas precisavam ser portáveis.
1 Oak, do Inglês, significa ‘carvalho’. O nome é homenagem à árvore visualizada da janela do escritório de Gosling.
2 World Wide Web (WWW), conhecida como Web, é um sistema de informação onde documentos e outros recursos
identificados por um Uniform Resource Locators (URLs, como https://www.ifmg.edu.br) podem ser interligados por
hipertexto e estão acessíveis pela Internet.
3 CPU sigla, do Inglês, para Central Processing Unit ou unidade central de processamento (processador).
Objetivos
Introdução à linguagem Java: conceitos e plataforma.
Estrutura de um programa em Java. Tipos de dados primitivos,
declaração de variáveis e constantes e entrada/saída para
console.
Semana 1 – Introdução à linguagem Java
Semana 1 – Introdução à linguagem Java
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
16
Atenção: cada termo novo em negrito é um conceito
importante da tecnologia Java. Busque compreender cada
um, relendo o texto. Se necessário faça uma busca Google
usando: definir <termoDeBusca>
Java herdou sua sintaxe da linguagem C e seu modelo de objetos foi adaptado do
C++. Foi concebida para simplificar a aprendizagem ‘sem reinventar a roda’ para o
programador da época. Seu projeto de portabilidade era uma das principais vantagens. A
maioria das linguagens de computador existentes era projetada para ser compilada para o
código de máquina de um tipo específico de plataforma de hardware-software4. Embora
fosse possível compilar um programa C/C++ para executar em qualquer dispositivo era
necessário contar com um programa de tradução específico para aquela plataforma. Esse
programa é chamado de compilador. Um compilador é responsável por converter o código
fonte do programa, em formato textual, escrito pelo programador, em código objeto
executável pela máquina (formato numérico binário). A construção de um programa tradutor
desse tipo é cara e demorada. Deveria haver um compilador para cada plataforma de
hardware/software (arquitetura de CPU + sistema operacional) algo inviável para o ambiente
da Internet. A solução foi um ambiente híbrido composto de compilação e interpretação,
descrito na próxima seção.
A linguagem disponibiliza aos desenvolvedores um conjunto de ferramentas de
desenvolvimento conhecido como kit de desenvolvimento Java (JDK5). O JDK inclui o
compilador Java (javac), o executor de programas (java), o gerador de documentação de
classes (javadoc), entre outros aplicativos. Essas ferramentas são utilizadas, inclusive, pelos
ambientes de desenvolvimento (IDE6) Java voltados para melhorar a produtividade no
trabalho de programar.
Java, enquanto tecnologia, além de linguagem é também uma plataforma. Plataforma
de software à medida que incorpora todo o ambiente de execução de programas. O ambiente
de tempo de execução, denominado de JRE7, inclui o interpretador de bytecodes (vide seção
1.2) conhecido como máquina virtual Java (JVM8) e um conjunto padrão de bibliotecas de
classes (API9). A JVM que interpreta e executa aplicações Java é especializada ao ambiente
de hardware/software do computador do usuário. A API Java é uma coleção de componentes
de software (classes, interfaces, etc.) úteis para se criar outros programas em Java.
4 Inclui o hardware (a CPU) que oferece uma linguagem de máquina e o software do sistema operacional que provê rotinas
de baixo nível chamadas por um programa aplicativo.
5 JDK da sigla, em Inglês, para Java Development Kit.
6 IDE da sigla, em Inglês, para Integrated Development Environment. São softwares que oferecem uma gama de recursos
para facilitar o desenvolvimento de programas.
7 JRE da sigla, em Inglês, para Java Runtime Environment ou ambiente de execução Java.
8 JVM da sigla, em Inglês, para Java Virtual Machine. A máquina virtual Java é responsável pela interpretação e execução
de bytecodes Java.
9 API da sigla, Application Programming Interface. A API do Java SE 8, por exemplo, pode ser acessada através do endereço
https://docs.oracle.com/javase/8/docs/api/.
https://docs.oracle.com/javase/8/docs/api/
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
17
Com o advento do Java 2, lançado em dezembro de 1998, as novas versões do Java
foram divididas em três plataformas:
A J2SE, hoje Java SE (Java Plataform, Standard Edition): é a plataforma base voltada
para desenvolvimento desktop, incluindo alguns recursos de servidor. Fornece a
funcionalidade central da linguagem e define tudo, desde os tipos e objetos básicos
até classes de alto nível usadas para rede, segurança, acesso a banco de dados,
desenvolvimento de interface gráfica com o usuário (GUI) e análise XML.
A J2EE, hoje o Java EE (Java Plataform, Enterprise Edition): é baseada na Java SE
mas incluiu especificações e API adicional voltada para aplicações corporativas,
comumente executadas em ambiente de servidor, multicamadas com base na Web.
A J2ME, hoje Java ME (Java Plataform, Micro Edition): é um subconjunto da API
Java SE adicionada de bibliotecas específicas para o desenvolvimento de aplicativos
para dispositivos com recursos limitados, como telefones celulares, PDAs, TV’s, set-
up-boxes, etc.
Observe que a mesma linguagem é utilizada para o desenvolvimento,
independentemente da plataforma ser SE, EE ou ME. Cabe esclarecer que, sendo o foco
deste curso uma iniciação à programação, a plataforma Java SE é a mais apropriada, sendo
pois a que utilizaremos neste curso.
Posteriormente, ainda sob o controle da Sun, a tecnologia ganhou mais uma
plataforma: a JavaFX. Esta nova plataforma estende tanto a Java SE quanto a Java ME com
capacidades de construção de aplicações avançados para a Internet. Os aplicativos JavaFX
usam mecanismos de mídia e gráficos acelerados por hardware para aproveitar as
vantagens de clientes de alto desempenho e uma aparência moderna. Os aplicativos JavaFX
podem ser clientes dos serviços da plataforma Java EE.
Após aquisição da Sun pela Oracle, em 2010, a linguagem passou a ter nova política
de atualizações. A partir da versão Java SE 9, lançada em 2017, novas versões terão
lançamento a cada seis meses. Dessas, uma em cada três oferecerá suporte LTS10, assim
essas versões serão lançadas de três em três anos. É recomendável trabalhar sempre com
versões LTS no desenvolvimento Java. Essa política de gerenciamento de produto visa
manter uma versão estável por um período maior do que as demais versões de atualização
da linguagem.
1.1.1. Bytecodes e o Ambiente de Execução
A portabilidade do Java é baseada em um processo híbrido de compilação e
interpretação. O código fonte, ou seja, o programa produzido pelo programador é um arquivo
texto com extensão .java, como o exibido na Figura 1. O código fonte é uma coleção de
sentenças que obedecem à sintaxe da linguagem e que descrevem o algoritmo que será
10 LTS da sigla, em Inglês, para long term support.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
18
executado. O conceito de algoritmo está relacionado ao passo-a-passo que define como
será o processamento ou a transformação dos dados de entrada (input) em informação útil
para saída (output). Todo programa representa um algoritmo a ser seguido pelo computador.
Observe que os arquivos fonte de programas estãoem formato de texto. Esse formato
não é inteligível pelo computador. Computadores apenas lidam com números,
especificamente, números de base 2, ou base binária11. A CPU ou o processador é o
componente do computador capaz de executar um conjunto reduzido de instruções
numéricas (em binário) ou instruções de máquina. Ao conjunto dessas instruções chamamos
de linguagem de máquina. Embora as linguagens de máquina sejam similares é
interessante notar que cada arquitetura de CPU possui sua linguagem de máquina própria.
Entenda arquitetura de CPU como uma espécie de modelo de CPU, como, p. ex., as CPU
construídas segundo a arquitetura X86 da Intel.
Figura 1 – Um exemplo de programa Java, um arquivo de código fonte (Teste.java)
Fonte: Elaborado pela autora
Portanto, para que um programa Java seja executado por qualquer computador, ele
precisa ser traduzido o código de máquina da CPU desse computador. Em Java essa
tradução é feita em duas etapas. A primeira delas fica a cargo do programador que deve
compilar o programa utilizando as ferramentas do JDK (javac12), ou através do seus próprio
ambiente de desenvolvimento (uma IDE como o NetBeans, por exemplo).
11 Diferente da base decimal que emprega os dígitos de 0 à 9, a representação de números na base binária ou base 2
apenas utiliza os dígitos 0 e 1.
12 O javac é a ferramenta de compilação da linguagem Java disponível no JDK.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
19
Figura 2 – Ambiente de programação (à esquerda) e execução do programa Java pelo usuário (à direita).
Fonte: Elaborado pela autora
Durante a compilação é feita a verificação da sintaxe do código fonte. Se a sintaxe do
programa estiver 100% correta, o compilador irá gerar um arquivo de instruções em um
formato que foi denominado de bytecode. Um arquivo de bytecodes tem extensão .class.
Esta tradução da compilação é ilustrada na Figura 2, no quadro à esquerda.
É interessante notar que as instruções em bytecode são muito próximas das
instruções de CPU’s de máquina reais, de modo que traduzir um programa de bytecodes
para código de máquina se torne um processo rápido e fácil. Aqui está o “pulo do gato” da
portabilidade de James Gosling: a criação da linguagem de máquina virtual para o Java, o
bytecode.
A segunda etapa do processo de tradução é ilustrada na Figura 2, quadro da direita.
Essa etapa ocorrerá sempre que um programa Java for solicitado para execução no
computador do usuário. Observe que este computador poderá estar situado em qualquer
lugar da Internet. Mais ainda, o dispositivo do usuário será equipado de alguma arquitetura
de CPU (e, portanto, linguagem de máquina) possivelmente diversa daquela em que o
programa foi compilado.
Nesse momento, entra em cena o ambiente Java de execução, o JRE. O JRE inclui
a JVM, a máquina virtual Java, que é responsável por verificar, interpretar e executar cada
instrução em bytecode no arquivo .class ao traduzí-la em instrução real, conforme a máquina
do usuário. Observe que aqui as instruções em bytecode serão interpretadas (traduzidas)
para instruções de máquina nativa, ou seja, para instruções na linguagem de máquina do
computador do usuário. A segurança desse processo é devida à verificação de bytecodes e
a uma execução protegida, tarefas realizadas pela JVM. Veja que a JVM é um programa (ou
software) que, por definir uma linguagem e realizar sua interpretação, é equivalente a uma
máquina real. Agora você é capaz de entender porque dizemos “máquina virtual”.
Embora, a princípio, códigos interpretados executavam mais lentamente, o processo
de interpretação do Java foi altamente otimizado. A JVM passou ser equipada com
compiladores JIT (just-in-time) que empregam técnicas de compilação dinâmica de bytecode
para código de máquina, visando a melhoria do desempenho. Isso permite uma performance
de execução comparável aquela de códigos compilados de linguagens como C/C++.
Atividade: para fixar os conceitos, vá até a sala virtual e
realize a atividade “Sobre a tecnologia Java”.
Mídia digital: assista ao video “Aula 2 - Um Hello World em
Java” disponível na 1º semana do curso.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
20
1.2. Introdução à Programação em Java
Dica do professor: consulte o “Apêndice I – Manuais
de Instalações” para fazer a instalação das
ferramentas de desenvolvimento adotadas no curso:
JDK e NetBeans. Elas serão usadas nesta seção.
Como Java é uma linguagem que segue o paradigma de programação orientada a
objetos (POO), programas em Java são estruturados em unidades de código que
chamamos de classe. Os conceitos de classe e objeto serão introduzidos na última semana
deste curso. Por agora, lembre-se que o código de um programa Java poderá estar inserido
dentro de uma ou mais classes. Os comandos Java dentro de uma classe são escritos em
sub-rotinas que chamamos de métodos. Cada método define uma pequena porção do
processamento da classe, ou seja, é uma operação, um subalgoritmo. Um método só será
executado quando receber uma chamada ou invocação. Métodos podem ser invocados pelo
próprio programa ou pela JVM.
Atenção: alguns trechos de código podem parecer
complicados, a princípio. Java é uma linguagem
orientada a objetos e esse paradigma envolve
conceitos além do escopo deste programa. Isso não
impedirá que você atinja seus objetivos no curso.
Dentre as classes do seu código, ao menos uma delas, deve ser a classe principal.
Uma classe principal é aquela que inclui o método main e este é o método invocado pela
JVM! Isso ocorre para que a JVM, que está por trás da execução de todo programa Java,
saiba de onde iniciar a execução do programa. Por esse motivo a assinatura (ou primeira
linha) do método main deve ser rigorosamente escrita como é exibido na Figura 3.
Escrevemos código Java em arquivos com extensão .java. Cada arquivo fonte (.java)
pode incluir uma ou mais classes mas, no máximo uma delas poderá ser classe a pública (
public) do arquivo. Se um arquivo incluir uma classe pública ele deve ser nomeado,
obrigatoriamente, com o nome da única classe pública nele definida (vide arquivo
HelloWord.java da Figura 4).
Observe que a sintaxe de métodos em Java inclui, nesta ordem: modificador de
acesso, escopo (de classe ou de objeto), tipo de retorno (ou void, para ausência de
retorno), nome do método e uma lista de definição de parâmetros entre parênteses.
Um detalhe que não pode ser esquecido é que a linguagem Java é case-sensitive.
Isso significa que o compilador irá fazer distinção entre letras maiúsculas e minúsculas.
Assim o identificador ‘main’ é diferente de ‘Main’, ou de ‘mAin’, por exemplo.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
21
Figura 3 – Sintaxe de métodos em Java. Assinatura do método ‘main’
Fonte: Elaborado pela autora
Vamos entender a estrutura de uma classe Java? Para isso inicie o NetBeans. Crie
um novo projeto chamado ‘helloworld’ e digite o código da classe ‘HelloWorld.java’ da Figura
4.
Dica do Professor: vá para o “Apêndice II –
Tutorial rápido do NetBeans” e siga as instruções
para criar um projeto Java.
Agora podemos executar o programa. No NetBeans, pressione o botão para salvar.
Observe que o código da classe HelloWorld é automaticamente compilado. Essa opção de
compilação automática é uma configuração padrão do NetBeans e pode ser alterada. Em
seguida, execute o projeto. Este programa é muito simples, apenas enviará para a saída, no
console, a frase “Alô mundo!” (Figura 5).
Figura 4 – Estrutura de uma classe Java
Fonte: Elaborado pela autora
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
22
Figura 5 – Compilação sem erros e resultadoda execução de HelloWord
Fonte: Elaborado pela autora
1.2.1. Palavras-chave, identificadores, comentários e convenções
Observe as considerações sobre sintaxe e escrita de código a seguir. Elas serão úteis
daqui em diante.
Palavras-chave são palavras reservadas que possuem significado específico para o
compilador. Você já viu algumas delas no código da classe HelloWorld acima: class, public,
void. O Quadro 1, a seguir, exibe outras palavras-chave do Java. Não é necessário decorá-
las. Elas serão naturalmente memorizadas a partir da sua prática.
Quadro 1 – Palavras reservadas da linguagem Java
Fonte: Elaborado pela autora
Existem regras para nomes ou identificadores em Java. Identificadores são usados
para nomear classes, métodos, variáveis, constantes, atributos, etc. definidos pelo
programador. Isso é necessário para que o compilador identifique corretamente esses
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
23
elementos no código e os diferencie das palavras reservadas da linguagem. No Quadro 2
são exibidos alguns exemplos e contraexemplos de identificadores. É importante observar
que, embora permitidos, caracteres acentuados (é, ó, ç, etc.) devem ser evitados em nomes
de identificadores.
Quadro 2 – Regras para nomear identificadores em Java
Fonte: elaborado pela Autora.
Comentários de código servem para inserir texto, no meio do programa, com o
objetivo de explicar trechos de códigos, de classes, de métodos, etc. Comentários são
desconsiderados pelo compilador e são importantes para documentar programas
complexos. Lembre-se que nem sempre o programador que escreveu o programa será
aquele que fará modificações futuras nele. Comentar código faz parte das boas práticas de
programação. O Quadro 3 exibe os tipos de comentário do Java.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
24
Quadro 3 – Tipos de comentário em Java
Fonte: Elaborado pela autora
Convenções de codificação são maneiras de escrever código e estão relacionadas
também a boas práticas. Os programadores de uma linguagem seguem suas convenções
para produzir códigos legíveis, limpos. As convenções ajudam na manutenção dos
programas uma vez que agilizam sua leitura. Essa percepção é clara quando trabalhamos
com POO. Como exemplo, ao encontrar a sentença CaixaEletronico.reiniciar() um
programador Java com segurança poderá concluir que se trata de chamada ao método
estático reiniciar da classe CaixaEletronico. Sem seguir uma convenção esse tipo de
conclusão não seria possível o que dificultaria a leitura e a manutenção do programa. O
Quadro 4 exibe as convenções de codificação mais comuns do Java.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
25
Quadro 4 – Convenções de codificação em Java
Fonte: Elaborado pela autora
Mídia digital: Assista ao vídeo “Aula 3 -
Variáveis/Constantes”, disponível na 1º semana do
curso.
Atividade: Estude as duas subseções seguintes. Em
seguida, resolva os primeiros exercícios propostos deste
livro.
1.2.2. Variáveis, constantes e tipos primitivos
Para que o computador transforme dados em informação13 útil ao usuário, três etapas
são necessárias (Figura 6). Primeiramente, o computador deve ser equipado de maneira
que os dados para o processamento sejam transmitidos ao programa. Os dispositivos de
entrada de dados acoplados ao computador fazem esse papel. Teclados, câmeras de vídeo,
mouse, microfone e scanner, por exemplo, permitem que a informação externa ao sistema14
seja traduzida em informação numérica (digital). Quando pressionamos uma tecla no
teclado, por exemplo, um código associado à tecla é convertido em sinal digital e informado
ao programa em execução. Para que esses dados de fontes externas (input) sejam
manipulados pelo programa devem ser armazenados temporariamente na memória
13 Aqui pretende-se intuir uma pequena distinção entre dados (brutos, sem significado) e informação (dados rotulados,
com significado) para uso humano. Em outros pontos do texto, dados e informações serão usados como sinônimos.
14 Entenda sistema como sistema computacional.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
26
principal15 do computador. A próxima etapa é processar esses dados para produzir a saída
do algoritmo. Cálculos, classificações, conversões e outras operações de transformação
fazem parte do processamento durante a execução do programa. Por último, as informações
produzidas pelo processamento, também manipuladas em memória, são preparadas para
envio aos dispositivos de saída (output). Monitores, impressoras, redes de comunicação,
etc., são exemplos de aparato tecnológico que comunicam as informações geradas pelo
processamento ao ambiente externo (externo ao programa).
Figura 6 – Esquema básico da computação: entrada-processamento-saída
Fonte: Elaborado pela autora
Suponha que você fará um programa para calcular o consumo médio de combustível
de um veículo durante uma viagem. Para isso, a distância total, em km, percorrida e a
quantidade de combustível, em litros, consumida na viagem são dados de entrada que
devem ser informados por fontes externas ao programa. Vamos supor que sejam informados
pelo usuário do programa quando este estiver executando. A Figura 7 apresenta as entradas
e a saída. Observe que o programa deve receber esses dois dados como entrada (input) a
fim de realizar o processamento exigido. O processamento é feito através de um cálculo
simples: distância percorrida dividida pela quantidade de combustível. Um bom rótulo que
poderíamos dar ao resultado deste processamento seria ‘consumo médio’ ou ‘consumo na
viagem: <xxxx> km/litro’. Este resultado uma vez gerado poderá ser informado ao usuário
através de uma mensagem no monitor. É esta informação preparada pelo programa que
denominados saída, ou output, do algoritmo16. Nenhum programa seria útil se não
produzisse saída, seja ao monitor, impressora, rede, ou para outro programa, como um
sistema de banco de dados, por exemplo.
15 Refere-se à memória principal (volátil) dos computadores pentes de DRAM ou caches (tipo SRAM), e à memória
secundária (permanente) os dispositivos como HD, pen-drive (memórias flash), etc.
16 Um programa é um algoritmo, ou seja, uma sequência de instruções a serem seguidas pelo computador. O conceito de
algoritmo é atribuído à área de programação de computadores mas sua origem remonta à Matemática. Algoritmo é uma
sequência de passos ou de ações que se executadas resultam no objetivo esperado.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
27
Figura 7 – Entradas e saída do programa “Eficiência de combustível“
Fonte: Elaborado pela autora
Observe a representação deste algoritmo no fluxograma da Figura 8, a seguir. Há um
símbolo específico para definir onde o algoritmo inicia e onde termina, esse é o símbolo de
terminal. Para descrever os dados de entrada é usado um trapézio (observe as entradas
‘distancia’ e ‘litros’). O processamento é descrito dentro do retângulo e a saída é informada
num símbolo que lembra o formato de um monitor antigo. Dentro de cada um desses
símbolos são descritos quais dados são entrada, qual é o processamento executado e qual
é a informação de saída gerada pelo algoritmo, respectivamente. Veja que a informação de
saída deve ser trabalhada para apresentação ao usuário. Supondo que o valor do consumo
médio calculado seja igual a 12.00 o programa representado no fluxograma irá apresentará
ao usuário a mensagem: “Consumo na viagem: 12.00 km/litro”.
Figura 8 – Fluxograma do algoritmo “eficiência de combustível”
Fonte: Elaborado pela autoraPlataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
28
Podemos agora definir o conceito de variável. Chamamos de variável a abstração17
para um local (endereço) na memória que armazena um dado manipulado pelo programa.
Todo dado envolvido no processamento será manipulado pelo programa como uma variável.
As variáveis são armazenadas temporariamente na memória principal (volátil) do
computador18. Variáveis podem se referir tanto a dados de entrada (inputs) quanto a dados
de apoio ao processamento (para cálculo do output). Variáveis possuem três aspectos
fundamentais (vide Figura 9): nome, tipo de dados e conteúdo.
O nome é um identificador para a variável que segue as regras de identificadores vistas
na seção 1.4. O nome da variável é como um rótulo para o local na memória do computador
onde ela está armazenada.
O segundo aspecto é o tipo. Toda variável deve ser de um determinado tipo de dados.
Um tipo de dados define tanto o formato (numérico, caractere, cadeia de caracteres, etc.)
quanto o comprimento em bytes19 gasto para guardar a variável na memória do
computador.
Quanto mais dígitos binários, isto é, bits/bytes disponíveis para um tipo de dados, maior
será a faixa de valores que a variável poderá assumir. Para sua compreensão, veja que se
consideramos tipos de dados numéricos, p. ex., com três dígitos decimais, poderemos
representamos valores não negativos de 0 até 999. Da mesma maneira, com três dígitos
binários seria possível armazenar números não negativos de 0 a 7. Lembre-se que para um
programa pensamos em dados na memória ocupando conjuntos de 8 dígitos binários (bits),
ou seja, pensamos na largura em bytes.
O terceiro aspecto sobre as variáveis é o seu conteúdo. O conteúdo de uma variável,
em determinado instante da execução de um programa será um valor dentro da faixa de
valores permitida pelo tipo de dados para ela definido.
17 As linguagens de alto nível, como Java, C/C++, Python, etc., abstraem do programador as dificuldades de se manipular
diretamente o hardware. A declaração de uma variável no programa é suficiente para se referir a um dado armazenado em
algum endereço na memória primária do computador.
18 A memória principal do computador inclui a dos pentes de DRAM e as memórias cache de CPU (SDRAM). São
tecnologias de armazenamento volátil que operam em velocidades mais compatíveis àquela dos processadores,
diferentemente das memórias secundárias, de armazenamento permanente, que embora grandes são lentas.
19 Byte é um conjunto de 8 dígitos binários, ou bits. Um bit é a menor unidade de informação digital. Um bit armazena um
dígito 0 ou um dígito 1, na base binária.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
29
Figura 9 – Toda variável possui nome, tipo de dados e conteúdo
Fonte: Elaborado pela autora
É importante lembrar que há tipos de dados compostos e tipos de dados simples.
Neste curso iremos trabalhar muito com os tipos de dados simples da linguagem Java: os
tipos de dados primitivos. O Quadro 5 enumera os tipos primitivos e respectivas faixas de
valores para representação dos dados.
Um conceito muito próximo ao de variável é o de uma constante. Da mesma maneira
que variáveis, constantes devem ser definidas com um tipo de dados e um identificador
(nome). Uma constante nada mais é que uma ‘variável’ que só pode assumir um único valor
do início ao fim do programa. Em oposição, o conteúdo de uma variável sofrerá alterações
durante a execução do programa.
Quadro 5 – Tipos primitivos da linguagem Java e faixa de valores permitidos
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Para elaborar um programa é preciso primeiro, compreender perfeitamente qual é o
problema a ser resolvido. Só assim é possível elaborar uma solução para o mesmo. Em
seguida, vem a etapa mais difícil: codificar uma solução em formato de programa, isso é,
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
30
uma solução computacional para o problema. É evidente que para os iniciantes este é o
maior desafio. Dizemos que aqui há um abismo a ser superado. Veja que a solução do
problema, uma vez compreendida num esboço ‘manual’, ou através de uma planilha de
cálculos deve ser descrita em instruções de linguagem de computador.
Uma abordagem inicial para superar esse desafio é começar com a seguinte
pergunta: “Quais dados serão manipulados? Isto é, quais serão as variáveis necessárias
para o programa e quais devem ser seus tipos de dados?” Para responder esta pergunta
busque identificar os elementos de dados que o programa precisará manipular a fim de gerar
a saída esperada. No caso do nosso exemplo da eficiência de combustível os dados serão:
a distância percorrida, o combustível gasto e o consumo médio que deve ser calculado.
Seguindo as regras para identificadores da seção 1.4, dê nomes válidos e sugestivos para
as variáveis. Por exemplo: distancia, qtdeCombustivel, consumoMedio.
Em seguida é preciso definir seus tipos de dados. Vamos conhecer os tipos de dados
primitivos da linguagem Java. Observe no Quadro 5 os tipos primitivos, suas as larguras em
bits/bytes e respectivas faixas de valores permitidos.
Observe que há tipos para números inteiros (byte, short, int e long) e para números
reais, que podem incluir parte fracionária. Em programação esses tipos são chamados de
ponto flutuante: float e double.
Os tipos em ponto flutuante são representados internamente em notação científica,
portanto podem ser usados para armazenar tanto números reais, quanto números inteiros.
No entanto, veja que nem mesmo é possível representar em ponto flutuante todos os
números entre 0 e 1. É preciso observar que os tipos float e double armazenam um número
finito de dígitos após o ponto decimal. A quantidade de dígitos significativos define uma
precisão finita para números representados em ponto flutuante, como indicado no Quadro
5. Então, lembre-se que todo número real, inteiro ou fracionário, pode ser escrito usando
notação científica. Veja esses exemplos: o inteiro 1200 pode ser escrito como 1.2x103 (ou
1.2E+3); o número fracionário 0.1234993 em notação científica pode ser escrito como
1.234993E-01 (ou 1.234993 x 10-1).
É importante dizer que dos dois tipos para ponto flutuante, o tipo double é o mais
usado. Todas as funções matemáticas da biblioteca Java (a classe Math) retornam valores
do tipo double (vide seção 1.6)
Outra questão é que a definição de tipo para uma variável deve ser contextualizada
segundo o problema tratado. Se o deslocamento é referente a uma aeronave que vai da
Terra até Plutão, p. ex., o consumo ou a distância percorrida assumiriam valores
astronômicos demais que não caberiam na faixa de valores armazenáveis por uma variável
do tipo int, por exemplo. Aliás para uma representação exata da distância incluindo possíveis
frações de quilômetros dentre os tipos primitivos sobrariam duas opções: float ou double.
Veja que a distância estimada é de cerca de 5 bilhões de quilômetros, então, se
considerarmos armazenar esta variável em ponto flutuante a precisão oferecida pelo tipo
float pode não ser suficiente. A opção nesse caso deverá ser o tipo double. Na dúvida sobre
o crescimento dos dados a escolha deve recair sobre o tipo de dado que oferece a maior
faixa de valores.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
31
Você deve estar se perguntando, “como se faz para representar uma frase, isto é,
uma cadeia de caracteres em um programa?”
A resposta é que, embora o Java não ofereça um tipo primitivo para cadeias, a
linguagem oferece a classe String. A boa notícia é que declaramos variáveis de tipo String
da mesma forma que variáveis de tipos primitivos. Nesse momento é bom ilustraro fato de
que as duas grandes categorias de tipos de dados em Java são: os tipos primitivos e os tipos
que são classes. Neste curso conheceremos além da classe String algumas outras comuns
e úteis para programar, todas elas da biblioteca de programação: a API do Java SE.
Não podemos esquecer dos tipos char e boolean. O tipo char representa um
caractere alfanumérico da tabela Unicode. A tabela Unicode permite a representação de
basicamente todos os caracteres de todos os alfabetos do globo. Já o tipo boolean serve
para armazenar duas possibilidades de valores: true ou false. Variáveis booleanas são úteis
para dados que permitem valores binários do tipo sim ou não, falso ou verdadeiro, ligado ou
desligado, etc.
O último passo dessa seção é apresentar a sintaxe Java para definição de variáveis:
Atenção: toda sentença em Java deve ser finalizada
com um sinal de ponto-e-vírgula ;
A sintaxe para constantes é análoga:
O código a seguir define as variáveis do problema da eficiência de combustível. Como
esses dados são valores que podem ter parte fracionária, serão definidos como sendo do
<tipo> <declaracao
1
>,..., <declaracao
n
>;
Onde <tipo> é o tipo de dados das variáveis que, para mais de uma, virão
separadas por vírgula
O <tipo> precede a <declaracao
i
> que consiste em:
• <variavel> [= <inicialização>]
Onde <variavel> é um identificador para a variável seguido,
opcionalmente, de =<inicialização> em que <inicialização> é uma
expressão que define um valor inicial para a variável
final <tipo> <declaracao
1
>,..., <declaracao
n
>;
Onde final é a palavra-chave que define uma constante. <tipo> e
<declaracaoi> são como para as variáveis
double distancia, qtdeCombustivel, consumoMedio = 0;
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
32
tipo double. Outra opção é declará-los como float. Observe a atribuição de 0 (zero) à
consumoMedio informando seu conteúdo inicial. Esta atribuição é opcional já que o valor
de consumoMedio será calculado durante o programa. Aqui o objetivo é ilustrar a
inicialização de uma variável na sua declaração.
Mais exemplos de declaração de variáveis são dados a seguir. Observe que valores
do tipo char devem ser delimitados por ‘ e ‘ (aspas simples). Já uma cadeia em uma variável
do tipo String é delimitada entre “ e “ (aspas duplas).
Outro detalhe é que, as variáveis do tipo float quando recebem valores fixos no código
(o que chamamos literais) devem ser sufixados com um ‘f’ ou um ‘F’. Isso ocorre porque os
compiladores Java traduzem um valor literal em ponto flutuante automaticamente para o tipo
double (8 bytes). Sendo assim um erro ocorreria indicando que poderá haver perda de
precisão quando um valor em 8 bytes (double) fosse copiado diretamente para 4 bytes
(float). Nesse caso, o compilador acusando erro obriga o programador a tratar o caso.
Portanto, insira o sufixo para indicar que o literal é um float!
Deve ser lembrado que toda variável ou constante em Java deve ser inicializada antes
do seu primeiro uso. Usar o conteúdo de uma constante ou variável sem atribuir valor faz
com que o compilador acuse o erro exibido no exemplo da Figura 10. Na linha 14 da classe
o conteúdo da variável y é solicitado gerando a mensagem de erro: “variável y não foi
inicializada”.
Figura 10 – Erro devido uso sem inicialização da variável y
byte diaDaSemana = 1; //byte é apropriado! De 1 (dom) à 7 (sáb)
short populacaoLavrasNovas = 1500; // estima-se que a população desse lugarejo no
// alto da serra não ultrapasse 1000 habitantes
int mortesCoronaVirusBrasil; // será menor que a população brasileira (cerca de 209 milhões)
boolean aprovado = true;
float salario = 3955.00F; //para valores float inclua o sufixo F ou f
double populacaoColoniaDeBacteria = 10E27; // o mesmo que 1027 informado em notação
// científica. Após o E é indicado o expoente
char c = ‘a’ ;
char alfanumerico = ‘7’; //esse é o caractere alfanumérico ‘7’ que é diferente do inteiro 7!
String nomeCompleto = “João de Barro”; //cadeias são informadas entre aspas duplas!
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
33
Fonte: Elaborado pela autora
Antes de completar nosso programa exemplo será preciso compreender como obter
dados de entrada, a partir do teclado, e como enviar informações para a saída que sejam
exibidas no console (modo texto) do monitor.
Mídia digital: vá até a sala virtual e assista ao vídeo “Aula 4
– Entrada e Saída”, disponível na semana 1.
1.2.3. Entrada e Saída padrão
Para enviar dados para o monitor, em modo texto, usamos o stream20 System.out
da API Java. Com ele podemos enviar cadeias de caracteres para a saída padrão. Observe
como usamos o comando:
System.out.print (<expressão>)
Para imprimir <expressão> e manter o cursor na mesma linha
System.out.println(<expressão>)
Para imprimir <expressão> e pular o cursor para a próxima linha
Em ambos os casos <expressão> é uma cadeia de caracteres informada entre aspas duplas
ou uma combinação de cadeias, variáveis/constantes concatenados com +.
Exemplos:
System.out.println(“Hello World!”); // Saída: Hello World!
System.out.println(“Soma = ”+ (1200 + 27)); // Saída: Soma = 1227
System.out.println(“Consumo médio: ”+ consumoMedio);
// Saída: Consumo médio: <conteúdo_variável_consumoMedio>
Agora, retorne à classe HelloWorld da seção 1.2. Veja se você será capaz de
compreender aquele código um pouco mais.
20 Stream é o termo em Inglês que significa um fluxo, nesse caso de dados bytes ou caracteres. Toda entrada e saída em
Java é realizada através de classes que implementam e filtram fluxos de caracteres ou de bytes.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
34
Em relação à entrada de dados um dos recursos que podemos usar em Java é a
classe Scanner da API. Esta classe facilita a obtenção de dados do stream de entrada pois
oferece métodos que formatam os dados para os tipos primitivos do Java. Observe as
opções disponíveis de métodos que podemos usar para leitura de dados no Quadro 6.
Quadro 6 – alguns métodos de leitura com a classe Scanner
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Para ler com Scanner é preciso seguir as etapas abaixo:
1. Importação do pacote da classe Scanner. Inclua no início da classe, abaixo
da clausula package, a cláusula import:
𝑖𝑚𝑝𝑜𝑟𝑡 𝑗𝑎𝑣𝑎. 𝑢𝑡𝑖𝑙. 𝑆𝑐𝑎𝑛𝑛𝑒𝑟;
2. Criação do objeto Scanner para realizar a entrada de dados. Dentro do método
main(), antes de realizar a leitura do teclado:
𝑆𝑐𝑎𝑛𝑛𝑒𝑟 < 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 > = 𝑛𝑒𝑤 𝑆𝑐𝑎𝑛𝑛𝑒𝑟(𝑆𝑦𝑠𝑡𝑒𝑚. 𝑖𝑛);
3. Empregue, para cada tipo primitivo, o método apropriado da classe conforme
o Quadro 6.
Podemos, enfim, codificar nosso primeiro programa útil que calcula a eficiência de
combustível. Observe a classe da Figura 11. Transcreva esta classe para seu ambiente de
desenvolvimento. Em seguida execute o programa para ver o resultado.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
35
Figura 11 – Classe Java executável para o programa da eficiência de combustível
Fonte: Elaborado pela autora.
Como não há método apropriado na classe Scanner para leitura de um único
caractere é preciso extrair o primeiro caractere da primeira palavra digitada pelo usuário. A
extração do caractere é feita da primeira palavra que o método next() retorna. Veja como
realizar a leitura da palavra e a extração do primeiro caractere dela em uma só linha na
Figura 12, a seguir.
Observe que este caractere pode ser maiúsculo ou minúsculo. Os métodos𝐶ℎ𝑎𝑟𝑎𝑐𝑡𝑒𝑟. 𝑡𝑜𝐿𝑜𝑤𝑒𝑟𝐶𝑎𝑠𝑒 () e 𝐶ℎ𝑎𝑟𝑎𝑐𝑡𝑒𝑟. 𝑡𝑜𝑈𝑝𝑝𝑒𝑟𝐶𝑎𝑠𝑒() retornam o caractere passado entre
parênteses como minúsculo e maiúsculo, respectivamente. Veja no código da Figura 12,
linhas 26 e 30, como tratar a conversão de caracteres entre maiúsculo e minúsculo.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
36
Figura 12 – Classe com exemplos de leitura de caracteres e transformação de case
Fonte: Elaborado pela autora
1.2.4. Pratique
1) Enumere os tipos de dados primitivos da linguagem Java.
2) Conceitue variáveis e constantes e descreva sua sintaxe de declaração.
3) Supondo que seja necessário armazenar os valores abaixo em programas. Aponte que
tipo de dado ou que tipos, se houver mais de um, podem ser utilizados para armazenar
cada valor.
a) 613
b) 613,0
c) -613
d) ‘6’
e) -3.012 x 1015
f) 1.7 x 1012
g) -28.3 x 10 -23
h) ‘F’
i) “Curso de Programação em Java para Iniciantes”
j) Dois estados: ligado ou desligado
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
37
4) Faça um programa em Java para somar dois números inteiros informados pelo usuário.
Lembre-se que é necessário que sua classe Java tenha o método main, isto é, que sua
classe seja uma classe executável.
5) Indique as saídas para o programa a seguir, em duas situações:
a) Supondo que o usuário informe 3 para x e 5 para y
b) Supondo que o usuário informe -5 para x e 7 para y
Figura 13 – Classe Java executável
Fonte: Elaborado pela autora
6) Faça um programa em Java para ler o nome, o nome do meio e o sobrenome do usuário.
O programa deve extrair os caracteres iniciais de cada parte do nome. Em seguida, cada
caractere deve ser convertido para maiúsculo.
Pede-se:
Supondo que você tenha dado os identificadores p, s, e t às variáveis dos
caracteres iniciais de cada parte do nome, imprima o conteúdo das três variáveis
na sequência, usando o comando:
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡(𝑝); 𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡(𝑠); 𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡(𝑡);
Agora imprima usando o comando abaixo. Verifique que os valores inteiros
referentes a cada caractere serão somados e resultado será exibido. Isso ocorre
porque com o tipo char é possível realizar a operação de soma de seus números
inteiros associados. Lembre-se que cada caractere Unicode possui um número
inteiro correspondente
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡𝑙𝑛(𝑝 + 𝑠 + 𝑡);
O problema anterior pode ser ajustado com o uso de uma String vazia
concatenada aos caracteres. Assim o compilador realizará a concatenação das
cadeias referentes aos caracteres com a String “”, ao invés de somar seus valores
na tabela de caracteres:
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡("" + 𝑐 + 𝑑 + 𝑒);
7) Faça um programa em Java para obter o nome e a idade do usuário. Seu programa deve
calcular e exibir o nome e a idade que o usuário terá em 2049. Exiba uma mensagem no
formato: < 𝑣𝑎𝑟𝑁𝑜𝑚𝑒 > 𝑣𝑜𝑐ê 𝑡𝑒𝑟á 𝑥𝑥 𝑎𝑛𝑜𝑠 𝑒𝑚 2049.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
38
Atividade: após concluir a 1º semana de estudos, vá até
a sala virtual e resolva a atividade “Programando em
Java: final da 1º etapa”.
Nos encontramos na próxima semana.
Bons estudos!
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
39
Mídia digital: vá até a sala virtual e assista aos vídeos
das aulas 5 e 6 sobre “Aritmética e funções”. Eles estão
disponíveis na semana 2.
Atividade: após estudo da seção a seguir, para fixação
resolva os exercícios práticos propostos, na sequência.
2.1. Operadores de atribuição, aritméticos e suas precedências
Usamos o símbolo = para atribuir valores a variáveis e constantes. O = é o operador
de atribuição. Observe a sintaxe e os exemplos a seguir:
Agora veja os operadores aritméticos binários do Quadro 7. Um operador é dito
binário quando é aplicado a dois operandos.
Objetivos:
Operadores aritméticos e suas precedências. Operadores
relacionais e lógicos e o comando de decisão (if simples e
composto). Seleção entre múltiplas escolhas usando if
encadeado e switch.
<variavel_ou_constante> = <expressão>;
Onde <expressão> é qualquer expressão que quando computada retorne um valor
compatível ao tipo da variável ou constante
Exemplos:
int populacao = 200000000;
double area = (12.45 * 21.50); // area = 12.45 x 21.50 = 267.675
double nota = 8.7;
boolean aprovado = (nota > 6)? true: false; //sendo nota igual a 8.7, aprovado= true
float x = 1.9E-7; // x = 1.9 x 10-7
char c = ‘A’;
String sobrenome = “Planalto”;
String nome = “Jorge Adam ” + sobrenome; // nome = ”Jorge Adam Planalto”
Semana 2 – Instruções de sequência
Semana 1 – Introdução à linguagem Java
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
40
Quadro 7 – operadores aritméticos binários
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Veja também que o mesmo operador de divisão, /, pode ser usado para divisão inteira
e para divisão exata. Quando ambos os operandos são inteiros é feita uma divisão inteira.
Quando um dos operandos é ponto flutuantes, seja float ou double, a divisão será exata.
Atenção deve ser dada aos literais inteiros informados no código. Se a necessidade for uma
divisão exata envolvendo literais inteiros será preciso acrescentar um ponto decimal ao
literal:
Quanto aos operadores unários esses são aplicados a apenas um operando. Há dois
operadores aritméticos unários muito comuns: o incremento (++) e o decremento (- -). O
incremento soma um ao operando. O decremento subtrai um do operando. O Quadro 8
apresenta ambos e dá exemplos.
Exemplos:
double indice = 27/100; // indice = 0 (divisão inteira!)
double indice = 27.0/100; // indice = 0.27 (divisão exata)
// 27.0 é interpretado como ponto flutuante
double indice = 27./100; // indice = 0.27 (divisão exata)
// basta acrescentar um ponto decimal, pois 27. = 27.0
double indice = 27/100. ; // indice = 0.27 (divisão exata)
// 100. é interpretado como 100.0
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
41
Fique atendo para os casos de incremento ou decremento pós fixado dentro de
expressões. Nesse caso, o valor da variável é utilizado na expressão antes que a operação
de incremento/decremento seja efetuada. Portanto, incremento e decremento pós fixado
quando usados dentro de expressões serão calculados apenas após a avaliação da
expressão.
Por último, é bom saber que há versões contraídas para todos os operadores
aritméticos. Essas versões fazem o uso do valor atual da variável à esquerda do sinal de
atribuição com o valor da expressão do lado direito. Observe os exemplos abaixo:
Quadro 8 – operadores de incremento/decremento
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Quando mais de um operador aparece em uma expressão aritmética é preciso
compreender qual operação é realizada primeiro. O Quadro 9 resume a precedência de
operações.
int valor = 14;
valor += 27; // equivalente a valor = valor + 27. Então, valor = 14 + 27 = 31
double indice = 18.5;
indice /=100; // o mesmo que indice = indice / 100. Então, indice = 18.5/100 = 0.185
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
42Quadro 9 – precedência de operadores aritméticos
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Quanto menor a ordem de precedência do operador, maior será a prioridade da
operação. Observe nos exemplos a seguir as operações que serão realizadas primeiro são
indicadas nos comentários à direita, entre parênteses.
Para forçar a precedência usamos parênteses ‘(‘ e ‘)’. Exemplos:
O Quadro 10 apresenta as versões contraídas para cada um dos operadores
aritméticos e dá exemplos.
y = a + b * c; // y = a + (b * c);
y = a + b % c; // y = a + (b % c);
y = a * b % c; // y = (a * b) % c; se ambos tem mesma precedência, o cálculo é feito
// da esquerda para direita
y = a++ * b; // y = (a * b) ; ocorre primeiro
// a = a + 1; ocorre por último
int y, a = 1, b = 2, c = 3;
y = (a – b ) * c; // y = (1 – 2 ) * 3 = -3
y = (a + b) % c; // y = (1 + 2) % 3 = 0
y = (a – 2*b) – (b – c); // y = (1 – 2*2) – (2 – 3) = (1 - 4) – (-1) = -2
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
43
Quadro 10 – operadores aritméticos em versão contraída
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
2.1.1. Outras funções matemáticas e a linearização de expressões
aritméticas
Você deve ter observado que não há operadores aritméticos em Java para
potenciação. Para calcular potências e raízes em Java usamos os métodos disponíveis na
classe Math. A classe Math é uma biblioteca de funções matemáticas. Veja algumas delas
no Quadro 11. Observe que a maioria das funções de Math retornam valores do tipo double
ou têm versões para retornar double, entre outros tipos de retorno. Esse último caso é o do
método round() para arredondar um número ou uma expressão em ponto flutuante para o
inteiro mais próximo. Assim é preciso ficar atento, pois se o argumento de round() é um float
o resultado será um inteiro do tipo int. Se o argumento for double o retorno de round() será
do tipo long.
Atenção: o único pacote de classes que é importado
automaticamente pelo compilador é o java.lang. Ele
possui as classes básicas para programar e algumas
que já usamos nos códigos: System e Math.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
44
Quadro 11 – Funções comuns da biblioteca Math
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Dica do professor: para maiores detalhes, acesse a
documentação oficial da API Java 8 SE a partir do site
da Oracle. Procure pela classe/interface desejada e
expanda sua documentação.
A classe Math também inclui as constantes matemáticas do Quadro 12. Use-as para
não incorrer em erros de precisão ao trabalhar com elas!
Quadro 12 – Constantes matemáticas da classe Math
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
45
O segundo objetivo desta seção é compreender sobre como escrever uma equação
em um programa Java. Se na matemática usamos informar a precedência das operações
com parênteses, colchetes e chaves, em programação usamos apenas os parênteses. Além
disso, devemos linearizar as expressões. Novamente aqui os parênteses solucionam a situação
pois indicam como priorizar as operações. Suponha, p. ex., uma divisão. Se ambos, numerador e
denominador são expressões maiores cada uma deve ser resolvida antes que o computador calcule
o quociente, não é mesmo?
A expressão 𝑋 =
𝐴+
𝐵
𝐶
𝐷−
𝐸
𝐹
, p. ex., será transcrita num programa em uma única linha: 𝑋 = (𝐴 +
𝐵/𝐶) / (𝐷 – 𝐸/𝐹). O Quadro 13 ilustra na coluna à esquerda uma expressão e como a
escrevemos na Matemática. À direita e a sua representação em Java.
Quadro 13 – Linearização de expressões em programas
Fonte: Elaborado pela autora
2.1.2. Exercícios resolvidos
1) Escreva um programa em Java que calcule a área de um círculo a partir do raio informado
pelo usuário.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
46
Figura 14 – Classe Java executável – exercícios 1, seção 1.10
Fonte: Elaborado pela autora
2) Um vendedor recebe um salário fixo mensal mais um percentual de comissão sobre o
total das vendas por ele realizadas. Ele deseja um programa para calcular o salário total
a receber ao final no mês. Faça um programa em Java para obter do usuário as entradas:
salário fixo, total de vendas e percentual de comissão sobre as vendas. Em seguida,
calcule e exiba o salário final a receber.
Figura 15 – Classe Java executável – exercícios 2, seção 1.10
Fonte: Elaborado pela autora
3) Uma arquiteta sugeriu cobrir o piso do chão de uma cozinha com um tipo específico de
porcelanato. Sabe-se que a área da cozinha é um retângulo (x metros de largura por y
metros de comprimento). O piso sugerido é um quadrado de 60 por 60 centímetros e o
preço será pesquisado no mercado. Faça um programa em Java que leia do usuário as
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
47
entradas necessárias: a medida dos lados da cozinha (x, y) e o preço em reais por
unidade de piso. Seu programa deverá calcular e exibir a quantidade de pisos a comprar
e o valor total gasto na reforma.
Figura 16 – Classe Java executável – exercícios 3, seção 1.10
Fonte: Elaborado pela autora
2.1.3. Pratique
1) Faça um programa que calcule a área de um retângulo de lados informados pelo usuário.
O programa deve exibir a área calculada.
2) Faça um programa que calcule a área de um triângulo de largura e altura dados pelo
usuário. O programa deve exibir a área calculada.
3) Uma cliente deseja adquirir uma calça jeans com desconto. Faça um programa que
calcule o total a pagar pela calça após obter do usuário o preço sem desconto e o
percentual de desconto para pagamento a vista.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
48
4) Um aluno fez 5 provas na Universidade e deseja fazer um programa para calcular sua
média final. Faça um programa que obtenha as cinco notas do aluno, calcule e exiba a
média aritmética de suas notas.
5) Faça um programa em Java que leia dois valores reais, n1 e n2, que correspondem a
duas notas de um aluno. Seu programa deve calcular a média do aluno sabendo que a
nota n1 tem peso 3.5 e a nota n2 tem peso 7.5. Observe que trata-se de uma média
ponderada, e que a soma dos pesos é igual a 11.
6) Um menino deseja pegar sua pipa que ficou agarrada em uma árvore a uma altura de x
metros. Devido a alguns obstáculos ele precisará colocar a escada a exatamente y
metros da árvore. Faça um programa que calcule e mostre o tamanho da escada
necessária para conseguir atingir exatamente o local onde está a pipa. Lembre-se que
para um triângulo retângulo, pelo teorema de Pitágoras temos que: 𝑧 = √𝑥2 + 𝑦2.
Figura 17 – Dados do problema
Fonte: Elaborado pela autora
Mídia digital: assista ao vídeo “Aula 7 - Operadores
relacionais e lógicos e o comando IF”, disponível na
semana 2.
2.2. Controlando o fluxo de execução
2.2.1. Operadores relacionais e lógicos
Até agora vimos o que nos possibilita fazer um programa contendo sentenças de
código Java que são executadas exatamente na ordem em que aparecem: uma após a outra.
É o que chamamos de “instruções de sequência”. Com elas conseguimos fazer muito pouco.
É quase que como usar o computador para fazer o mesmo que fazemos em uma calculadora
não programável: informamos uma sequência de cálculos e aguardamos o resultado.
A partir de agora vamos trabalhar com instruções que possibilitam controlar ou alterar
essefluxo sequencial. Isso significa que podemos selecionar se determinado conjunto de
instruções será ou não executado a depender do que chamados da ‘instância de
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
49
execução’. Veja um exemplo onde isso é aplicado. Suponha um programa para computar o
peso ideal de uma pessoa. O peso ideal é calculado de maneira diferente a depender do
sexo. Há uma fórmula para o peso ideal de homens e outra fórmula para mulheres. É claro
que o programa precisa atender tanto homens quanto mulheres, seus possíveis usuários.
Assim deverá executar o cálculo correto de acordo com o sexo informado. Como cada
chamada do programa é uma execução distinta, quando usamos instruções de controle de
fluxo cada instância poderá executar um conjunto diferente de instruções, dentro do mesmo
programa.
Para conseguirmos essa flexibilidade precisamos antes conhecer mais operadores:
os operadores relacionais e os operadores lógicos. Apenas depois estaremos aptos a
trabalhar com instruções de controle de fluxo do tipo IF, Switch, etc.
Vamos aos relacionais. Os operadores relacionais são usados para fazer
comparações e inequações como já os conhecemos da Matemática. Veja o Quadro 14. Um
detalhe aqui é que usamos == para testar a igualdade. É assim necessário para diferenciar
a comparação de igualdade do operador de atribuição (=).
Quadro 14 – Operadores relacionais
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
s operandos de uma operação relacional podem ser variáveis, literais numéricos ou
expressões aritméticas. O resultado de uma operação relacional sempre será um valor
‘booleano’: true (verdadeiro) ou false (falso). Veja alguns exemplos:
Voltando à Matemática do ensino básico, vamos lembrar como descrevemos que um
dado número 𝑋, do conjunto dos inteiros ou dos reais, está dentro de um intervalo. O
intervalo pode ser aberto e/ou fechado em ambas as extremidades. Veja:
Se 𝑋 =] − 5, 21[ escrevemos que −5 < 𝑋 < 21.
Se 𝑋 = [0, 1[ significa que 0 ≤ 𝑋 < 1.
Se 𝑋 = [10, 15] a inequação será: 10 ≤ 𝑋 ≤ 15.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
50
Em linguagens de programação não podemos especificar um intervalo desta maneira!
Em um programa precisamos escrever as sentenças anteriores de maneira ainda mais
legível para o computador. Veja que em todos os casos acima temos duas operações
relacionais que precisam ser conectadas por meio do que chamamos de operadores
lógicos:
Se 𝑋 =] − 5, 21[ então 𝑋 > −5 𝐸 𝑋 < 21.
Se 𝑋 = [0, 1[ então 𝑋 ≥ 0 𝐸 𝑋 < 1.
Se 𝑋 = [10, 15] então 𝑋 ≥ 10 𝐸 𝑋 ≤ 15.
O 𝐸 nas sentenças acima tem a função de combinar as expressões relacionais (que
usam operadores relacionais) de ambos os lados. Veja que a afirmação 𝑋 ≥ 0 𝐸 𝑋 < 1 só
será verdadeira se ambas as expressões relacionais foram verdadeiras. Ou seja, só
podemos afirmar que 𝑋 pertence ao intervalo [0,1[ se é verdade que 𝑋 ≥ 0 e é verdade que
𝑋 < 1. Assim, concluímos que 𝑣𝑒𝑟𝑑𝑎𝑑𝑒𝑖𝑟𝑜 𝐸 𝑣𝑒𝑟𝑑𝑎𝑑𝑒𝑖𝑟𝑜 = 𝑣𝑒𝑟𝑑𝑎𝑑𝑒𝑖𝑟𝑜 e essa é a única
possibilidade de uma operação lógica com 𝐸 resultar em verdadeiro! Chamamos de 𝐸 o
operador lógico para conjunção21 e o símbolo que usamos em Java para o mesmo é &&, ou
seja, dois e’s comerciais seguidos, sem espaços.
O Quadro 15 seguinte mostra os três operadores lógicos existentes: conjunção (𝐸),
disjunção (𝑂𝑢) e negação (𝑁ã𝑜). Observe as tabelas verdades de cada um. Uma tabela
verdade enumera todas as possibilidades de valores para os operandos, isto é, dados os
valores para as proposições 𝐴 e 𝐵, cada linha é um resultado para a operação. Em um
programa 𝐴 e 𝐵 serão expressões relacionais ou mesmo outras operações lógicas. Observe
ainda que expressões relacionais comumente envolvem operações aritméticas. De toda
maneira, aqui 𝐴 e 𝐵 serão pois expressões booleanas, isto é, valores do tipo verdadeiro ou
falso que em Java é representado por 𝑡𝑟𝑢𝑒 ou 𝑓𝑎𝑙𝑠𝑒.
Vejamos um exemplo de uso para o operador lógico 𝑂𝑈. Um usuário brasileiro deseja
saber se será obrigado a votar nas eleições de 2020. As eleições ocorrerão em novembro e
ele já completou 𝑋 anos em 31 de julho de 2020. Sabemos que no Brasil o voto é opcional
para os menores de 18 e para maiores de 70 anos. O programa perguntará a idade do
usuário e exibirá a mensagem “Voto opcional” caso a idade dele esteja em uma das faixas
acima. Qual será o teste, isto é, a sentença booleana que o programador deve especificar?
Lembre-se! O programador tem à disposição operadores relacionais e lógicos.
Então, para descobrir se o voto é opcional uma solução é formular a sentença: 𝑋 <
18 𝑂𝑈 𝑋 > 70, supondo que 𝑋 é a variável no programa para a idade do usuário. Em Java
escreveremos (𝑋 < 18) || (𝑋 > 70). Aqui o uso dos parênteses é opcional, mas é
aconselhável para delimitar de maneira legível os operandos do 𝑂𝑢, (𝑋 < 10) e (𝑋 > 70).
21 𝐸 ou AND, 𝑂𝑢 ou OR e 𝑁ã𝑜 ou NOT, do Inglês.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
51
O último operador lógico é a negação representada em Java pelo símbolo de !. Para
ilustrar seu uso vamos lançar mão de uma situação simples: desejamos saber se o ano de
nascimento do usuário é diferente de 2007. A maneira natural de especificar esse teste
booleano é escrevendo: 𝑎𝑛𝑜 ! = 2007. Aqui usamos o operador relacional já conhecido
para diferença: ! =. É interessante lembrar que certas expressões booleanas podem ser
especificadas de mais de uma forma. Nesse exemplo poderíamos também escrever o teste
da seguinte maneira: ! (𝑎𝑛𝑜 == 2007). Vamos averiguar se dá o mesmo resultado?
Quadro 15 – Operadores lógicos e tabelas verdades
Fonte: Elaborado pela autora, baseado em (SCHILDT, 2018)
Podemos resumir o comportamento do 𝑂𝑈 e do 𝐸. Uma expressão com 𝐸 será
verdadeira apenas se ambos os operandos forem verdadeiros. Uma expressão com 𝑂𝑈
resultará será falsa apenas se ambos os operandos forem falsos. Quanto ao operador de
negação, este terá prioridade sobre os demais! Por fim, a partir dessas três operações
lógicas podemos concatenar expressões menores e realizar testes completos.
Agora que aprendemos os principais operadores, vejamos a ordem de precedência
entre as três categorias:
1º) São executadas as operações aritméticas
2º) As operações relacionais
3º) As operações lógicas
Suponha que o usuário digitou 2004:
O teste ano != 2007 resulta em true
O teste !(ano == 2007) resulta em !(false) o que é igual a true
Agora suponha que o usuário digitou 2007:
O teste ano != 2007 resulta em false
O teste !(ano == 2007) resulta em !(true) o que implica false
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
52
Embora a expressão (𝑦 − 𝑥 > 5 && 𝑤/𝑦 == 1) não exija o uso parênteses é
comum em programas delimitarmos cada operação: (((𝑦 − 𝑥) > 5) && ((𝑤/𝑦) == 1)) .
Isso melhora o entendimento, a legibilidade do código.
2.2.2. Exercícios resolvidos
1) Supondo x = 4, y = 13, z = 120 e w = 11. Qual o resultado das expressões a seguir? Para
não errar, resolva passo a passo. Use V, para true e F para false.
a) ((𝑤 % 2) == 0) || ( (𝑦 % 2) == 0)
((11%2) == 0) || ((13 % 2) == 0))
(1 == 0) || (1 == 0)
F || F
F
b) ((𝑦 − 𝑥) > 5) && ((𝑤/𝑦) == 1) , 𝑎𝑡𝑒𝑛çã𝑜 𝑝𝑎𝑟𝑎 𝑎 𝑑𝑖𝑣𝑖𝑠ã𝑜 𝑖𝑛𝑡𝑒𝑖𝑟𝑎: 𝑤/𝑦
((13 - 4) > 5) && ((11/13) == 1))
((9 > 5) && (0 == 1))
(V && F)
F
c) ! ((𝑦 ∗ 𝑧) > 𝑤) || ((𝑦 − 𝑤) > 𝑥)
!((13*9) > 120) || ((13 – 120) > 4)
!(117 > 120) || (-107 > 4)
!(117 > 120) || (-107 > 4)
!(F) || (F)
V || F
V
d) ! ( ( ( (𝑤 + 𝑥 + 𝑦 + 𝑧)/4)<= 5) || ((𝑤%3) == 1) ) , 𝑎𝑡𝑒𝑛çã𝑜 𝑝𝑎𝑟𝑎 𝑎 𝑑𝑖𝑣𝑖𝑠ã𝑜 𝑖𝑛𝑡𝑒𝑖𝑟𝑎
!((((120 + 4 + 13 + 9)/4) <= 5)||((120%3) ==1))
!(((146/4) <= 5)||(0 == 1))
!((36 <= 5)||F)
!(F||F)
!(F)
V
2.2.3. Pratique
1) Supondo x = 2, y = 3, z = 12 e w = 17. Qual o resultado das expressões a seguir? Você
pode usar V, para true e F para false. Para não errar, resolva passo a passo e considere
as divisões como inteiras. Lembre-se que 𝑀𝑎𝑡ℎ. 𝑝𝑜𝑤(2, 3) significa 23 = 8.
a) ( ((𝑤 + 𝑦)/2) > 6) || ( (𝑤 − 3 ∗ 𝑥) > 12)
b) ! ((𝑀𝑎𝑡ℎ. 𝑝𝑜𝑤(𝑧, 5) > (𝑤 ∗ 𝑦)) && ((𝑦 + 𝑧/2) == 3) )
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
53
c) (𝑀𝑎𝑡ℎ. 𝑝𝑜𝑤(𝑥, 𝑦) >= (𝑤 ∗ 𝑧)) && ( ((𝑥 + 𝑧) >= (𝑦 % 𝑧)) || ! ((𝑦 ∗ 𝑧) ! = 𝑤) )
Atividade: resolva a atividade “Programando em Java:
exercício 1” disponível na sala virtual para a 2º semana.
2.2.4. O comando IF simples
Agora estamos preparados para entender como controlar o fluxo de execução de
instruções em um programa. Voltemos ao exemplo do programa que responde ao usuário
se seu voto é opcional. O programa perguntará a idade do usuário e exibirá a mensagem
“Voto opcional” se a idade dele for menor que 18 ou maior que 70 anos. Já sabemos que a
expressão booleana, isto é, a condição será: (𝑖𝑑𝑎𝑑𝑒 < 18) || (𝑖𝑑𝑎𝑑𝑒 > 70). Apenas se
esta condição for verdadeira é que o computador deverá exibir a mensagem com
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡𝑙𝑛(“𝑉𝑜𝑡𝑜 𝑜𝑝𝑐𝑖𝑜𝑛𝑎𝑙”).
Para isso podemos usar a instrução IF. Seja condicao uma expressão booleana
(relacional ou lógica) que quando executada retorne true ou false, a sintaxe do comando IF
no Java é:
Para o programa do voto o comando IF será:
Observe. Quando um bloco de instruções, delimitado por { e } contem apenas uma
sentença podemos excluir os delimitadores do bloco.
Veja o programa completo na Figura 18. Agora entenda porque estamos controlando
o fluxo. Suponha que o usuário digite 18 para a variável 𝑖𝑑𝑎𝑑𝑒. Nesse caso a condição
((𝑖𝑑𝑎𝑑𝑒 < 18) || (𝑖𝑑𝑎𝑑𝑒 > 70)) resultará em ( 𝐹 || 𝐹) que é igual a 𝐹. Então a mensagem
não será exibida e as linhas ou sentenças executadas serão aquelas do início do main até
a linha 15 e a linha 18 que finaliza o método main. Perceba que a linha 16 não será
if (condicao){
// bloco de instruções
}
if ((idade < 18) || (idade > 70)){
System.out.println(“Voto opcional”);
}
// ou apenas:
if ((idade < 18) || (idade > 70))
System.out.println(“Voto opcional”);
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
54
executada, embora a linha 15 do teste de condição do IF sempre será pois o computador
precisará avaliar a condição para decidir se entra ou não no bloco interno.
Fica fácil perceber qual o perfil de execução para uma idade igual a 16. Esse é o caso
em que a mensagem será informada pois ((𝑖𝑑𝑎𝑑𝑒 < 18) || (𝑖𝑑𝑎𝑑𝑒 > 70)) resultará em
(𝑉 || 𝐹) que é igual a 𝑉. Nessa instância do programa todas as linhas do main serão
executadas.
Figura 18 – Programa do voto opcional
Fonte: Elaborado pela autora
2.2.5. Exercícios resolvidos
1) Em um clube as piscinas maiores são de acesso controlado para crianças menores de 9
anos de idade. Essas piscinas são fechadas e o acesso é feito por catracas onde o
usuário deve indicar sua idade e confirmar um termo de responsabilidade. Se o usuário
é autorizado a entrar a catraca abre. Caso contrário, aparecerá no visor a mensagem
“Entrada proibida!”. Faça um programa em Java para ler o nome do usuário e informar a
mensagem acima quando o acesso for proibido devido idade informada.
Figura 19 – Programa do acesso com catraca
Fonte: Elaborado pela autora
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
55
2) Faça um programa para ler um número inteiro 𝑋. Se 𝑋 estiver no intervalo ]27, 100] some
57 à 𝑋. Em seguida, teste se o valor de 𝑋 é maior que 102. Se sim, o programa deve
calcular o novo valor de 𝑋 dividindo 𝑋 por 2 (divisão inteira) e somando 5. O programa
deve exibir o valor final de 𝑋 em uma mensagem no formato: 𝑋 = < 𝑋 >, onde < 𝑋 >
deve ser substituído pelo conteúdo da variável 𝑋.
Figura 20 – Programa seção 1.16, exercícios 2.
Fonte: Elaborado pela autora
2.2.6. Pratique
1) Faça um programa em Java para ler um número inteiro e testar se este número é divisível
por 2. Se sim o programa deve exibir a mensagem “Número par”.
2) Faça um programa em Java para ler dois números inteiros e testar se o primeiro número
é o maior. Se sim o programa deve exibir a mensagem “O primeiro é maior”.
3) Faça um programa em Java que leia os coeficientes 𝑎, 𝑏 e 𝑐 de uma equação de segundo
grau. O programa deve calcular o 𝑑𝑒𝑙𝑡𝑎 = 𝑏2 − 4 ∗ 𝑎 ∗ 𝑐 . Se o 𝑑𝑒𝑙𝑡𝑎 for menor que 0, o
programa deverá exibir a mensagem “Não existem raízes reais”.
2.2.7. IF composto
É provável que você tenha percebido que o programa estava incompleto nos
exemplos em que usamos o comando IF simples. O caso do voto opcional é um exemplo. A
pergunta deve ter sido: “porque não informar se o voto é obrigatório também?”.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
56
A boa notícia é que fazer isso é absolutamente simples. Observe que se o voto não
é opcional é porque ele é obrigatório. Então a negação da condição (𝑖𝑑𝑎𝑑𝑒 <
18) || (𝑖𝑑𝑎𝑑𝑒 > 70) é a constatação de que votar é obrigatório para aquela idade. Muitos
param por aqui e concluem precipitadamente que devem incluir mais um IF ao programa
como no contraexemplo abaixo:
Não precisamos fazer dois testes condicionais. Aliás, não devemos fazê-los sem
necessidade, pois cada teste é uma computação na máquina! Dispomos do comando IF
composto para isso. Observe sua sintaxe abaixo. É importante lembrar que um IF composto,
ou um IF-ELSE também é tratado como um único comando. Aqui o computador não
precisará avaliar nova condição pois o bloco 𝑒𝑙𝑠𝑒 será executado automaticamente quando
a condição do 𝑖𝑓 for falsa. Lembre-se que else, em Inglês, significa senão. Então após
avaliada a condição, se esta for verdadeira o bloco do 𝑖𝑓 será executado. Senão se condição
é falsa será feito o bloco do 𝑒𝑙𝑠𝑒.
A Figura 21 a seguir exibe o programa do voto usando o IF composto. Veja agora que
o programa está completo e será executado de maneira mais eficiente uma vez que o
computador não fará dois testes condicionais, mas apenas um!
Figura 21 – Programa do voto usando If-Else
Fonte: Elaborado pela autora
if ((idade < 18) || (idade > 70)){
System.out.println(“Voto opcional”);
}
// continuando…
if ((idade >= 18) && (idade <= 70)){
System.out.println(“Voto obrigatório”);
}
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
57
Agora podemos verificar novamente quais linhas serão executadas se a idade
informada pelo usuário for igual a 16. Lembre-se que a condição será verdadeira pois, (16 <
18) || (16 > 70) resultando em (𝑡𝑟𝑢𝑒 || 𝑓𝑎𝑙𝑠𝑒) que é igual a 𝑡𝑟𝑢𝑒. Portanto, as linhas
executadas serão as iniciais até a 17 (onde o bloco do 𝑖𝑓 é fechado, sem a execução do
𝒆𝒍𝒔𝒆!) e a linha 20. Se o usuário informasse a idade igual a 18 a condição (18 <
18) || (18 > 70) resultaria em (𝑓𝑎𝑙𝑠𝑒 || 𝑓𝑎𝑙𝑠𝑒) que é igual a 𝑓𝑎𝑠𝑒. Dessa vez o bloco 𝑒𝑙𝑠𝑒
será executado. Nessa instância o fluxo de execução passará pelas linhas iniciais até a 15
(onde a condição é avaliada como false) e da linha 17 (no início do bloco else) até o final do
main na linha 20.
Como mencionado na seção sobre operadores lógicos, como podemos escrever um
mesmo teste lógico de formas diferentes podemos escrever o programa do voto com o IF-
Else abaixo,bastando inverter as mensagens.
2.2.8. Exercícios resolvidos
1) Suponha completar o programa de controle de acesso às piscinas do clube. Nesse caso
o visor da catraca deve exibir “acesso livre”, se o usuário tem idade maior ou igual a 9
anos, e “acesso proibido” para crianças abaixo de 9 anos.
Figura 22 – Programa do acesso com catraca usando If-Else
Fonte: Elaborado pela autora
if ((idade >= 18) && (idade <= 70)){
System.out.println(“Voto obrigatório”);
}else{
System.out.println(“Voto opcional”);
}
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
58
2) Faça um programa para obter um número inteiro do usuário, calcular e exibir se o número
é par ou é ímpar.
Figura 23 – Programa para verificar se um número é par ou impar
Fonte: Elaborado pela autora
2.2.9. Pratique
1) Faça um programa para ler 2 números inteiros do usuário. O programa deve calcular e
exibir a mensagem “números iguais”, se os números digitados são iguais, ou “números
diferentes”, caso contrário.
2) Faça um programa para ler 2 números inteiros, A e B, do usuário. O programa deve
calcular e exibir a mensagem “A é divisível por B”, se o resto da divisão inteira de A por
B for igual a zero. Caso contrário o programa deve exibir a mensagem: “A não é múltiplo
de B”.
3) Um cliente deseja comprar uma calça Jeans mas apenas está disposto a pagar por ela
550 reais. Faça um programa para atende-lo da seguinte maneira. Após o lojista lhe
informar o preço da calça e percentual de desconto para pagamento à vista, o usuário
deseja apresentar esses dados ao programa e obter dele uma das respostas: “Preço com
desconto maior que 550”, se o valor da calça foi superior aos 550 que está disposto a
pagar, ou, “É possível comprar a calça” se o valor for até 550 reais.
4) Faça um programa para obter os coeficientes de uma equação de segundo grau, calcular
e exibir o seu delta. Se o 𝑑𝑒𝑙𝑡𝑎 for negativo o programa deve exibir a mensagem “não
existem raízes reais”. Caso contrário, sendo o 𝑑𝑒𝑙𝑡𝑎 maior ou igual a zero o programa
deve calcular e exibir as duas raízes, ainda que sejam iguais (caso do delta igual a 0).
Observe as fórmulas abaixo:
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
59
𝑑𝑒𝑙𝑡𝑎 = 𝑏2 − 4𝑎𝑐, 𝑟𝑎𝑖𝑧𝑒𝑠 =
−𝑏±√𝑑𝑒𝑙𝑡𝑎
2𝑎
.
Mídia digital: assista ao vídeo “Aula 8 - If’s encadeados
e switch”, disponível na sala virtual para a semana 2.
2.3 Comando de decisão: IF’s encadeados
Nesta semana iremos aprofundar nas estruturas de programação disponíveis para
controlar o fluxo de execução de instruções em um programa.
Começamos explorando um pouco mais do comando IF. Suponha um programa que
após computar a nota final do aluno deva exibir seu status de aprovação. São três as
possibilidades. Se a nota for menor que 40 o aluno será reprovado. Se alcançou nota no
intervalo [40, 60[ terá direito à recuperação. Caso contrário, obtendo nota maior ou igual a
60 o status exibido pelo programa deve ser “Aprovado!”. Como podemos escrever este
código usando o comando IF?
Novamente aqui vem a ideia de lançar mão dos recursos que temos. É preciso
atenção! A solução pode estar incorreta e isso passar sem que se perceba o erro (Figura
24, à esquerda). Por outro lado, a solução pode estar correta mas exigir mais trabalho do
computador (Figura 24, à direita). Devemos buscar soluções corretas e eficientes. A
compreensão de eficiência inicia-se no aprendizado da lógica de programação.
Figura 24 – Solução incorreta à esquerda. Solução correta, mas pouco eficiente à direita.
Fonte: Elaborado pela autora
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
60
Observe o programa da Figura 24, à esquerda. Nele são usados um IF simples
seguido de um IF-ELSE. Ele está incorreto. Observe que quando a nota final for menor que
40 o programa executa exibindo dois status: reprovado e aprovado! Isso ocorre porque se a
condição da linha 19 é falsa a mensagem da linha 22 é automaticamente exibida. Teste
exaustivamente seu código. Se são três as situações de resposta (status), devemos projetar
os dados de entrada de maneira a testar todas as possibilidades de saídas.
O programa da direita da Figura 24 está correto mas inclui IF’s desnecessários. Os
três IF’s serão sempre executados. Não haverá diferença perceptível no tempo de execução
para um aluno, mas tenha em mente que programas completos lidam com grandes massas
de dados. Há alternativa para reduzir o número de testes condicionais nesse programa.
Basta incluir IF’s aninhados, isto é, incluir um IF dentro de outro IF.
Veja como podemos encadear IF’s para verificar condições sucessivas:
Não há nada novo aqui. Apenas inserimos um IF dentro de um Else. Há um IF-Else
dentro do Else da linha 03. O mesmo fizemos ao inserir um IF-Else ao Else da linha 06. Essa
maneira de estruturar as condições torna o programa mais eficiente. Se a 𝑐𝑜𝑛𝑑𝑖𝑐𝑎𝑜1 é true
então o programa executará as linhas de 01 à 03 até o fechamento do bloco IF com }. Em
seguida o fluxo de execução seguirá para a próxima sentença após o IF, linha 14. Da mesma
maneira, se a 𝑐𝑜𝑛𝑑𝑖𝑐𝑎𝑜1 for falsa e a 𝑐𝑜𝑛𝑑𝑖𝑐𝑎𝑜2 for verdadeira então os IF’s das linhas 01
e 04 são realizados. Em seguida, o 𝑏𝑙𝑜𝑐𝑜 𝑑𝑒 𝑖𝑛𝑠𝑡𝑟𝑢çõ𝑒𝑠 2 é executado e o fluxo vai para o
final do Else da linha 03, seguindo a execução para a instrução seguinte ao IF mais externo,
na linha 14. A estratégia é não incluir IF’s independentes se o problema requer uma seleção
a partir de múltiplas alternativas que exigem testes sucessivos. Com IF’s encadeados
minimizamos a execução de testes condicionais desnecessários implementando uma
solução mais eficiente.
Observe o programa da nota reescrito na Figura 25. O IF da linha 19 apenas será
executado se o teste condicional da linha 16 for falso. Nesse caso o computador executará,
no máximo, duas condições ao invés de três. Cabe lembrar que quando usamos um
01 if (condicao1){
02 // bloco de instruções 1
03 }else{
04 if (condicao2){
05 // bloco de instruções 2
06 }else{
07 if (condicao 3){
08 // bloco de instruções 3
09 }else{
10 // bloco de instruções 4
11 }
12 }
13 }
14
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
61
operador relacional ou lógico exigimos instruções de máquina até mais complexas que uma
operação aritmética de soma ou subtração, por exemplo.
Voltando ao assunto dos blocos de instruções que delimitamos com { e }. Já vimos
que um IF ou um IF-Else contam cada um como um único comando, ou seja, são uma única
sentença não importando o que esteja dentro de seus blocos IF e Else. Por sua vez, cada
bloco que contenha um único comando pode ser reescrito sem { e }. Outra questão é que
podemos escrever um 𝑒𝑙𝑠𝑒 seguido de um 𝑖𝑓 na mesma linha. Outro detalhe! Observe que
a condição da linha 19 pode ser escrita de forma mais resumida como: 𝑖𝑓 (𝑛𝑜𝑡𝑎𝐹𝑖𝑛𝑎𝑙 < 60).
Essa condição pode assim ser escrita uma vez que já se sabe que 𝑛𝑜𝑡𝑎𝐹𝑖𝑛𝑎𝑙 não é menor
que 40, pois a condição do 𝑖𝑓 na linha 16 já seria avaliada.
Figura 25 – Solução adequada para o identificar e exibir o status de aprovação
Fonte: Elaborado pela autora
Dito isso, é possível reescrever os If’s aninhados do programa de maneira mais
concisa e legível. Nenhum bloco foi delimitado com { e } já que têm apenas um comado. No
entanto, tenha atenção e insira chaves em caso de dúvida. O segundo If-Else está destacado
em azul. A leitura fica facilitada aqui pelo fato de as condições (if, else if e o else) ficarem
alinhadas à esquerda embaixo do If inicial.
if (notaFinal < 40)
System.out.println(“Reprovado”);else if (notaFinal <60)
System.out.println(“Recuperação”);
else
System.out.println(“Aprovado!”);
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
62
Outro exemplo muito comum da aplicação de If’s aninhados é quando precisamos
verificar em qual intervalo um dado valor se encontra. As faixas de IMC (índice de massa
corporal) são um exemplo disso. A Figura 26 mostra a fórmula de cálculo e a tabela que
define o resultado para cada faixa. Como são sete faixas, após calcular o índice o programa
deve apresentar o resultado através de uma estrutura contendo seis testes condicionais (If)
aninhados. Veja o código Java da Figura 27. Observe a sugestão comentada para redução
das condições em cada else if.
Figura 26 – Fórmula e tabela de resultados do ICM
Fonte: https://pt.wikipedia.org
https://pt.wikipedia.org/wiki/%C3%8Dndice_de_massa_corporal
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
63
Figura 27 – Programa para cálculo do IMC e exibição do resultado segundo a tabela da Figura 26. Fonte:
Elaborado pela autora
2.4 Comando de seleção: switch
Em algumas situações onde usamos If’s aninhados podemos substituir pelo comando
de seleção switch. A estrutura condicional usando switch deixa o código mais limpo. A
sintaxe é a seguinte:
switch(expressao){
case 1:
// bloco de instruções para expressao == 1
break;
case 2:
// bloco de instruções para expressao == 2
break;
default:
//se nenhuma das constantes acima tem o valor da expressao
// aquí é o bloco para todos os demais valores de expressao
}
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
64
No switch o bloco de comandos é executado de acordo com o valor de uma variável
ou expressão (representado por 𝑒𝑥𝑝𝑟𝑒𝑠𝑠𝑎𝑜 na sintaxe acima). Se o valor desta expressão
não for igual a nenhuma das constantes informadas em cada 𝑐𝑎𝑠𝑒, o bloco do 𝑑𝑒𝑓𝑎𝑢𝑙𝑡 será
executado.
A palavra-chave 𝑏𝑟𝑒𝑎𝑘 é necessária quando não devem ser executados os blocos
situados abaixo. Parece estranho mas sem 𝑏𝑟𝑒𝑎𝑘 os cases abaixo são realizados. Sem o
𝑏𝑟𝑒𝑎𝑘 no código acima, quando é verdadeiro que 𝑒𝑥𝑝𝑟𝑒𝑠𝑠𝑎𝑜 == 1 os blocos de instruções
seguintes ao 𝑐𝑎𝑠𝑒 1, ao 𝑐𝑎𝑠𝑒 2 e ao 𝑑𝑒𝑓𝑎𝑢𝑙𝑡 seriam todos executados. Então, as instruções
abaixo do 𝑐𝑎𝑠𝑒 com valor correto vão sendo realizadas até que o final do 𝑠𝑤𝑖𝑡𝑐ℎ ou até o
próximo comando 𝑏𝑟𝑒𝑎𝑘. O 𝑏𝑟𝑒𝑎𝑘 faz o fluxo sair do 𝑠𝑤𝑖𝑡𝑐ℎ e ir para a instrução seguinte a
ele. Ele é opcional pois há situações em que sua ausência é necessária. Observe:
A expressão dentro dos parênteses do switch pode ser dos tipos: 𝑆𝑡𝑟𝑖𝑛𝑔, 𝑐ℎ𝑎𝑟, 𝑏𝑦𝑡𝑒,
𝑠ℎ𝑜𝑟𝑡 ou 𝑖𝑛𝑡. Os tipos em ponto flutuante, float e double, ou inteiro long não são suportados.
Por fim, precisamos entender que o 𝑠𝑤𝑖𝑡𝑐ℎ é útil quando:
Há um grande número de alternativas;
Todas as alternativas dependem da avaliação de uma mesma expressão (na
maioria das vezes, dependem do valor de uma única variável);
As condições de teste são de igualdade
Veja um exemplo de código usando 𝑠𝑤𝑖𝑡𝑐ℎ para seleção entre múltiplas alternativas,
na Figura 28 a seguir.
case ‘.’:
case ‘;’:
case ‘,’:
case ‘!’:
case ‘?’:
case ‘:’:
//bloco de instruções único para todas os casos anteriores
break;
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
65
Figura 28 – Exemplo de uso do switch em um programa que exibe os detalhes da refeição escolhida. Fonte:
Elaborado pela autora
Toda escolha entre múltiplas alternativas sempre pode ser escrita usando If’s
aninhados. Mas a recíproca nem sempre é verdadeira. Nem tudo que escrevemos com If
podemos escrever com switch.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
66
Veja no trecho abaixo a substituição da seleção do switch da Figura 28 por If’s
encadeados:
Essa substituição não é possível para os programas que calculam o status de
aprovação do aluno e a faixa de IMC, da seção anterior. Aqueles incluem testes condicionais
que usam operadores relacionais diferentes de igualdade, são eles: <, <=. O switch é uma
excelente alternativa, mas só poderá ser empregado quando os testes de seleção são de
igualdade.
2.5 Exercícios resolvidos
1) Faça um programa que leia 3 números reais do usuário, calcule e exiba o maior.
Figura 29 – Programa maior de 3
Fonte: Elaborado pela autora
if (codigo == 1)
System.out.println("Arroz, feijão, filé com fritas …”);
else if (código == 2)
System.out.println("Talharim com molho bolonhesa …”);
else if (código == 3)
System.out.println("Alface, couve-flor, brócolis …");
else
System.out.println("Código inválido");
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
67
2) Faça um programa em Java que simule uma calculadora simples a qual executa as
operações: soma, subtração, multiplicação, divisão. O programa deve obter do usuário
dois números do usuário e a operação escolhida. Ao final deve exibir o resultado.
Figura 30 – Programa da calculadora simples
Fonte: Elaborado pela autora
2.6 Pratique
1) Faça um programa que leia 2 números reais e um número inteiro representando uma
das opções abaixo. De acordo com a opção, execute as operações especificadas:
1 - Média aritmética dos números: (𝑛1 + 𝑛2)/2
2 - Média geométrica dos números: √𝑛1 ∗ 𝑛2
3 - Diferença do maior pelo menor (descubra o maior e calcule a diferença)
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
68
4 - Divisão do primeiro pelo segundo: 𝑛1/𝑛2 (se 𝑛2 for diferente de zero!)
5 - O primeiro elevado pelo segundo: 𝑛1 𝑛2
Utilize a instrução 𝑠𝑤𝑖𝑡𝑐ℎ para decidir entre as opções. Se o usuário escolher uma opção
inválida, mostre uma mensagem de erro.
2) Faça um programa que receba o salário de um funcionário e usando a tabela a seguir
calcule e mostre o novo salário, após aplicado o reajuste correto para a faixa:
Faixa salarial % de reajuste no salário
Até R$ 500,00 (inclusive) 30%
Entre R$ 500,00 e R$ 700,00 (inclusive) 25%
Entre R$ 700,00 e R$ 900,00 (inclusive) 20%
Entre R$ 900,00 e R$ 1.200,00 (inclusive) 15%
Acima de R$ 1.200,00 10%
3) Um caixa eletrônico do Banco 24 Horas foi configurado para retornar sempre o menor
número de notas possível. Simule este programa em Java de maneira que, informado o
valor do saque pelo usuário o programa calcule e exiba o número de notas de: 100, de
50, de 20, de 10, de 5, de 2 e de 1 real (suponha existir). Por exemplo, se o usuário
deseja sacar 165 reais, o menor número de notas será: 1 nota de 100, 1 nota de 50, 1
nota de 10 e 1 de 5 reais. Então deve-se priorizar as notas maiores para que o total de
papel moeda entregue seja o menor possível. Observação: o caixa apenas entrega uma
quantia inteira, sem centavos.
4) Faça um programa que dados três números informados pelo usuário exiba-os em ordem
crescente.
Atividade: ao concluir os estudos da 2º semana, vá até
a sala virtual e resolva a atividade “Programando em
Java: final da 2º etapa”.
Nos encontramos na próxima semana.
Bons estudos!
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
69
Mídia digital: assista a vídeos “Aula 9 - Laços de
Repetição (parte 1)”, disponível para a semana 3.
3.1 Laços de repetição
São muito comuns em programas situações em que um dado bloco de comandos
precise ser executado mais de uma vez. Suponha um aplicativo acessível para guiar um
deficiente visual pelas ruas da cidade. Ele cadastrou um destino e está a caminho. Antes de
uma esquina onde deve virar à direita o aplicativo emitirá5 vezes a mensagem: “Na próxima
esquina, vire à direta”.
Como faríamos um código Java para exibir 5 vezes esta mensagem? Usando os
recursos que temos o código ficaria assim:
Aqui escrevemos cinco vezes o mesmo comando. No entanto é comum programas
que precisem executar um dado bloco de instruções dezenas ou centenas de vezes. Fazer
cópias do conjunto de instruções que se repete produziria um código imenso e de difícil
manutenção.
Atenção: o ciclo de desenvolvimento de softwares
não termina na implantação. Manutenções
corretivas e evoluções ocorrerão com frequência.
Por isso, códigos devem ser escritos o mais legível
e estruturados o possível.
Objetivos
Laços de repetição determinados e indeterminados usando os
comandos: while, do-while e for. Variáveis indexadas
(vetores): sintaxe e manipulação.
Semana 3 – Laços de repetição e Vetores
System.out.println("Na próxima esquina, vire à direita”);
System.out.println("Na próxima esquina, vire à direita”);
System.out.println("Na próxima esquina, vire à direita”);
System.out.println("Na próxima esquina, vire à direita”);
System.out.println("Na próxima esquina, vire à direita”);
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
70
Precisamos de uma forma mais eficiente para resolver essas repetições que
chamamos de laços ou loops. Há laços que saberemos previamente, quando escrevemos o
programa22, a quantidade de vezes que se repetirão. A esses chamamos de laços
determinados. Por outro lado, haverá laços que não há como prever o número de vezes
que serão repetidos pois essa quantidade dependerá da instância de execução. Suponha
que o mesmo app23 acessível fosse configurado para repetir o áudio da mensagem até que
o usuário respondesse com um toque na tela indicando que compreendeu o aviso. Nesse
caso a mensagem "𝑁𝑎 𝑝𝑟ó𝑥𝑖𝑚𝑎 𝑒𝑠𝑞𝑢𝑖𝑛𝑎, 𝑣𝑖𝑟𝑒 à 𝑑𝑖𝑟𝑒𝑖𝑡𝑎” seria executada um número
indeterminado de vezes. Esse é um exemplo de laço indeterminado. Em laços
indeterminados o número de repetições de um bloco de instruções só é conhecido no
momento em que o programa está sendo executado, isto é, em tempo de execução.
A seguir veremos os comandos disponíveis em Java para lidar com laços tanto
determinados, quanto indeterminados. São três os comandos possíveis que podem ser
aplicados em ambos os casos.
3.1.1 O comando while
Observe a sintaxe do comando while abaixo. While, em Inglês, significa enquanto.
Então enquanto a 𝑐𝑜𝑛𝑑𝑖𝑐𝑎𝑜 for verdadeira o bloco de instruções interno será executado:
Aqui também 𝑐𝑜𝑛𝑑𝑖𝑐𝑎𝑜 é uma expressão booleana como a dos testes condicionais.
São expressões que retornam true ou false podendo incluir operadores aritméticos,
relacionais e lógicos. A 𝑐𝑜𝑛𝑑𝑖𝑐𝑎𝑜 pode até mesmo ser uma única variável desde que seja do
tipo 𝑏𝑜𝑜𝑙𝑒𝑎𝑛. Nesse caso enquanto a variável for igual a true o bloco é realizado.
Veja o código para as mensagens usando while na Figura 31. Observe que a
mensagem e o 𝑖 + + serão repetidos 5 vezes.
22 Durante a programação, dizemos ‘em tempo de codificação’. Em oposição à “em tempo de execução” o qual depende
da instância de execução.
23 App forma resumida para aplicativo (apps de celular).
while (condicao){
// bloco de instruções do laço
}
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
71
Figura 31 – Laço determinado usando While
Fonte: Elaborado pela autora
No while o bloco de instruções só será executado a primeira vez se a condição for
inicialmente verdadeira. Dizemos que 𝑐𝑜𝑛𝑑𝑖𝑐𝑎𝑜 é uma condição de permanência para
permanecer executando o bloco interno. Então esta expressão deve se tornar falsa em
algum momento. Caso contrário o que teremos é um laço infinito e a finalização do programa
precisará ser forçada.
Atenção ao que é necessário para construir corretamente um laço determinado:
1. Dê valores inicias às variáveis usadas para controlar as repetições do laço. (Na
Figura 31, este é o papel da variável i que é inicializada com 𝑖 = 1)
2. Confira a condição de permanência do laço. Ela deve considerar os valores das
variáveis que controlam o número de repetições. (Na Figura 31, para 5
mensagens, se i é iniciado de 1 então o laço deve executar até que i seja igual a
5. Quando i for igual a 6 a condição será falsa o que fará interromper o laço)
3. Dentro do bloco atualize os valores das variáveis de controle. (Se o 𝑖 + + for
esquecido a condição 𝑖 <= 5 será eternamente verdadeira, gerando um laço
infinito)
Vamos para outro exemplo. Suponha uma contagem regressiva para a largada de
uma corrida de cavalos. O código Java para exibir a contagem regressiva a partir de 10 até
0 será como o da Figura 32. Dos três aspectos anteriores, temos que:
1. A variável de controle é a variável 𝑐𝑜𝑛𝑡𝑎𝑔𝑒𝑚 que foi iniciada de 10
2. A condição está correta pois a contagem é regressiva de 10 até 0, portanto, o
laço deve se repetir enquanto contagem for maior ou igual a 0
3. A variável 𝑐𝑜𝑛𝑡𝑎𝑔𝑒𝑚 está sendo atualizada, nesse caso decrementada, dentro
do bloco com a instrução 𝑐𝑜𝑛𝑡𝑎𝑔𝑒𝑚--
Se 𝑐𝑜𝑛𝑡𝑎𝑔𝑒𝑚 fosse incrementada ao invés de decrementada teríamos aqui também
um loop infinito. Observe que o bloco de instruções do while (comandos nas linhas 13 e 14)
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
72
serão executados onze vezes para: 𝑖 = 10, 𝑖 = 9, 𝑖 = 8, 𝑖 = 7, 𝑖 = 6, 𝑖 = 5, 𝑖 = 4, 𝑖 = 3,
𝑖 = 2, 𝑖 = 1 𝑒 𝑖 = 0. Quando o bloco for executado para 𝑖 = 0, a mensagem exibirá 0 e
𝑐𝑜𝑛𝑡𝑎𝑔𝑒𝑚 será atualizada para −1. Após isso a condição será novamente avaliada
resultando em falso, pois −1 <= 0 é igual 𝑓𝑎𝑙𝑠𝑒, o que irá interromper o while.
Atenção: se o bloco de instruções do laço executa
𝑛 vezes, então a condição do laço será avaliada
𝑛 + 1 vezes!
Figura 32 – Laço determinado usando While
Fonte: Elaborado pela autora
Vejamos como seria um laço indeterminado. Suponha que o funcionário de um
estabelecimento comercial precise contabilizar o valor total em notas promissórias emitidas
no mês. Ele coletou uma pilha e não tem ideia de quantas notas existem para somar. Um
programa do tipo do da Figura 33 poderá ajudá-lo. Veja que o funcionário não será
questionado antecipadamente sobre a quantidade de notas. Após cada nota registrada o
programa pergunta se ele deseja continuar ou parar a contabilização. A depender da
resposta do usuário o laço irá continuar ou terminar. Se o usuário responder com uma
palavra cuja primeira letra seja ‘N’ ou ‘n’ a variável 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑎 que controla o laço será
atualizada para 𝑓𝑎𝑙𝑠𝑒 e a repetição irá terminar. Qualquer outro caractere digitado, diferente
de ‘N’ ou ‘n’, fará o laço continuar. Atenção deve ser dada ao fato de que o programa realiza
uma somatória. Os valores de cada nota são acumulados na variável 𝑣𝑎𝑙𝑜𝑟𝑇𝑜𝑡𝑎𝑙𝑁𝑜𝑡𝑎𝑠. Esta
variável deve ser inicializada com 0 (linha 14). A cada iteração 𝑣𝑎𝑙𝑜𝑟𝑇𝑜𝑡𝑎𝑙𝑁𝑜𝑡𝑎𝑠 é atualizado
somando-se seu valor atual ao valor da nota lida do usuário. Após sair do loop while a
somatória é exibida na mensagem final.
Atividade: pratique programação com os exercícios aqui
propostos, na sequência.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
73
Figura 33 – Laço indeterminado usando While
Fonte: Elaborado pela autora
Mídia digital: assista a vídeos “Aula 10 - Laços de
Repetição (parte 2) ”, disponível para a semana 3.
3.1.2 O comando do..while
Outra alternativa muito similar para estruturas de repetição é o comando do-while.
Observe a sintaxe abaixo:
A diferença aqui é que a condição de permanência é avaliada ao final do laço. Então
o bloco de instruções do laço seráexecutado no mínimo uma vez. Basta ver que na primeira
iteração (primeira execução do bloco de instruções) a entrada ocorrerá sem testes.
Vamos a um exemplo. Imagine que o programa do status de aprovação precise
avaliar as notas de 35 alunos de uma turma. Veja o laço determinado com o do-while no
código da Figura 34. O mesmo cuidado é necessário. A variável que controla o número de
repetições, 𝑖, recebe valor inicial igual a 1. Dentro do laço 𝑖 é incrementado. A condição está
do{
// bloco de instruções do laço
}while(condicao);
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
74
correta pois só será avaliada como 𝑓𝑎𝑙𝑠𝑒 quando 𝑖 for igual a 36. Ao todo serão 35 iterações
(execuções do bloco) e 36 vezes que o teste da condição será avaliado.
Figura 34 – Cálculo do status de aprovação para 35 alunos usando do-while
Fonte: Elaborado pela autora
Vamos supor a seguinte repetição indeterminada. Um programa lê os coeficientes a,
b e c de uma dada equação de segundo grau, calcula e exibe s as raízes reais se existirem.
Quando o usuário digitar um coeficiente 𝑎 = 0, o programa finaliza (vide Figura 35).
O laço é indeterminado já que o número de vezes que serão calculadas as raízes é
desconhecido no momento da codificação do programa. Esse número dependerá dos
valores de a informados pelo usuário em cada iteração. Observe que dentro do laço, após a
leitura de a, o delta e as raízes são calculadas, contanto que a condição do IF da linha 16
seja verdadeira. Essa condição é necessária para não executar os cálculos uma vez que um
a igual a 0 não define uma equação de segundo grau, mas define a saída do laço.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
75
Figura 35 – Laço com do-while para o cálculo das raízes das equações
Fonte: Elaborado pela autora
3.1.3 Break e continue
Há duas palavras-chave que podem ser usadas para mudar o comportamento em
um laço de repetição: 𝑏𝑟𝑒𝑎𝑘 e 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒. O 𝑏𝑟𝑒𝑎𝑘 como já vimos é usado para interromper
um case na seleção com switch. Dentro de um comando de repetição o 𝑏𝑟𝑒𝑎𝑘 interrompe o
laço! Veja o programa da Figura 35 reescrito na Figura 36 a seguir. Se o valor digitado para
𝑎 for igual a 0, o IF da linha 16 é executado e o 𝑏𝑟𝑒𝑎𝑘 faz interromper o do..while. A instrução
seguinte ao do..while será executada. Como o programa exemplo não inclui instrução
seguinte ao do..while, a execução é finalizada. Um detalhe aqui é que o comando de
repetição poderia ser escrito, sem causar mudanças à lógica, como 𝑑𝑜{ . . . }𝑤ℎ𝑖𝑙𝑒(𝑡𝑟𝑢𝑒). Em
ambos os casos, atenção deve ser dada para que o laço finalize em algum momento. A
construção foi empregada apenas para ilustrar o uso do 𝑏𝑟𝑒𝑎𝑘.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
76
Figura 36 – Laço com do-while interrompido com break
Fonte: Elaborado pela autora
A palavra-chave 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒 é usada para desviar para o teste da condição do laço,
deixando de executar as instruções abaixo. Interessante é que para no programa das raízes,
pela forma como está escrito na Figura 36, a substituição do 𝑏𝑟𝑒𝑎𝑘 pelo 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒 no mesmo
ponto do código terá o mesmo efeito: a saída do do..while. Veja na Figura 37. Deve-se, no
entanto, compreender que são comandos distintos! O 𝑏𝑟𝑒𝑎𝑘 interrompe a repetição
independentemente da avaliação da condição do laço. O 𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒 desvia para a para o teste
condicional do loop deixando de executar as instruções seguintes a ele (das linhas 18 a 32
da Figura 37).
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
77
Figura 37 – Caso em que o laço é interrompido se continue for executado.
Fonte: Elaborado pela autora
3.1.4 Laços com o comando For
O terceiro comando de repetição é o For que em Java tem a mesma sintaxe das
linguagens C/C++. No cabeçalho, o For inclui três partes separadas por ponto-e-vírgula:
A primeira delas é usada para inicialização e declaração das variáveis de controle do
laço. A inicialização é executada apenas na primeira iteração. A condição de permanência
é definida na segunda seção do For. Na terceira se atualiza o valor das variáveis
inicializadas, comumente com incrementos ou decrementos. Esta seção é executada da
segunda iteração em diante. Resumindo, na primeira iteração é feita a execução da
inicialização (1ª parte) e o teste da condição (2ª parte). Da segunda iteração em diante
for(inicializacao; condicao; atualizacao){
// bloco de instruções do laço
}
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
78
executa-se a atualização das variáveis (3ª parte) seguida do teste da condição (2ª parte).
Aqui também o laço será executado como no comando while: zero ou mais vezes.
O For pode ser usado tanto em laços determinados quanto em repetições
indeterminadas. O uso mais comum é para laços determinados que envolvem contagens
pois o comando facilita a escrita do programa. Veja o código para o cálculo do produtório da
Figura 38.
Figura 38 – Laço de contagem usando For.
Fonte: Elaborado pela autora
Três aspectos são importantes para serem destacados. Primeiro, a variável 𝑝𝑟𝑜𝑑𝑢𝑡𝑜
é a que acumula o produtório. Ela deve ser inicializada de 1, o valor neutro para
multiplicação. Em cada iteração o 𝑝𝑟𝑜𝑑𝑢𝑡𝑜 será atualizado multiplicando-se seu valor atual
pela i-ésima parcela do produtório. O segundo é que, como a variável 𝑘 foi criada dentro do
For ela só estará acessível dentro do bloco. O uso de 𝑘 após o For exige sua declaração
fora do laço. Lembre-se: o escopo de variáveis é no bloco em que for declarada.
Por último, não menos importante é a conversão do numerador de 𝑖𝑛𝑡 para 𝑑𝑜𝑢𝑏𝑙𝑒.
Para isso uma coerção para o tipo indicado entre parênteses: (𝑑𝑜𝑢𝑏𝑙𝑒). Lembre-se que a
conversão para double é necessária para que a divisão seja exata já que os operandos da
divisão, (𝑘 + 1) e 2 ,são inteiros.
A Figura 39 mostra o uso do For para o laço indeterminado do programa das raízes
(Figura 36). O exemplo ilustra que cada seção (inicialização, condição e atualização) é
opcional. É possível até mesmo omitir todas elas ao usar um 𝑓𝑜𝑟 ( ; ; ), como na linha 13 da
int k;
for(k = 1; k <= 5; k++){
// …
}
// Aqui k estará acessível. Após o For k será igual a 6!
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
79
Figura 39. Nesse caso, a repetição terá a forma de um 𝑤ℎ𝑖𝑙𝑒(𝑡𝑟𝑢𝑒)24 onde a interrupção do
laço deverá ser feita por um 𝑏𝑟𝑒𝑎𝑘, p. ex.. Embora essa construção seja permitida é preciso
atenção, pois essa estrutura dificulta a depuração do programa. Se o 𝑏𝑟𝑒𝑎𝑘 não for
executado o laço se tornará infinito.
Figura 39 – Laço indeterminado com For.
Fonte: Elaborado pela autora
3.2 Exercícios resolvidos
1) É comum e necessário que um programa sempre faça a consistência ou validação de
dados de entrada informados pelo usuário. Suponha por exemplo que o mesmo deva
informar uma nota de 0 a 100. O código deve verificar o caso de nota inválida, exigindo
24 while(true){ //bloco} ou do{ //bloco }while(true);
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
80
nova digitação. Inclua este teste em um programa Java. A validação implica num laço
indeterminado.
Figura 40 – Exercício 1 – seção 2.6
Fonte: Elaborado pela autora
2) Faça um programa em Java que exiba todos os números pares entre 2 e X, onde X é um
inteiro lido pelo usuário. Faça a verificação de X o qual deve ser maior que 2.
Figura 41 – Exercício 2 – seção 2.6
Fonte: Elaborado pela autora
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoriade Extensão
81
3) Dados três números fornecidos pelo usuário, use repetição para ordenar os números e
exibi-los em ordem crescente.
Figura 42 – Exercício 3 – seção 2.6
Fonte: Elaborado pela autora
4) Um processamento muito comum é realizar estatísticas do tipo maior valor, menor valor,
média dos valores informados, etc. Faça um programa que leia 10 números do usuário,
calcule e exiba o maior deles no console.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
82
Figura 43 – Exercício 4 – seção 2.6
Fonte: Elaborado pela autora
3.3 Pratique
1) Simule a execução do programa abaixo e aponte sua saída. Para isso anote os valores
de cada variável na tabela ao lado. A cada novo valor escreva-o abaixo na coluna e risque
o valor anterior.
Figura 44 – Exercício 1 – seção 2.7
Fonte: Elaborado pela autora
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
83
2) Simule a execução do programa que calcula o maior entre 5 números digitados pelo
usuário. Suponha a digitação dos números na coluna à direita da tabela para a variável
𝑣𝑎𝑙𝑜𝑟. Para cada valor de 𝑖 verifique e atualize o valor de 𝑚𝑎𝑖𝑜𝑟, se este mudar.
Figura 45 – Exercício 2 – seção 2.7
Fonte: Elaborado pela autora
3) Altere o programa da Figura 45 para calcular o menor número digitado pelo usuário.
Generalize o código para aceitar X números ao invés de apenas 5. Solicite inicialmente
do usuário o valor de X.
4) Escreva um programa que leia um número inteiro n, calcule e mostre o valor do seguinte
somatório: ∑ 2𝑖𝑛𝑖=0
5) Considere as seguintes faixas etárias: criança (de 0 a 10 anos), adolescente (de 11 a 16
anos), Jovem (de 17 a 26 anos), adulto (de 27 a 59 anos) e idoso (acima de 60 anos).
Faça um programa que leia a idade de 20 pessoas e mostre para cada uma qual a faixa
etária que pertence.
6) Faça um programa que leia uma quantidade indeterminada de valores inteiros do usuário.
O programa deve exibir quantos são maiores que 82, quantos números são menores que
18 e quantos números informados estão no intervalo [18, 82]. Faça uma versão do
programa para cada uma das três estruturas de repetição estudadas: while, do..while e
for.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
84
7) Escreva um programa que calcule o valor total a ser pago em uma compra no
supermercado. O programa deve ler a quantidade e o preço unitário de cada produto,
calcular e acumular o subtotal a cada iteração do laço. Considere que a compra só será
encerrada quando o caixa que opera o programa digitar um valor menor ou igual a zero
para a quantidade do produto. Ao final o programa deve apresentar o total a pagar.
8) Construa um programa que leia a idade e o estado civil (C - casado, S - solteiro, O -
outros) para uma pesquisa com um conjunto de pessoas. A quantidade de pessoas é
desconhecida pelo pesquisador. Use um laço indeterminado. O programa deve calcular
e exibir:
a) Quantidade de pessoas solteiras
b) Média da idade das pessoas casadas
c) Qual é a idade da pessoa mais velha.
Atividade: vá até a sala virtual e resolva a atividade
“Programando em Java: exercício 2”, disponível na
semana 3
Mídia digital: assista aos vídeos 11 e 12 intitulados
“Manipulando vetores em Java” disponíveis na sala
virtual para a semana 3.
Atividade: após estudar o conteúdo das seção a seguir
resolva os exercícios propostos na sequência.
3.4 Estruturas de dados indexadas: vetores
Um vetor define um conjunto de variáveis que serão armazenadas em posições
consecutivas na memória do computador. Todos esses dados devem ser do mesmo tipo
de dado e o número deles define o tamanho do vetor. Vetores são úteis pois tratamos todo
o conjunto de dados como uma unidade: uma variável do tipo vetor. Ao definir um vetor
devemos definir o seu tamanho, isto é, o número máximo de elementos que poderão ser
armazenados nele. Observe a sintaxe para declaração e definição de vetores. Os colchetes
[ e ] na declaração são obrigatórios:
//Declara e em seguida instancia o vetor v:
int v[]; // ou int[] v;
v= new int[15]; //cria um vetor para 15 elementos do tipo int
//Declara e instancia o vetor nome na mesma linha:
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
85
String[] nome= new String[3]; //um vetor para 3 elementos String
//Declara e instancia o vetor x de double:
double x[]= new double[20]; //cria um vetor de 20 posições de double
Os colchetes na declaração podem vir após o tipo ou após o nome da variável:
< 𝑡𝑖𝑝𝑜 > [] 𝑣𝑎𝑟; ou < 𝑡𝑖𝑝𝑜 > 𝑣𝑎𝑟[];
Veja que ao declarar o tipo da variável estamos definindo que todos os elementos do
vetor serão do mesmo tipo. Por esse motivo um vetor, ou array, do Inglês, é chamado de
variável composta homogênea, ou estrutura de dados homogênea. O termo indexado
também é usado, observe o título da seção. O motivo será explicado a seguir.
Podemos declarar a variável vetor e posteriormente alocar a memória necessária ao
informar o número de elementos entre colchetes, como em: 𝑑𝑜𝑢𝑏𝑙𝑒[20], 𝑆𝑡𝑟𝑖𝑛𝑔[3] e 𝑖𝑛𝑡[15].
Esta alocação nada mais é que a criação do vetor, propriamente dito. Afinal, o computador
deve saber o tamanho para alocar espaço em memória o suficiente para abrigar todos os
elementos. Além disso, é importante adiantar que vetores em Java são como objetos
devendo ser instanciados ou criados previamente, com um 𝑛𝑒𝑤. Antes de instanciar um vetor
com 𝑛𝑒𝑤 não será possível manipular seus elementos.
Outro detalhe importante é a atribuição em linha para os elementos de um vetor.
Nesse caso não precisamos definir o tamanho, este será deduzido pelo número de valores
informados entre { e }, separados por vírgula.
//Define e dá valores iniciais para os elementos do vetor x!
// 0.1 será o 1º elemento, 1.5 o 2º, -0.98 o 3º e 0.09 o 4º elemento
//A atribuição em linha é possível apenas na declaração de um vetor:
double x[]= {0.1, 1.5, -0.98, .09};
//Define e dá valores iniciais para os elementos do vetor nome
//nome poderá ter no máximo 5 elementos
String nome[]= {“Josué do Carmo”,”Jeruza Silva”,
“Roberto Carlos”, “Ronaldo Barros”,
”Francisco Franco”};
Para manipular os elementos de um vetor é simples: basta informar o nome do vetor
e a posição do elemento que desejamos entre colchetes. Em Java, o primeiro elemento de
um vetor é armazenado na posição 0, ou seja, no índice 0. Se um vetor possui 3 posições
seus elementos serão armazenados nos índices de 0 à 2:
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
86
//Atribuição de valores
double x[] = new double[3];
x[0]= .1;
x[1]= 1.5;
x[2]= 100.5;
//Uso dos valores
double soma= x[0] + x[1] + x[2]; //soma = .1 + 1.5 + 100.5 =102.1
int i = 0;
System.out.println(nome[i]); // nome[0] que é Josué do Carmo
Observe que o emprego de variável para indexar um elemento (𝑛𝑜𝑚𝑒[𝑖]) é válido e
muito útil. Uma tentativa de acessar um índice fora dos limites de um vetor faz disparar um
erro em tempo de execução. Erros de tempo de execução são chamados de exceção em
Java. Ao executar, o programa da Figura 46 será interrompido e o aviso da exceção é exibido
em vermelho. O índice acessado é exibido à frente da exceção
ArrayIndexOutOfBoundException. A linha 14 que originou o erro é informada na mensagem.
Para não correr o risco de acessar um índice fora de um array usamos o atributo
𝑙𝑒𝑛𝑔𝑡ℎ que guarda o tamanho do vetor. A sintaxe é: < 𝑣𝑎𝑟𝑖𝑎𝑣𝑒𝑙𝑉𝑒𝑡𝑜𝑟 >. 𝑙𝑒𝑛𝑔𝑡ℎ. Para o vetor
𝑥 da Figura 46, 𝑥. 𝑙𝑒𝑛𝑔𝑡ℎ retornará 3. Para 𝑥 só é possível acessar os elementos nas
posições de 0 à 𝑥. 𝑙𝑒𝑛𝑔𝑡ℎ.
Quando trabalhamos com vetores a vantagem é o uso de estruturas de repetiçãopara
realizar a atribuição de valores aos elementos, varreduras, pesquisas, etc. A praticidade é
devida à possibilidade de a mesma variável de controle do laço ser usada para indexar cada
elemento. Observe o programa da Figura 47. Para cada elemento teremos uma mensagem
seguida da entrada de dados para a idade. Há, portanto, uma repetição! Para generalizar
basta indexar o vetor com a variável 𝑖, como na linha 18.
Vamos continuar o programa incluindo o cálculo da média das idades e a
contabilização de quantos valores estão acima da média. Obviamente, primeiro precisamos
contabilizar a média para em seguida calcular a quantidade de pessoas com idade acima da
média. Duas repetições serão necessárias aqui: a primeira para leitura e somatória das
idades; a segunda, feita após o cálculo da média, será necessária para a segunda
estatística. Veja o programa completo na Figura 48.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
87
Figura 46 – Exceção de acesso a índice fora dos limites do vetor
Fonte: Elaborado pela autora
Lembre-se! Devemos utilizar o mínimo de recursos computacionais, então
precisamos varrer o vetor o menor número de vezes.
Figura 47 – Preenchendo um vetor de inteiros
Fonte: Elaborado pela autora
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
88
Figura 48 – Calculando estatísticas com base em dados em vetor
Fonte: Elaborado pela autora
3.5 Exercícios resolvidos
1) Altere o programa da Figura 48 para exibir também a menor e a maior idade.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
89
Figura 49 – Cálculo do maior e menor valor em um vetor
Fonte: Elaborado pela autora
2) Após preencher dois vetores, A e B, de inteiros cujo número de elementos e valores serão
informados pelo usuário. Crie um terceiro vetor para armazenar o produto: C = A x B. O
programa deve exibir os três vetores, ao final.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
90
Figura 50 – Produto de dois vetores
Fonte: Elaborado pela autora
3) Leia um vetor de nomes para os convidados de uma festa. Em seguida o usuário
informará um nome para pesquisa na lista. Se o nome informado estiver no vetor o
programa deverá exibir a mensagem “Foi convidado”, caso contrário exibirá “Não foi
convidado”. Lembre-se de realizar a pesquisa pelo nome desconsiderando maiúsculas e
minúsculas.
Atenção: o programa a seguir usa dois objetos
Scanner: um para a leitura do inteiro e outro para a
leitura dos nomes. Esse artifício resolve o problema da
leitura com objetos Scanner que vem após chamadas
ao método nextLine(). Isso evita que algumas entradas
de dados sejam ‘desconsideradas’.
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
91
Atenção: embora não seja fonte de erros para
programas menores, após a leitura de dados com
Scanner, uma chamada ao método close() é
necessária. O fechamento do stream de leitura devolve
o recurso de entrada/saída ao sistema operacional.
Figura 51 – Pesquisa um nome em um vetor de nomes
Fonte: Elaborado pela autora
Plataforma +IFMG
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
92
3.6 Pratique
1) Leia um vetor de 10 números inteiros dados pelo usuário. Exiba os elementos do vetor
na ordem inversa à leitura: do último ao primeiro número elemento.
2) Dado um vetor de inteiros de x posições informadas pelo usuário, calcule e exiba a soma
dos elementos do vetor.
3) Um técnico deseja convocar um time jogadores anotando os nomes dos 11 titulares e
dos 11 reservas para um torneio regional. Seu programa deve armazenar os nomes em
dois vetores distintos: um para titulares e outro para reservas. Em seguida o programa
deve obter um nome de jogador para uma pesquisa em ambos os vetores. O técnico
deseja saber se o nome informado é titular, reserva ou não foi convocado. Faça
comparação ignorando maiúsculas e minúsculas.
4) Leia para um conjunto de alunos seus nomes e suas notas finais. Armazene os valores
em dois vetores: uma para nomes e outro para notas. O número de alunos na turma será
informado pelo usuário. O programa deve calcular a média das notas e exibir o nome e
a nota final dos alunos com notas inferiores à média da turma. Também deve exibir os
nomes e notas dos que alcançaram rendimento igual ou acima da média. Por fim, o
programa deve informar o nome do aluno que obteve a menor nota da turma e o nome
do aluno que obteve a maior nota.
Atividade: Após concluir a terceira semana de estudos
vá até a sala virtual e realize a atividade “Programando
em Java: final da 3ª etapa”.
Nos encontramos na próxima semana.
Bons estudos!
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 93
“A arte de programar consiste na arte de organizar e dominar a complexidade dos
sistemas” (Dijkstra, 1972)
4.1 Evolução da programação
Desde a época inicial a programação de computadores passa por evoluções
tecnológicas significativas. Na época dos primeiros computadores digitais a atividade de
programar era realizada pela manipulação direta de cabos e chaves. Em seguida, os
programas passaram a ser digitalizados e armazenados na memória do computador, assim
como os dados. No entanto, a programação ainda era feita em linguagem de máquina, algo
muito trabalhoso para sistemas complexos.
Um grande avanço veio com a concepção de linguagens de programação de alto
nível. FORTRAN e COBOL são alguns exemplos das primeiras linguagens importantes. Aqui
já não é mais necessário se preocupar com detalhes de funcionamento do hardware para
poder programá-lo. Daqui em diante o programador pôde se dedicar ao processamento de
informações para a solução do problema, abstraindo-se dos detalhes de operação da
máquina.
À medida que a programação se expandiu da academia e indústria para a atividade
comercial os sistemas foram crescendo em complexidade. A engenharia de software surge
na tentativa de buscar soluções aos altos custos de desenvolvimento e manutenções
frequentes. Muitos softwares em processo de desenvolvimento nem chegaram a ser
concluídos.
As linguagens de programação também necessitavam de evolução. Desta crise, um
primeiro paradigma de programação que surgiu foi a programação imperativa que passou a
incorporar a modularização. A programação modular foi uma técnica que proporcionou um
certo controle da complexidade das soluções. Ela se baseia na decomposição de um
processamento em partes menores, denominadas de módulos. Cada módulo fica
responsável por executar uma porção da funcionalidade do sistema.
Com a programação modular as linguagens como C/C++ passam a incluir recursos
para permitir a definição de subprogramas ou sub-rotinas. Uma sub-rotina é escrita uma
Objetivos
Definindo funções e procedimentos em métodos estáticos
Java. Treinando sintaxe Java em aplicações com interface
gráfica (conteúdo em formato de videoaulas). Introdução aos
conceitos e à sintaxe para definição de classes e objetos.
Semana 4 – Modularização: uma introdução
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 94
única vez pelo programador podendo ser chamada à execução quantas vezes for
necessário. Aqui o foco está em conceber soluções com base na decomposição das
funcionalidades do programa.
As próximas seções abordam sobre a definição e o uso de sub-rotinas as quais
chamamos de funções e procedimentos. A compreensão deste tema é de extrema
importância para a orientação a objetos, outra evolução em termos de paradigma de
programação. A linguagem Java foi concebida para a programação orientada a objetos, um
assunto que apenas introduzimos na última seção.
4.2 Sub-rotinas e os desvios no fluxode execução
Suponha que um programa precise calcular o número de combinações a partir de ‘n’
elementos tomados ‘p’ a ‘p’. A necessidade é calcular o número de subconjuntos de ‘p’
elementos formatos a partir de ‘n’ elementos onde cada elemento ocorra uma única vez no
subconjunto. Conhecemos a fórmula para o cálculo: 𝑐𝑝,𝑛 =
𝑛!
𝑝!(𝑛−𝑝)!
. A fórmula usa três
cálculos de fatorial.
O cálculo do fatorial de um número exige repetições para as multiplicações
sucessivas de 1 até o número inteiro dado. O fatorial de 5, p. ex., é calculado como: 5 ∗ 4 ∗
3 ∗ 2 ∗ 1 = 120 . Analise o que muda em cada cálculo de fatorial da Figura 52. A única
diferença aqui é o limite do laço de cada For: 𝑛 , (𝑛 − 𝑝) e 𝑝. Se construirmos uma sub-rotina
que dado um valor 𝑥 qualquer ela calcule e retorne o fatorial de 𝑥 eliminamos esta repetição
desnecessária.
Figura 52 – Fatoriais envolvidos no cálculo de combinações
Fonte: Elaborado pela autora
Para o código da sub-rotina a qual será desenvolvida a parte é dado um nome,
digamos: 𝑓𝑎𝑡. Escrevemos o código de 𝑓𝑎𝑡 uma vez. No código iremos definir que essa sub-
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 95
rotina deve receber um valor inteiro, calcular o fatorial desse inteiro e retornar o resultado.
Fazemos isso ao definir que 𝑓𝑎𝑡 recebe do código chamador (o código cliente que precisa
do processamento de fatorial) um valor inteiro como parâmetro para seus cálculos. Todas
as vezes que o programa necessitar calcular o fatorial, basta chamar a sub-rotina pelo nome
informando o parâmetro.
Desse modo, o cálculo de combinações no programa não virá após três repetições
para o cálculo dos três fatoriais. Ao invés disso, será possível até mesmo invocar três vezes
a sub-rotina 𝑓𝑎𝑡() dentro da própria fórmula de combinações, como o código abaixo:
Veremos a seguir como construir e chamar sub-rotinas em Java, sem fazer uso da
programação orientada a objetos. Antes precisamos compreender mais detalhes.
Uma sub-rotina nada mais é que um subprograma, isto é, um bloco de instruções com
um único objetivo de processamento. É um código desenvolvido à parte e identificado por
um nome. Uma sub-rotina é executada sempre que for invocada ou chamada à execução
pelo código cliente. O código cliente, ou código chamador, é o código dentro do qual haverá
a chamada à sub-rotina. É cliente uma vez que solicita o serviço oferecido pela sub-rotina
(código chamado).
Como um subprograma, toda sub-rotina irá processar dados! Quando um ou mais
desses dados são conhecidos do código chamador, então esse deve transmiti-los à sub-
rotina. Essa comunicação de dados à sub-rotina é feita por meio da passagem de
parâmetros. Então, parâmetros são áreas de memória preenchidas pelo código chamador
e manipuladas pelo código chamado, em cada invocação. Cada parâmetro se refere a um
dado que será tratado como uma variável local dentro da sub-rotina. Após a execução, toda
a área de memória utilizada pela sub-rotina, incluindo parâmetros e variáveis locais, será
desalocada, isto é, será devolvida ao sistema operacional.
Então veja, estamos nos referindo a um código com estrutura semelhante ao de um
programa (entrada, processamento, saída) que é identificado por um nome, executa uma
única tarefa claramente definida e é escrito uma única vez. A vantagem, aqui, além da
reutilização, é que podemos construir e testar sub-rotinas independentemente do resto da
aplicação. Além disso, a aplicação terá um código mais limpo uma vez que se decompõe a
funcionalidade como um todo em módulos coesos, chamando-os à execução sempre que
necessário.
Toda vez que um código chamador X invocar uma sub-rotina Y, haverá um desvio no
fluxo de execução de X para Y. Observe a Figura 53. A execução de X segue sem desvios
até a chamada à Y. Esta chamada deverá ser resolvida pelo computador. Antes de executar
Y, o computador salva o estado atual de X (suas variáveis locais e demais recursos) e um
endereço de retorno para reiniciar a execução após Y. Então, a execução de X é suspensa
e o fluxo é desviado para Y. Y é executado até finalizar. O retorno é feito de acordo com o
endereço salvo anteriormente, para a instrução seguinte à invocação em X.
double combinacoes;
combinacoes = fat(n)/(fat(p)*fat(n-p));
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 96
Figura 53 – Desvio do fluxo para execução de sub-rotina
Fonte: Elaborado pela autora
É muito comum que exista mais de um código cliente suspenso aguardando a
resolução de chamadas em um programa em execução. Esse cenário é ilustrado na Figura
54.
Figura 54 – Pilha de execução entre chamadas.
Fonte: Elaborado pela autora
O programa principal (main) invocou a sub-rotina A e foi suspenso. Ao executar, A
fez uma chamada à B. A foi suspensa e o fluxo de execução foi desviado para B. Enquanto
B não finalizar A não será retomada. Durante a execução de B uma de suas instruções é
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 97
uma chamada à C. Então B também foi suspenso e o fluxo agora está executando C. Nesse
momento, B, A e o programa principal estão todos parados, aguardando cada qual a sub-
rotina que chamaram retornar. O programa principal aguarda A, A aguarda B que aguarda
C. Quando C finalizar, o fluxo volta para B. Assim que B terminar, a execução de A será
retomada. Por fim, quando A finalizar a execução será desviada de volta ao programa
principal.
Precisamos compreender como ocorre o fluxo de execução de um programa. O
controle dessa execução é feito pelo computador. Observe o estado da pilha de chamadas
ilustrada na Figura 54. Será sempre a sub-rotina do topo da pilha aquela que o computador
irá retomar primeiro. O estado da pilha após a retomada à B terá A no topo, então após B o
computador vai desviar para A, e assim sucessivamente, até voltar ao programa principal.
Mídia digital: assista aos vídeos 13 e 14 intitulados
“Criando sub-rotinas com métodos estáticos”, disponível
na semana 4.
Atividade: após estudo da seção a seguir, resolva os
exercícios propostos na sequência.
4.3 Procedimentos e funções em métodos estáticos
Há duas categorias de sub-rotinas: funções e procedimentos. Tanto funções quanto
procedimentos podem receber ou não parâmetros. A diferença está no retorno. Funções
devem retornar algum dado ao código cliente. Esse é o caso da função 𝑓𝑎𝑡 da seção anterior
que calcula e retorna o resultado do fatorial. Já um procedimento não retorna nenhum valor
ao código chamador.
Definimos procedimentos e funções como métodos em Java. O tipo de retorno de um
método função é qualquer tipo válido da linguagem, inclusive os tipos de dados primitivos.
Definimos que um método é um procedimento quando no lugar do tipo de retorno inserimos
a palavra-chave void, que significa vazio ou ausência de dados. Procedimento e função são
conceitos. Quando não for necessário diferenciar o termo empregado será apenas método.
Há métodos de objetos e métodos de classes. Métodos no escopo de classes são
marcados com static. Esse é o caso do método main que faz da classe uma classe
executável (Figura 3). Trabalhamos com métodos estáticos nesta iniciação já que não
aprofundamos na programação orientada a objetos. Para chamar um método estático
incluímos o nome da classe seguido de ponto e do nome do método:
< 𝑁𝑜𝑚𝑒𝐷𝑎𝐶𝑙𝑎𝑠𝑠𝑒 >. < 𝑛𝑜𝑚𝑒𝐷𝑜𝑀𝑒𝑡𝑜𝑑𝑜 > ( )
Se o código chamador é um método da mesma classe do método chamado <
𝑁𝑜𝑚𝑒𝐷𝑎𝐶𝑙𝑎𝑠𝑠𝑒 > pode ser omitido usando-se apenas: < 𝑛𝑜𝑚𝑒𝐷𝑜𝑀𝑒𝑡𝑜𝑑𝑜 > ( )
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 98
Observe a sintaxe para definição de métodos estáticos:
Um método público fica acessível para toda a aplicação. Há outros modificadores de
acesso além de 𝑝𝑢𝑏𝑙𝑖𝑐 como o acesso privado, o restritoa pacotes ou o acessível pela
hierarquia de classes. Esses detalhes são importantes na programação orientada a objetos
que é apenas introduzida ao final deste curso.
Para nomear um método siga as mesmas regras de identificadores da seção 1.2.1.
Se não houver parâmetros os parênteses ficam vazios. Se houver mais de um parâmetro
eles devem vir separados por vírgula. Para cada parâmetro deve-se informar tipo de dados
e nome:
A Figura 55 mostra o método 𝑓𝑎𝑡 para cálculo do fatorial do parâmetro 𝑥. O método
define a variável local 𝑓𝑎𝑡𝑜𝑟𝑖𝑎𝑙 para acumular o produtório que é iniciado de 1. O valor de
𝑓𝑎𝑡𝑜𝑟𝑖𝑎𝑙 será retornado ao código chamador com o uso da palavra-chave 𝑟𝑒𝑡𝑢𝑟𝑛. Todos os
métodos do tipo função devem incluir um 𝑟𝑒𝑡𝑢𝑟𝑛. Se o retorno declarado no cabeçalho do
método é do tipo 𝑖𝑛𝑡 então a expressão após o 𝑟𝑒𝑡𝑢𝑟𝑛 (nesse caso, a variável 𝑓𝑎𝑡𝑜𝑟𝑖𝑎𝑙) deve
ser do mesmo tipo, caso contrário ocorre erro de incompatibilidade de tipos, em tempo de
compilação.
Figura 55 – Método do tipo função para o cálculo do fatorial
Fonte: Elaborado pela autora
Agora podemos chamar 𝑓𝑎𝑡 para calcular as combinações da seção anterior. Veja a
classe 𝐶𝑜𝑚𝑏𝑖𝑛𝑎𝑐𝑜𝑒𝑠 da Figura 56. Nela 𝑓𝑎𝑡 é um método definido dentro da mesma classe
do código cliente: o método 𝑚𝑎𝑖𝑛. Toda chamada à 𝑓𝑎𝑡 deve informar o parâmetro esperado,
do tipo inteiro. Os valores de 𝑛 e 𝑝 são lidos do usuário antes de serem passados nas
chamadas.
A passagem de parâmetros em Java é por cópia. Isso significa que o valor de cada
parâmetro real nas chamadas (𝑛, 𝑝 ou 𝑛 – 𝑝) é copiado para o parâmetro formal (𝑥).
Chamamos de parâmetro real aquele cujo valor é realmente comunicado ao método. O
parâmetro formal 𝑥 é apenas um rótulo para o valor passado. O rótulo é necessário para que
public static <tipoDeRetorno> <nome> (<listaDeParâmetros>)
public static <tipoDeRetorno> <nome> (<tipoDeDado> par1,...,<tipoDeDado> parN)
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 99
o dado seja internamente manipulado pelo método tal como as variáveis locais como é o
caso da variável 𝑓𝑎𝑡𝑜𝑟𝑖𝑎𝑙.
Parâmetros formais e variáveis locais só existem enquanto o método está sendo
executado. Após a execução de cada chamada a área de memória ocupada será destruída.
Tenha em mente que é apenas quando escrevemos o código do método que definimos os
parâmetros (formais) com nome e tipo. Na chamada apenas informamos os parâmetros
reais sem indicar tipo. O tipo dos parâmetros nas chamadas é deduzido pelo compilador.
Figura 56 – Chamada do método fat pelo método main
Fonte: Elaborado pela autora
Observe a chamada à 𝑓𝑎𝑡 na linha 18. Nessa chamada o conteúdo da variável 𝑛 é
copiado para o parâmetro 𝑥 de 𝑓𝑎𝑡. Note que, sendo 𝑓𝑎𝑡 uma função é como se o método
‘armazenasse’, após sua execução, o seu resultado. Veja a atribuição de 𝑓𝑎𝑡(𝑛) à variável
𝑓𝑎𝑡𝑁. As linhas 19 e 20 fazem o mesmo. Funções são chamadas dentro de expressões. De
fato, a sentença da linha 22 poderia ser reescrita assim:
𝑐𝑜𝑚𝑏𝑖𝑛𝑎çõ𝑒𝑠 = 𝑓𝑎𝑡(𝑛)/(𝑓𝑎𝑡(𝑝) ∗ 𝑓𝑎𝑡(𝑛 − 𝑝));
Quanto ao fluxo de execução, observe que haverá três desvios, um para cada
chamada da função: linha 18, 19 e 20. Em cada execução o método main ficará suspenso
e o fluxo será desviado para o método 𝑓𝑎𝑡 (linhas de 27 à 33) que executa até o 𝑟𝑒𝑡𝑢𝑟𝑛.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
100
Vamos a um exemplo de método da categoria de procedimentos. Suponha um
método responsável pelo seguinte processamento. Dado um arquivo de texto e uma String
ele deve escrever uma linha contendo a cadeia informada ao final do arquivo. Observe o
código do método 𝑖𝑚𝑝𝑟𝑖𝑚𝑒𝐿𝑖𝑛ℎ𝑎() destacado na Figura 57. Embora o procedimento realize
saída em arquivo ele não retorna dados ao código chamador, por isso o uso de void.
Observe também que a chamada de um método void gera uma sentença independente,
diferente de métodos que retornam valor (função) que aparecem dentro de expressões. A
sentença da linha 25 é apenas a invocação do procedimento:
𝑖𝑚𝑝𝑟𝑖𝑚𝑒𝐿𝑖𝑛ℎ𝑎(𝑎𝑟𝑞𝑢𝑖𝑣𝑜, 𝑒𝑛𝑡𝑟𝑎𝑑𝑎);.
A classe 𝑃𝑟𝑖𝑛𝑡𝑊𝑟𝑖𝑡𝑒𝑟 foi usada para escrever caracteres no arquivo “arquivo.txt”. A
cada linha digitada pelo usuário o procedimento é invocado. Ao executar o programa o
arquivo será criado no diretório raiz do projeto Java. É importante destacar que para realizar
entrada/saída o primeiro passo é abrir o arquivo (linha 17). O último passo deve ser esvaziar
o buffer com 𝑓𝑙𝑢𝑠ℎ (para transferir os dados restantes em memória para o armazenamento
permanente) e fechar o arquivo (linha 29). Como a realização de entrada/saída está sujeita
a erros de tempo de execução é necessário informar a exceção no cabeçalho do método
main (linha 12), ou inserir o tratamento do erro dentro do programa25.
Figura 57 – Método com retorno void para escrita em arquivo
Fonte: Elaborado pela autora
25 O tratamento de exceções está fora do escopo deste curso.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 101
4.4 Exercícios resolvidos
1) Faça um método estático do tipo procedimento para exibir no console as linhas abaixo.
Observe que não é necessário passar parâmetros. Teste invocando uma vez o
procedimento dentro do método main:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
Figura 58 – Seção 3.4 – Exercício 1
Fonte: Elaborado pela autora
2) Em uma classe inclua um método estático que recebe um vetor de inteiros, calcula e
retorna a média dos elementos do vetor. Chame-o do método de main:
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 102
Figura 59 – Seção 3.4 – Exercício 2
Fonte: Elaborado pela autora
3) Suponha que o vetor da questão anterior armazene a idade de 20 pessoas. Use o
método média já construído na Figura 59. O programa deve calcular e exibir quantas
pessoas possuem idade acima da média. Faça esse cálculo em outro método estático
que será chamado a partir do main. Exiba a média e a quantidade de pessoas com idade
acima da média ao final.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 103
Figura 60 – Seção 3.4 – Exercício 3
Fonte: Elaborado pela autora
4.5 Pratique
1) Cite e explique a(s) vantagem(ns) de definir procedimentos e/ou funções em programas.
2) Faça um método estático do tipo procedimento para exibir no console as linhas abaixo.
Observe que não é necessário passar parâmetros. Teste invocando uma vez o
procedimento dentro do método main:
5
5 4
5 4 3
5 4 3 2
5 4 3 2 1
3) Generalize o método estático da questão anterior para exibir no console as linhas abaixo.
Nesse caso, o procedimento receberá como parâmetro o valor de x. Teste invocando
uma vez o procedimento dentro do método main:
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 104
𝑥
𝑥 𝑥 − 1
𝑥 𝑥 − 1 𝑥 − 2
𝑥 𝑥 − 1 𝑥 − 2 𝑥 − 3
𝑥 𝑥 − 1 𝑥 − 2 𝑥 − 3 𝑥 − 4
. . .
𝑥 𝑥 − 1 𝑥 − 2 𝑥 − 3 𝑥 − 4 … 1
4) Escreva uma classe Java executável que defina e teste um método estático do tipo
função que dado dois inteiros como parâmetro, calcule e retorne valor do primeiro inteiro
elevado ao segundo. Tente resolver a potenciação aplicando multiplicações sucessivas.
5) Desenvolva um método para validar o CPF passado via parâmetro. Pesquise sobre a
validação de CPF. O método deve retornar true se o CPF for válido ou false, caso
contrário. Teste invocando o método com seu CPF dentro do método main.
6) Faça um método estático do tipo função, chamado Aumento. O método irá receber dois
valores reais (X e Y) como parâmetros, calcular e retornar o aumento de X em Y%. Teste
o método em main no qual o valor de X representará o preço à vista deuma mercadoria
em uma loja de roupas e Y o percentual de acréscimo para o pagamento com cartão.
7) Faça um método que receba como parâmetro três números inteiros: a, b e c. O método
deve calcular e retornar o maior dos três. Chame esse método a partir do método main
da classe para testá-lo.
8) Faça uma classe Java executável para resolver o seguinte problema. Dados dois vetores,
um para as idades e outro para os respectivos salários de 27 funcionários de uma
empresa, o programa deve calcular e exibir a média dos salários dos funcionários com
mais de 40 anos. O método main deve ler os dois vetores do usuário e chamar o seguinte
método estático para realizar o cálculo:
𝑝𝑢𝑏𝑙𝑖𝑐 𝑠𝑡𝑎𝑡𝑖𝑐 𝑑𝑜𝑢𝑏𝑙𝑒 𝑚𝑒𝑑𝑖𝑎(𝑑𝑜𝑢𝑏𝑙𝑒 𝑠𝑎𝑙𝑎𝑟𝑖𝑜[], 𝑖𝑛𝑡 𝑖𝑑𝑎𝑑𝑒[], 𝑖𝑛𝑡 𝑖𝑑𝑎𝑑𝑒𝑇𝑒𝑠𝑡𝑒)
Dica do professor: armazene a idade e o salário dos
funcionários em vetores diferentes, mas, de maneira
que, o indivíduo com idade[0] terá o salário
armazenado na mesma posição 0 do vetor salário (ou
seja, salario[0]), o de idade[1] o salário ficará em
salario[1], e assim por diante.
9) Faça um método estático que dado um inteiro i informado, via parâmetro, calcule e
retorne o i-ésimo número da sequência de Fibonacci. O cálculo da sequência de
Fibonacci é feito como abaixo:
𝑓0 = 0, 𝑓1 = 1, 𝑓2 = 1, . . , 𝑓𝑛 = 𝑓𝑛 − 1 + 𝑓𝑛 − 2
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 105
Os seis primeiros números da sequência são: 0, 1, 1, 2, 3, 5. Temos que, 𝑓5 = 5.
Atividade: vá até a sala virtual e resolva a atividade
“Programando em Java: exercício 3”, disponível na
semana 4.
4.6 POO, classes e objetos
Chegamos a última seção do curso e o que pretendemos aqui é apenas uma
abordagem inicial sobre classes e objetos. A motivação é a linguagem Java a qual foi
concebida para ser orientada a objetos.
A programação orientada a objetos (POO) é um paradigma de programação que
surgiu para resolver problemas associados à softwares grandes e complexos. Havia
problemas relacionados a todo o ciclo de vida. O paradigma possibilitou uma conexão firme
entre análise e projeto, bem como favoreceu muito a evolução e manutenção dos softwares.
Isso ocorre devido o fato de as linguagens orientada a objetos serem concebidas sob pilares
que promovem a abstração e o encapsulamento na construção dos componentes do
software e também oferecem recursos que permitem a objetos um comportamento
polimórfico.
Um paradigma determina qual é a visão que você, programador, deve ter sobre a
estruturação e execução dos programas. No caso da orientação a objetos essa visão deixa
de ser nas funções (na decomposição funcional) e passa a ser nos dados.
A POO aproveitou os avanços do paradigma imperativo anterior mas avançou ao
propor modelar as instruções (sub-rotinas/funções) junto com os dados. Instruções e dados
são definidos numa unidade de programação que chamados de classe. Criamos uma classe
e a partir dela criamos (instanciamos) um ou mais objetos. Por essa razão a classe é vista
como a ‘forma’, o projeto para criar os objetos.
Veja um exemplo. Suponha um sistema para controlar um estacionamento. O projeto
deve começar definindo quais serão os objetos do domínio do problema, reais ou abstratos,
que devem fazer parte da solução. Esses objetos darão origem a classes no programa. Para
o exemplo os objetos seriam: carros, vagas, clientes, etc. O projetista deve levantar para
essas entidades quais são as características, em termos de dados e comportamento,
necessárias para serem incorporadas às respectivas classes da solução.
É importante para um estacionamento registrar para um carro que entra a placa, cor,
modelo, data/horário de entrada, data/horário de saída, etc. Certamente não será relevante
saber o preço de compra ou o tipo do material dos bancos dos carros. Os dados que
caracterizam os objetos de uma classe são chamados de atributos da classe. Já as funções
que definem o comportamento dos objetos chamamos de métodos. O comportamento de
um carro para esse software não é ligar, deligar. O comportamento dos objetos da classe
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 106
carro para esse caso seriam métodos como: entrar, sair, calcular tempo de permanência,
etc.
Na Figura 61 está o código da classe Carro. Lembre-se, classes são escritas com
letra inicial maiúscula. Não usamos static nos métodos aqui pois esses serão agora de
escopo dos objetos. Os atributos são bem definidos como privados, assim só serão
acessados de dentro da própria classe. Observe o ‘−‘ no diagrama de classes e o
modificador 𝑝𝑟𝑖𝑣𝑎𝑡𝑒 na declaração dos atributos. Atributos privados impedem acessos
diretos por parte do código cliente, o que reduz o acoplamento. Para o caso quando o código
cliente necessitar informar ou acessar os atributos a convenção é definir métodos públicos
chamados de modificadores (setters) e acessadores (getters). Observe o método 𝑔𝑒𝑡𝑃𝑙𝑎𝑐𝑎()
na Figura 61.
O construtor da classe é um método especial que tem o mesmo nome: 𝐶𝑎𝑟𝑟𝑜. O
construtor é usado para dar um estado inicial ao objeto. O estado de um objeto é definido
pelos valores dos seus atributos. A palavra-chave 𝑡ℎ𝑖𝑠 significa ‘este’ ou desta classe. Ela é
usada para se referir a atributos e métodos da própria classe. O 𝑡ℎ𝑖𝑠 é necessário para
desambiguar identificadores diferentes com o mesmo nome. No método construtor, p. ex.,
há o parâmetro 𝑝𝑙𝑎𝑐𝑎 e o atributo 𝑝𝑙𝑎𝑐𝑎, então será necessário referenciar o atributo com o
𝑡ℎ𝑖𝑠 para diferenciá-lo do parâmetro na atribuição. Para trabalhar com data, hora, data e
hora, etc., usamos as classes do pacote java.time. Veja a importação do pacote no início do
código.
Escrito o código da classe podemos criar os objetos. A criação ou instanciação de um
objeto é feita usando a palavra-chave new e invocando o construtor da classe. Veja a
sentença abaixo:
𝐶𝑎𝑟𝑟𝑜 𝑐𝑎𝑟𝑟𝑜1 = 𝑛𝑒𝑤 𝐶𝑎𝑟𝑟𝑜(“𝐼𝐹𝑀 − 9090”, “𝐵𝑟𝑎𝑛𝑐𝑜”, “𝐺𝑜𝑙 𝑅𝑎𝑙𝑙𝑦”);
O comando criou na memória o objeto 𝑐𝑎𝑟𝑟𝑜1. 𝑐𝑎𝑟𝑟𝑜1 é definido como uma variável
que faz referência a um objeto da classe 𝐶𝑎𝑟𝑟𝑜, então o tipo é a própria classe. Os valores
dos atributos após a instanciação serão: placa = “IFM-9090”, cor = “Branco”, modelo = “Gol
Rally”. Observe que não basta declarar a variável:
𝐶𝑎𝑟𝑟𝑜 𝑐𝑎𝑟𝑟𝑜1;
Aqui o objeto é uma referência 𝑛𝑢𝑙𝑙. Para invocar métodos sobre o objeto ele deve
ser instanciado. Portanto, antes de usar o objeto será preciso fazer:
𝑐𝑎𝑟𝑟𝑜1 = 𝑛𝑒𝑤 𝐶𝑎𝑟𝑟𝑜(“𝐼𝐹𝑀 − 9090”, “𝐵𝑟𝑎𝑛𝑐𝑜”, “𝐺𝑜𝑙 𝑅𝑎𝑙𝑙𝑦”);
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 107
Figura 61 – Definindo a classe Carro
Fonte: Elaborado pela autora
Agora podemos interagir com o objeto. Um software orientado a objetos implementa
suas funcionalidades através da interação entre os objetos na memória. Um objeto A envia
mensagem a um objeto B quando A chama um método de B.
Para solicitar que um objeto execute um método basta incluir o nome da variável do
objeto seguido do nome do método, informando, se houver, os parâmetros entre parênteses.
O comando abaixo chama o método 𝑒𝑛𝑡𝑟𝑎𝑟 em 𝑐𝑎𝑟𝑟𝑜1 informando a data e a hora do
sistema com 𝐿𝑜𝑐𝑎𝑙𝐷𝑎𝑡𝑒𝑇𝑖𝑚𝑒. 𝑛𝑜𝑤(). Veja que o método agora preenche o atributo 𝑒𝑛𝑡𝑟𝑎𝑑𝑎:
𝑐𝑎𝑟𝑟𝑜1. 𝑒𝑛𝑡𝑟𝑎𝑟(𝐿𝑜𝑐𝑎𝑙𝐷𝑎𝑡𝑒𝑇𝑖𝑚𝑒. 𝑛𝑜𝑤());
Para obter a placa invocamos, 𝑐𝑎𝑟𝑟𝑜1. 𝑔𝑒𝑡𝑃𝑙𝑎𝑐𝑎() atribuindo o resultado para uma
variável do tipo String:
𝑆𝑡𝑟𝑖𝑛𝑔 𝑝𝑙𝑎𝑐𝑎 = 𝑐𝑎𝑟𝑟𝑜1. 𝑔𝑒𝑡𝑃𝑙𝑎𝑐𝑎();
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 108
O código da classe 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 segue a seguir. Esta classe depende da classe
𝐶𝑎𝑟𝑟𝑜 uma vez que dentro dos seus métodos há chamadas a métodosde 𝐶𝑎𝑟𝑟𝑜. De fato,
haverá em tempo de execução uma associação entre um objeto 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 e um ou
mais objetos 𝐶𝑎𝑟𝑟𝑜. A classe 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 inclui o método 𝑚𝑎𝑖𝑛 para exemplificar a
comunicação entre os objetos.
𝑖𝑚𝑝𝑜𝑟𝑡 𝑗𝑎𝑣𝑎. 𝑡𝑖𝑚𝑒. 𝐿𝑜𝑐𝑎𝑙𝐷𝑎𝑡𝑒𝑇𝑖𝑚𝑒;
𝑖𝑚𝑝𝑜𝑟𝑡 𝑗𝑎𝑣𝑎. 𝑢𝑡𝑖𝑙.∗;
𝑝𝑢𝑏𝑙𝑖𝑐 𝑐𝑙𝑎𝑠𝑠 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 {
𝑝𝑟𝑖𝑣𝑎𝑡𝑒 𝑖𝑛𝑡 𝑐𝑜𝑑𝑖𝑔𝑜𝐹𝑖𝑙𝑖𝑎𝑙, 𝑛𝑢𝑚𝑉𝑎𝑔𝑎𝑠;
𝑝𝑟𝑖𝑣𝑎𝑡𝑒 𝑑𝑜𝑢𝑏𝑙𝑒 𝑝𝑟𝑒𝑐𝑜𝐻𝑜𝑟𝑎;
//𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜 𝑝𝑎𝑟𝑎 𝑢𝑚𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑜𝑏𝑗𝑒𝑡𝑜𝑠 𝑑𝑎 𝑐𝑙𝑎𝑠𝑠𝑒 𝐶𝑎𝑟𝑟𝑜:
𝑝𝑟𝑖𝑣𝑎𝑡𝑒 𝐴𝑟𝑟𝑎𝑦𝐿𝑖𝑠𝑡 < 𝐶𝑎𝑟𝑟𝑜 > 𝑐𝑎𝑟𝑟𝑜𝑠𝑃𝑎𝑟𝑎𝑑𝑜𝑠;
//𝐶𝑜𝑛𝑠𝑡𝑟𝑢𝑡𝑜𝑟 𝑑𝑒 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜
𝑝𝑢𝑏𝑙𝑖𝑐 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜(𝑖𝑛𝑡 𝑓𝑖𝑙𝑖𝑎𝑙, 𝑖𝑛𝑡 𝑣𝑎𝑔𝑎𝑠, 𝑑𝑜𝑢𝑏𝑙𝑒 𝑝𝑟𝑒𝑐𝑜){
𝑡ℎ𝑖𝑠. 𝑐𝑜𝑑𝑖𝑔𝑜𝐹𝑖𝑙𝑖𝑎𝑙 = 𝑓𝑖𝑙𝑖𝑎𝑙;
𝑡ℎ𝑖𝑠. 𝑛𝑢𝑚𝑉𝑎𝑔𝑎𝑠 = 𝑣𝑎𝑔𝑎𝑠;
𝑡ℎ𝑖𝑠. 𝑝𝑟𝑒𝑐𝑜𝐻𝑜𝑟𝑎 = 𝑝𝑟𝑒𝑐𝑜;
𝑡ℎ𝑖𝑠. 𝑐𝑎𝑟𝑟𝑜𝑠𝑃𝑎𝑟𝑎𝑑𝑜𝑠 = 𝑛𝑒𝑤 𝐴𝑟𝑟𝑎𝑦𝐿𝑖𝑠𝑡(); //𝐶𝑟𝑖𝑎 𝑎 𝑙𝑖𝑠𝑡𝑎 𝑑𝑒 𝑐𝑎𝑟𝑟𝑜𝑠 𝑣𝑎𝑧𝑖𝑎
}
//𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑑𝑒 𝑢𝑚 𝑐𝑎𝑟𝑟𝑜 𝑛𝑜 𝑒𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 𝑠𝑒 ℎ𝑜𝑢𝑣𝑒𝑟 𝑣𝑎𝑔𝑎
//𝑆𝑒 𝑒𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑟 𝑟𝑒𝑡𝑜𝑟𝑛𝑎 𝑡𝑟𝑢𝑒, 𝑐𝑎𝑠𝑜 𝑐𝑜𝑛𝑡𝑟á𝑟𝑖𝑜, 𝑟𝑒𝑡𝑜𝑟𝑛𝑎 𝑓𝑎𝑙𝑠𝑒
𝑝𝑢𝑏𝑙𝑖𝑐 𝑏𝑜𝑜𝑙𝑒𝑎𝑛 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝐸𝑛𝑡𝑟𝑎𝑑𝑎(𝐶𝑎𝑟𝑟𝑜 𝑐){
//𝑠𝑒 ℎá 𝑢𝑚𝑎 𝑣𝑎𝑔𝑎 𝑑𝑖𝑠𝑝𝑜𝑛í𝑣𝑒𝑙:
𝑖𝑓 (𝑡ℎ𝑖𝑠. 𝑐𝑎𝑟𝑟𝑜𝑠𝑃𝑎𝑟𝑎𝑑𝑜𝑠. 𝑠𝑖𝑧𝑒() < 𝑡ℎ𝑖𝑠. 𝑛𝑢𝑚𝑉𝑎𝑔𝑎𝑠){
𝑐. 𝑒𝑛𝑡𝑟𝑎𝑟(𝐿𝑜𝑐𝑎𝑙𝐷𝑎𝑡𝑒𝑇𝑖𝑚𝑒. 𝑛𝑜𝑤());
𝑡ℎ𝑖𝑠. 𝑐𝑎𝑟𝑟𝑜𝑠𝑃𝑎𝑟𝑎𝑑𝑜𝑠. 𝑎𝑑𝑑(𝑐);
𝑟𝑒𝑡𝑢𝑟𝑛 𝑡𝑟𝑢𝑒;
}𝑒𝑙𝑠𝑒
𝑟𝑒𝑡𝑢𝑟𝑛 𝑓𝑎𝑙𝑠𝑒; //𝑛ã𝑜 ℎá 𝑣𝑎𝑔𝑎𝑠
}
//𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎 𝑠𝑎í𝑑𝑎 𝑑𝑒 𝑢𝑚 𝑐𝑎𝑟𝑟𝑜 𝑑𝑜 𝑒𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜
//𝑆𝑒 𝑎 𝑝𝑙𝑎𝑐𝑎 𝑛ã𝑜 𝑒𝑥𝑖𝑠𝑡𝑖𝑟 𝑟𝑒𝑡𝑜𝑟𝑛𝑎 𝑛𝑢𝑙𝑙, 𝑐𝑎𝑠𝑜 𝑐𝑜𝑛𝑡𝑟á𝑟𝑖𝑜 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎 𝑎 𝑠𝑎í𝑑𝑎
//𝑛𝑜 ℎ𝑜𝑟á𝑟𝑖𝑜 𝑑𝑜 𝑠𝑖𝑠𝑡𝑒𝑚𝑎 𝑒 𝑟𝑒𝑡𝑜𝑟𝑛𝑎 𝑜 𝑜𝑏𝑗𝑒𝑡𝑜 𝐶𝑎𝑟𝑟𝑜
𝑝𝑢𝑏𝑙𝑖𝑐 𝐶𝑎𝑟𝑟𝑜 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑆𝑎𝑖𝑑𝑎(𝑆𝑡𝑟𝑖𝑛𝑔 𝑝𝑙𝑎𝑐𝑎){
𝑓𝑜𝑟(𝐶𝑎𝑟𝑟𝑜 𝑐: 𝑡ℎ𝑖𝑠. 𝑐𝑎𝑟𝑟𝑜𝑠𝑃𝑎𝑟𝑎𝑑𝑜𝑠){
𝑖𝑓(𝑐. 𝑔𝑒𝑡𝑃𝑙𝑎𝑐𝑎(). 𝑒𝑞𝑢𝑎𝑙𝑠(𝑝𝑙𝑎𝑐𝑎)){
𝑐. 𝑠𝑎𝑖𝑟(𝐿𝑜𝑐𝑎𝑙𝐷𝑎𝑡𝑒𝑇𝑖𝑚𝑒. 𝑛𝑜𝑤());
𝑟𝑒𝑡𝑢𝑟𝑛 𝑐;
}
}
𝑟𝑒𝑡𝑢𝑟𝑛 𝑛𝑢𝑙𝑙; //𝑝𝑙𝑎𝑐𝑎 𝑛ã𝑜 𝑒𝑛𝑐𝑜𝑛𝑡𝑟𝑎𝑑𝑎 𝑛𝑜 𝑒𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜!
}
𝑝𝑢𝑏𝑙𝑖𝑐 𝑑𝑜𝑢𝑏𝑙𝑒 𝑐𝑎𝑙𝑐𝑢𝑙𝑎𝑉𝑎𝑙𝑜𝑟𝐴𝑃𝑎𝑔𝑎𝑟(𝐶𝑎𝑟𝑟𝑜 𝑐){
𝑑𝑜𝑢𝑏𝑙𝑒 ℎ𝑜𝑟𝑎𝑠 = 𝑐. 𝑐𝑎𝑙𝑐𝑢𝑙𝑎𝑇𝑒𝑚𝑝𝑜𝑃𝑒𝑟𝑚𝑎𝑛𝑒𝑛𝑐𝑖𝑎()/60.0;
𝑑𝑜𝑢𝑏𝑙𝑒 𝑣𝑎𝑙𝑜𝑟 = ℎ𝑜𝑟𝑎𝑠 ∗ 𝑡ℎ𝑖𝑠. 𝑝𝑟𝑒𝑐𝑜𝐻𝑜𝑟𝑎;
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 109
𝑟𝑒𝑡𝑢𝑟𝑛 𝑣𝑎𝑙𝑜𝑟;
}
𝑝𝑢𝑏𝑙𝑖𝑐 𝑠𝑡𝑎𝑡𝑖𝑐 𝑣𝑜𝑖𝑑 𝑚𝑎𝑖𝑛(𝑆𝑡𝑟𝑖𝑛𝑔[] 𝑎𝑟𝑔𝑠) 𝑡ℎ𝑟𝑜𝑤𝑠 𝐼𝑛𝑡𝑒𝑟𝑟𝑢𝑝𝑡𝑒𝑑𝐸𝑥𝑐𝑒𝑝𝑡𝑖𝑜𝑛 {
//𝐶𝑟𝑖𝑎 𝑢𝑚 𝑜𝑏𝑗𝑒𝑡𝑜 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 𝑝𝑎𝑟𝑎 𝑡𝑒𝑠𝑡𝑎𝑟 𝑎𝑠 𝑐𝑙𝑎𝑠𝑠𝑒𝑠:
𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 𝑝𝑎𝑟𝑒𝐵𝑎𝑟𝑎𝑡𝑜 = 𝑛𝑒𝑤 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜(12783, 12, 10.00);
//𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑑𝑒 𝑐𝑎𝑟𝑟𝑜 𝑛𝑜 𝑒𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜:
𝐶𝑎𝑟𝑟𝑜 𝑐1 = 𝑛𝑒𝑤 𝐶𝑎𝑟𝑟𝑜("𝑃𝑋𝐴9980", "𝑃𝑟𝑒𝑡𝑜", "𝐹𝑖𝑒𝑠𝑡𝑎");
𝑝𝑎𝑟𝑒𝐵𝑎𝑟𝑎𝑡𝑜. 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝐸𝑛𝑡𝑟𝑎𝑑𝑎(𝑐1);
//𝑆𝑢𝑠𝑝𝑒𝑛𝑑𝑒 𝑎 𝑒𝑥𝑒𝑐𝑢çã𝑜 𝑑𝑜 𝑝𝑟𝑜𝑔𝑟𝑎𝑚𝑎 𝑝𝑜𝑟 5 𝑚𝑖𝑛𝑢𝑡𝑜𝑠 (300.000 𝑚𝑖𝑙𝑖𝑠𝑠𝑒𝑔𝑢𝑛𝑑𝑜𝑠)
//𝑝𝑎𝑟𝑎 𝑠𝑖𝑚𝑢𝑙𝑎𝑟 𝑎 𝑝𝑎𝑠𝑠𝑎𝑔𝑒𝑚 𝑑𝑒 𝑡𝑒𝑚𝑝𝑜:
𝑇ℎ𝑟𝑒𝑎𝑑. 𝑠𝑙𝑒𝑒𝑝(300000);
//𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎 𝑠𝑎𝑖𝑑𝑎 𝑑𝑜 𝑚𝑒𝑠𝑚𝑜 𝑐𝑎𝑟𝑟𝑜, 𝑖𝑛𝑓𝑜𝑟𝑚𝑎𝑛𝑑𝑜 𝑎 𝑝𝑙𝑎𝑐𝑎:
𝐶𝑎𝑟𝑟𝑜 𝑐𝑎𝑟𝑟𝑜𝑆𝑎𝑖𝑛𝑑𝑜 = 𝑝𝑎𝑟𝑒𝐵𝑎𝑟𝑎𝑡𝑜. 𝑟𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑆𝑎𝑖𝑑𝑎("𝑃𝑋𝐴9980");
𝑖𝑓 (𝑐𝑎𝑟𝑟𝑜𝑆𝑎𝑖𝑛𝑑𝑜 == 𝑛𝑢𝑙𝑙){
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡𝑙𝑛("𝑃𝑙𝑎𝑐𝑎 𝑛ã𝑜 𝑒𝑥𝑖𝑠𝑡𝑒! ");
}𝑒𝑙𝑠𝑒{
//𝐶𝑎𝑙𝑐𝑢𝑙𝑎 𝑜 𝑝𝑟𝑒ç𝑜 𝑝𝑒𝑙𝑎 𝑝𝑒𝑟𝑚𝑎𝑛ê𝑛𝑐𝑖𝑎 𝑑𝑜 𝑣𝑒í𝑐𝑢𝑙𝑜
𝑑𝑜𝑢𝑏𝑙𝑒 𝑝𝑟𝑒𝑐𝑜𝑇𝑜𝑡𝑎𝑙 = 𝑝𝑎𝑟𝑒𝐵𝑎𝑟𝑎𝑡𝑜. 𝑐𝑎𝑙𝑐𝑢𝑙𝑎𝑉𝑎𝑙𝑜𝑟𝐴𝑃𝑎𝑔𝑎𝑟(𝑐𝑎𝑟𝑟𝑜𝑆𝑎𝑖𝑛𝑑𝑜);
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡𝑙𝑛("𝑉𝑎𝑙𝑜𝑟 𝑎 𝑝𝑎𝑔𝑎𝑟: " + 𝑝𝑟𝑒𝑐𝑜𝑇𝑜𝑡𝑎𝑙);
}
}
}
4.7 Pratique
1) Altere o método main da classe 𝐸𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑚𝑒𝑛𝑡𝑜 para incluir e tratar as seguintes opções
menu:
1. 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑑𝑒 𝑣𝑒í𝑐𝑢𝑙𝑜
2. 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑎𝑟 𝑠𝑎í𝑑𝑎 𝑒 𝑎𝑝𝑟𝑒𝑠𝑒𝑛𝑡𝑎𝑟 𝑡𝑜𝑡𝑎𝑙 𝑎 𝑝𝑎𝑔𝑎𝑟
3. 𝑉𝑒𝑟𝑖𝑓𝑖𝑐𝑎𝑟 𝑝𝑒𝑙𝑎 𝑝𝑙𝑎𝑐𝑎 𝑠𝑒 𝑜 𝑐𝑎𝑟𝑟𝑜 𝑒𝑠𝑡á 𝑒𝑠𝑡𝑎𝑐𝑖𝑜𝑛𝑎𝑑𝑜
4. 𝐼𝑚𝑝𝑟𝑖𝑚𝑖𝑟 𝑟𝑒𝑙𝑎çã𝑜 𝑑𝑒 𝑣𝑒í𝑐𝑢𝑙𝑜𝑠 𝑝𝑎𝑟𝑎𝑑𝑜𝑠
5. 𝐹𝑖𝑛𝑎𝑙𝑖𝑧𝑎𝑟 𝑜 𝑝𝑟𝑜𝑔𝑟𝑎𝑚𝑎
Observações:
Pesquise sobre como percorrer os elementos de um ArrayList na documentação
da API Java. Outra alternativa é criar um vetor de objetos da classe Carro. Nesse
caso, o vetor terá o tamanho do número de vagas no estacionamento e o controle
de crescimento do vetor poderia ser feito por atributo do tipo inteiro, como, p. ex.,
𝑣𝑎𝑔𝑎𝑠𝑂𝑐𝑢𝑝𝑎𝑑𝑎𝑠.
Considere utilizar laços de repetição, identificar e definir sub-rotinas de apoio para
execução do programa.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão 110
Mídia digital: Assista aos vídeos 15, 16 e 17 nomeados
“Treinando sintaxe com interface gráfica” disponíveis na
sala virtual para a semana 4. Além de aprender esse
novo tópico aproveite para rever a sintaxe e se preparar
para a Avaliação Geral.
Atividade: para concluir o curso e gerar o seu
certificado, vá até a sala virtual e responda ao
Questionário “Avaliação geral”, disponível ao final da
semana 4. O teste inclui 10 questões relacionadas à
sintaxe básica Java para averiguar os conhecimentos e
a prática de programação adquiridos.
Parabéns pela conclusão do curso! Foi um prazer tê-lo conosco!
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
111
Referências
HORSTMANN, Cay S.. Core Java: Volume I - Fundamentals. 11 ed. Pearson Education,
2019.
INFOWORLD. Java programming language celebrates 25 years. Disponível em:
<https://www.infoworld.com/article/3544229/java-programming-language-celebrates-25-
years.html>. Acesso em: 1 jul. 2020.
JAVA. In: Wikipedia, the free encyclopedia.Wikimedia, 2020. Disponível em:
<https://en.wikipedia.org/wiki/Java>. Acesso em: 1 jul. 2020.
PYPL. PYPL PopularitY of Programming Language. Disponível em:
<http://pypl.github.io/PYPL.html>. Acesso em: 1 jul. 2020.
REDMONK. The RedMonk Programming Language Rankings: January 2020. Disponível
em: <https://redmonk.com/sogrady/2020/02/28/language-rankings-1-20/>. Acesso em: 1 jul.
2020.
SCHILDT, Herbert. Java: A Beginner’s Guide Eighth Edition. 8 ed. McGrawHill Education,
2018.
TIOBE. TIOBE Index for July 2020. Disponível em: <https://www.tiobe.com/tiobe-index>.
Acesso em: 1 jul. 2020.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
112
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
113
Apêndice I – Manuais de instalação
Introdução
O Java Development Kit (JDK) é o kit de ferramentas do desenvolvedor de aplicações
Java que contém, além da máquina virtual (JVM), bibliotecas e ferramentas necessáriaspara
compilar e executar programas. As ferramentas do JDK são necessárias para a
programação Java, inclusive usadas pelas IDE’s de desenvolvimento como NetBeans,
Eclipse, IntelliJ, BlueJ, etc. A instalação do JDK deve ser feita a parte se ele não for incluso
no pacote de instalação da IDE escolhida. Nesse momento, p. ex., nenhum pacote de
instalação do NetBeans vem acompanhado do JDK.
Saiba que a plataforma Java SE também é uma especificação. É preciso baixar uma
de suas implementações. Há muitas empresas envolvidas na implementação do JDK além
da própria Oracle, como a IBM, a Apache, Azul Systems, etc. Entre as opções Java SE
disponíveis as mais comuns são:
Oracle JDK: implementação oficial da Oracle sob licença comercial (BCL) que
permite uso sem taxas para desenvolvimento interno se for com o objetivo apenas de
projetar, desenvolver e testar programas.
OpenJDK: implementação gratuita sob licença GPL (GPLv2+CE) realizada da
OpenJDK Community, com apoio direto da Oracle. Segundo o site da comunidade o
OpenJDK é a única implementação Java SE de código aberto para a qual a Oracle
planeja continuar contribuindo. É o JDK de código aberto adotado pelas distribuições
Linux mais populares. Do Java 11 em diante, as compilações do Oracle JDK e
OpenJDK são essencialmente idênticas.
AdoptOpenJDK: outra implementação gratuita sob a mesma licença GPL. É
realizada pela comunidade de membros do Java User Group (JUG), desenvolvedores
e fornecedores de Java incluindo Azul, Amazon, GoDaddy, IBM, jClarity, Microsoft,
New Relic, Pivotal e Red Hat.
Qualquer das implementações acima pode ser baixada e instalada para fins de estudos.
Se pretende fazer uso comercial sem pagar taxas, opte por uma das implementações
gratuitas. A Oracle, a partir do Java SE 9, em 2017, passou a entregar novas versões do
Java a cada seis meses. Uma em cada três dessas versões oferece suporte LTS, com
lançamento de três em três anos. Para uso comercial opte pelas versões LTS que terão
suporte por um período maior de tempo.
É importante lembrar que o Java SE 8 foi lançado em 2014 e continuará recebendo
atualizações até o final de 2020, tendo suporte estendido até 2025. O Java SE 11 é a última
versão LTS lançada pela Oracle.
Dado o aspecto introdutório deste curso qualquer versão Java SE a partir da 8 poderá
ser utilizada. Sendo assim, a instalação será feito para a versão 8, mas o processo é o
mesmo para qualquer outra versão
Observação: é necessário fazer a instalação do JDK antes de instalar a IDE Netbeans.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
114
Instalando o Oracle JDK 8 no Windows
Para instalar o JDK do site da Oracle (apenas para fins de estudo), basta seguir os
passos abaixo.
1. Na página de downloads do Java Oracle,
https://www.oracle.com/br/java/technologies/javase-downloads.html , clique no link
indicado.
Figura 62 – Instalação JDK 8 no Windows (passo 1)
Fonte: adaptado de www.oracle.com.br/java/technologies/javase-downloads.html
2. Na página seguinte escolha a opção de acordo com sua instalação do Windows: x86
(sistema operacional de 32 bits) ou x64 (sistema operacional de 64 bits)
ou
https://www.oracle.com/br/java/technologies/javase-downloads.html
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
115
Figura 63 – Instalação JDK 8 no Windows (passo 2)
Fonte: adaptado de www.oracle.com.br/java/technologies/javase-downloads.html
No diálogo aberto marque a caixa de verificação e clique no botão de download:
Figura 64 – Instalação JDK 8 no Windows (passo 2.1)
Fonte: adaptado de www.oracle.com.br/java/technologies/javase-downloads.html
3. A página seguinte solicitará o seu login. Forneça seu usuário e senha e clique no
botão “Iniciar sessão”. Caso ainda não possua uma conta Oracle clique no botão
“Criar Conta”, siga as instruções e refaça os passos anteriores
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
116
Figura 65 – Instalação JDK 8 no Windows (passo 3)
Fonte: adaptado de www.oracle.com.br/java/technologies/javase-downloads.html
4. Se usuário e senha estiverem corretos, clique no botão “Salvar arquivo” e aguardo o
download ser concluído
Figura 66 – Instalação JDK 8 no Windows (passo 4)
Fonte: adaptado de www.oracle.com.br/java/technologies/javase-downloads.html
5. Execute o arquivo .exe baixado e siga as sugestões clicando em “Next”
Figura 67 – Instalação JDK 8 no Windows (passo 5)
Fonte: adaptado de www.oracle.com.br/java/technologies/javase-downloads.html
Se desejar alterar a pasta de instalação, clique no botão ‘Alterar’ abaixo e
informe uma pasta. Obs.: a pasta selecionada deve estar vazia.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
117
6. Finalizada a instalação, as variáveis de ambiente do Windows já estarão
configuradas.
Observação: se desejar em seguida instalar o NetBeans (versão Apache) o Java Oracle
JDK será automaticamente identificado.
Instalando o OpenJDK 8 no Windows
Para instalar a versão gratuita do OpenJDK siga os passos abaixo.
1. Vá até a página de download do OpenJDK, https://jdk.java.net/. Selecione o link da
versão desejava na lista Reference implementations
Figura 68 – Instalação OpenJDK 8 no Windows (passo 1)
Fonte: adaptado de https://jdk.java.net
2. Na página aberta clique na opção de instalação indicada
Figura 69 – Instalação OpenJDK 8 no Windows (passo 2)
Fonte: adaptado de https://jdk.java.net
https://jdk.java.net/
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
118
3. Selecione “Salvar arquivo” e dê Ok para fazer o download
Figura 70 – Instalação OpenJDK 8 no Windows (passo 3)
Fonte: adaptado de https://jdk.java.net
4. Mova o arquivo .zip baixado para a pasta desejada e extraia seu conteúdo.
Figura 71 – Instalação OpenJDK 8 no Windows (passo 4)
Fonte: adaptado de https://jdk.java.net
5. Verifique a pasta gerada após a extração.
Figura 72 – Instalação OpenJDK 8 no Windows (passo 5)
Fonte: adaptado de https://jdk.java.net
6. Anote o caminho \bin da pasta gerada. Para o exemplo acima será C:\java\java-se-
8u41-ri\bin
7. O último passo é importante para a identificação da versão de instalação da
plataforma Java necessária para o funcionamento do Netbeans. Trata-se de
configurar a variável path do Windows para incluir a pasta \bin como anteriormente
indicado:
a) No Windows 10 abra o em Painel de Controle e escolha Sistema
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
119
Figura 73 – Instalação OpenJDK 8 no Windows (passo 7.a)
Fonte: adaptado de https://jdk.java.net
b) Na janela aberta, no canto à esquerda escolha “Configurações avançadas do
sistema”
Figura 74 – Instalação OpenJDK 8 no Windows (passo 7.b)
Fonte: adaptado de https://jdk.java.net
c) Clique no botão ‘Variáveis de Ambiente’ da aba ‘Avançado’
https://jdk.java.net/
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
120
Figura 75 – Instalação OpenJDK 8 no Windows (passo 7.c)
Fonte: adaptado de https://jdk.java.net
d) Na janela ‘Variáveis de Ambiente’, vá para a seção ‘Variáveis do sistema’ e clique
no botão ‘Novo’. Em Seguida preencha o diálogo mostrado para criar a variável
javahome, conforme o exemplo abaixo.
Nome da variável: javahome
Valor da variável: C:\java\java-se-8u41-ri (ou o caminho raiz do jdk instalado)
Figura 76 – Instalação OpenJDK 8 no Windows (passo 7.d)
Fonte: adaptado de https://jdk.java.net
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
121
e) Em seguida, clique no botão ‘Ok’ do diálogo ‘Editar Variável de Sistema’ Agora selecioneem ‘Variáveis do sistema’ a variável Path. Clique no botão ‘Editar’ ou dê duplo
clique na seleção
Figura 77 – Instalação OpenJDK 8 no Windows (passo 7.e)
Fonte: adaptado de https://jdk.java.net
f) Pressione o botão ‘Novo’ para incluir o caminho da pasta \bin usando a variável
javahome. Insira a linha como destacado na janela da direita:
%javahome%\bin (Figura 78).
Em seguida dê OK em todas as janelas.
g) Para testar a configuração, abra o shell de comandos do Windows
pressionando as teclas Win+R . No diálogo da Figura 79 digite cmd e pressione
<Enter>.
Com o terminal aberto digite java –version (ou javac –version) seguido de
<Enter>. Confira a versão de instalação do JDK.
Se a resposta for “Java não é reconhecido...” algo de errado ocorreu. Nesse caso, confira
a variável ‘path’ ou repita o processo seguindo os passos descritos anteriores.
Concluído o passo 7 será possível executar o instalador do Apache NetBeans que
identificará o OpenJDK acima configurado.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
122
Figura 78 – Instalação OpenJDK 8 no Windows (passo 7.f)
Fonte: adaptado de https://jdk.java.net
O instalador irá sugerir uma versão do Java de 64 bits, já que a versão instalada para
os passos acima, a 8u41, é de 32 bits. Caso deseje, baixe e descompacte o OpenJDK 11,
versão de 64 bits, para usar com o Netbeans. Para instalar o OpenJDK11 siga os mesmos
passos. Todavia essa alteração não é necessária, basta aceitar e continuar a instalação
normalmente com a versão 8u41 de 32 bits.
Figura 79 – Testanto a instalação OpenJDK 8 no Windows (passo 7.g)
Fonte: adaptado de https://jdk.java.net
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
123
Instalando o Apache NetBeans no Windows
1. Vá até a página de download do NetBeans
https://netbeans.apache.org/download/index.html
2. Clique no botão “Download” na versão desejada. É exemplificada a instalação da
última versão 12.0.
Figura 80 – Instalando o Apache NetBeans (passo 2)
Fonte: adaptado de https://netbeans.apache.org/download/index.html
3. Na próxima página clique no link indicado. Observe que a versão Windows é apenas
para 64 bits.
Figura 81 – Instalando o Apache NetBeans (passo 3)
Fonte: adaptado de https://netbeans.apache.org/download/index.html
https://netbeans.apache.org/download/index.html
https://netbeans.apache.org/download/index.html
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
124
4. A próxima página sugere um site para download. Siga o link sugerido.
Figura 82 – Instalando o Apache NetBeans (passo 4)
Fonte: adaptado de https://netbeans.apache.org/download/index.html
5. Na caixa de diálogo que será aberta pressione “Salvar arquivo”. Aguarde a conclusão
do download.
Figura 83 – Instalando o Apache NetBeans (passo 5)
Fonte: adaptado de https://netbeans.apache.org/download/index.html
6. Execute o arquivo baixado, aceitando a licença. No terceiro passo, no diálogo abaixo,
é possível selecionar o JDK desejado pressionando o botão “Browse...” ou aceitar a
seleção.
7. Observe na Figura 84 a mensagem de aviso relacionada à versão JDK de 32 bits
instalada (OpenJDK 8). Não se trata de uma mensagem de erro é apenas um alerta
para melhorar a performance. Basta ignorar e pressionar “Next”.
8. No restante das telas de instalação aceite as configurações dadas pressionando
“Next” e ao final “Finish”.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
125
Figura 84 – Instalando o Apache NetBeans (passo 6)
Fonte: adaptado de https://netbeans.apache.org/download/index.html
Instalando o OpenJDK 8 no Linux Ubuntu
Para instalar a versão gratuita no Debian/Ubuntu, basta usar o gerenciador de pacotes
Apt. Siga os passos abaixo:
1. Abra um terminal (teclas CTRL + ALT + T);
2. Use o comando abaixo para atualizar a lista de pacotes
Figura 85 – Instalando o OpenJDK no Linux (passo 2)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
126
3. O próximo comando irá instalar a versão 8 do OpenJDK. Se desejar instalar a versão
11 altere o nome do pacote para openjdk-11-jdk.
Figura 86 – Instalando o OpenJDK no Linux (passo 3)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
4. Para verificar a versão do compilador java, o javac, digite:
Figura 87 – Instalando o OpenJDK no Linux (passo 4)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
5. Para configurar a variável de ambiente JAVA_HOME no Linux use o comando update-
alternatives para consultar o diretório das versões Java existentes.
No exemplo apenas a versão 8 foi instalada. Copie o caminho da pasta de
instalação, como abaixo.
Figura 88 – Instalando o OpenJDK no Linux (passo 5)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
A configuração da variável JAVA_HOME é importante não só para as
execuções em linha de comando mas também porque é referenciada por programas
que fazem uso do Java em tempo de execução.
6. Abra o arquivo /etc/environment digitando.
Figura 89 – Instalando o OpenJDK no Linux (passo 6)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
127
7. Inclua o caminho do JDK ao valor da variável JAVA_HOME como ilustrado abaixo.
Em seguida salve o arquivo. Para salvar dê Ctrl+O.
Figura 90 – Instalando o OpenJDK no Linux (passo 7)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
Você pode incluir também o valor de JRE_HOME <pastaRootJDK>/jre se esta
variável não existir.
Instalando o Apache NetBeans no Linux Ubuntu
1. Abra a Central de Software do Ubuntu. Na aba ‘Todos’, dê Ctrl+F e busque por NetBeans
Figura 91 – Instalando o Apache NetBeans no Linux (passo 1)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
128
2. Selecione a primeira versão exibida na janela anterior. Clique em ‘Instalar’ na próxima
janela.
Figura 92 – Instalando o Apache NetBeans no Linux (passo 2)
Fonte: print de tela de usuário Linux. Adaptado pela Autora
3. Aguarde o processo de instalação finalizar.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
129
Apêndice II – Tutorial rápido do NetBeans
Criando um projeto Java
Siga os passos a seguir para criar um novo projeto Java no NetBeans:
1. Com o NetBeans aberto ative o menu “File” opção “New Project...” Na janela abaixo
clique em “Next”
Figura 93 – Criando um projeto no Apache NetBeans (passo 1)
Fonte: print de tela adaptado pela Autora
2. Na próxima janela preencha os campos: nome do projeto (ProjectName) e a local do
projeto (ProjectLocation). Se desejar altere o campo Group Id para informar uma URL
invertiva para compor o nome inicial dos pacotes de sua aplicação. O campo Version
também pode ser alterado. Ao final clique no botão Finish.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
130
Figura 94 – Criando um projeto no Apache NetBeans (passo 2)
Fonte: print de tela adaptado pela Autora
3. Se a janela Projects não estiver ativa pressione Ctrl+1 para visualizar o projeto
criado na árvore de projetos
Figura 95 – Criando um projeto no Apache NetBeans (passo 3)
Fonte: print de tela adaptado pela Autora
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
131
Inserindo Classes a um projeto
1. Selecione o pacote onde deseja inserir a classe. Clique com o botão direito do
mouse e escolha a opção “New” e depois “Java Class...”
Figura 96 – Criando uma classe no Apache NetBeans (passo 1)
Fonte: print de tela adaptadopela Autora
2. No diálogo “New Java Class” informe o nome da Classe no primeiro campo e
clique no botão Finish.
Figura 97 – Criando uma classe no Apache NetBeans (passo 2)
Fonte: print de tela adaptado pela Autora
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
132
3. Veja na Janela Projects a classe criada. Clique 2 vezes no nome da classe para
abrir a janela de edição.
Figura 98 – Criando uma classe no Apache NetBeans (passo 2)
Fonte: print de tela adaptado pela Autora
Executando um programa no NetBeans
1. Após digitar o código, salva os arquivos do seu projeto clicando no botão da Figura
99.
2. Com o cursor no código da classe executável que deseja verificar o funcionamento,
p. ex., a classe HelloWorld, pressione as teclas Shift+F6 juntas. Antes, elimine os
erros de compilação, sublinhados em vermelho, pois esses vão impedir a execução
de seu código.
3. Para outras opções de execução acesse o menu Run. Se a saída do programa for
para o console, verifique sua execução na janela Output (Figura 100). Se esta janela
não for exibida pressione Ctrl+4. Veja também no menu ‘Windows’ as teclas de atalho
para todas as visões disponíveis.
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
133
Figura 99 – Executando uma classe (executável!) no Apache NetBeans (passo 1)
Fonte: print de tela adaptado pela Autora
Figura 100 – Exibição da janela “Output” para o console NetBeans.
Fonte: print de tela adaptado pela Autora
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
134
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
135
Currículo do autor
Feito por (professor-autor) Data Revisão de layout Data Versão
Daniela Costa Terra 29/10/2020 Viviane Lima Martins 09/09/2021 1.0
Daniela Costa Terra possui graduação em Ciência da Computação, pós-graduação em
Gestão Financeira de Empresas, mestrado em Modelagem Matemática e Computacional
pelo CEFET/MG e doutoranda em Ciência da Computação pela UFOP. Atuou por seis
anos em desenvolvimento de software, três deles com sistemas legados em
multinacional. Há mais de 10 anos se dedica ao ensino de programação de
computadores. Professora efetiva do Instituto Federal de Educação, Ciência e
Tecnologia de Minas Gerais, desde 2010. Desde 2015 é parte do corpo docente da área
de Computação no Campus Ouro Branco, ministrando disciplinas relacionadas à
programação, algoritmos e arquitetura de computadores. Realizou trabalhos na área de agentes
cognitivos/emocionais e aplicações acessíveis para deficientes visuais para Android. Atualmente
desenvolve pesquisa em visão computacional e aprendizagem de máquina aplicadas ao processamento
de imagens médicas.
Currículo Lattes: http://lattes.cnpq.br/5745086306252542
http://lattes.cnpq.br/5745086306252542
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
136
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
137
Glossário de códigos QR (Quick Response)
Mídia digital
Aula 1 -
Apresentação do
curso
Mídia digital
Aula 2 - Um Hello
World em Java
Mídia digital
Aula 3 -
Variáveis/Constantes
Mídia digital
Aula 4 - Entrada e
saída
Mídia digital
Aula 5 - Aritmética e
funções (parte 1)
Mídia digital
Aula 6 - Aritmética e
funções (parte 2)
Mídia digital
Aula 7 - Operadores
relacionais e lógicos
e o comando IF
Mídia digital
Aula 8 - If’s
encadeados e switch
Mídia digital
Aula 9 - Laços de
Repetição (parte 1)
Mídia digital
Aula 10 - Laços de
Repetição (parte 2)
Mídia digital
Aula 11 -
Manipulando vetores
em Java (parte 1)
Mídia digital
Aula 12 -
Manipulando vetores
em Java (parte 2)
Mídia digital
Aula 13 -Criando sub-
rotinas com métodos
estáticos (parte 1)
Mídia digital
Aula 14- Criando
sub-rotinas com
métodos estáticos
(parte 2)
Instituto Federal de Minas Gerais
Pró-Reitoria de Extensão
138
Mídia digital
Aula 15 - Treinando
sintaxe com interface
gráfica (parte 1)
Mídia digital
Aula 16 - Treinando
sintaxe com interface
gráfica (parte 2)
Mídia digital
Aula 17 - Treinando
sintaxe com interface
gráfica (parte 3)
Plataforma +IFMG
Formação Inicial e Continuada EaD
A Pró-Reitoria de Extensão (Proex), neste ano de
2020 concentrou seus esforços na criação do Programa
+IFMG. Esta iniciativa consiste em uma plataforma de cursos
online, cujo objetivo, além de multiplicar o conhecimento
institucional em Educação à Distância (EaD), é aumentar a
abrangência social do IFMG, incentivando a qualificação
profissional. Assim, o programa contribui para o IFMG cumprir
seu papel na oferta de uma educação pública, de qualidade e
cada vez mais acessível.
Para essa realização, a Proex constituiu uma equipe
multidisciplinar, contando com especialistas em educação,
web design, design instrucional, programação, revisão de
texto, locução, produção e edição de vídeos e muito mais.
Além disso, contamos com o apoio sinérgico de diversos
setores institucionais e também com a imprescindível
contribuição de muitos servidores (professores e técnico-
administrativos) que trabalharam como autores dos materiais
didáticos, compartilhando conhecimento em suas áreas de atuação.
A fim de assegurar a mais alta qualidade na produção destes cursos, a Proex adquiriu
estúdios de EaD, equipados com câmeras de vídeo, microfones, sistemas de iluminação e
isolação acústica, para todos os 18 campi do IFMG.
Somando à nossa plataforma de cursos online, o Programa +IFMG disponibilizará
também, para toda a comunidade, uma Rádio Web Educativa, um aplicativo móvel para
Android e IOS, um canal no Youtube com a finalidade de promover a divulgação cultural e
científica e cursos preparatórios para nosso processo seletivo, bem como para o Enem,
considerando os saberes contemplados por todos os nossos cursos.
Parafraseando Freire, acreditamos que a educação muda as pessoas e estas, por
sua vez, transformam o mundo. Foi assim que o +IFMG foi criado.
O +IFMG significa um IFMG cada vez mais perto de você!
Pró-Reitor de Extensão do IFMG
Professor Carlos Bernardes Rosa Jr.
Pró-Reitor de Extensão do IFMG
Características deste livro:
Formato: A4
Tipologia: Arial e Capriola.
E-book:
1ª. Edição
Formato digitalMais conteúdos dessa disciplina
9780070109100, Chapter 15 2, Problem 1E- 9780070109100, Chapter 2 5, Problem 6E
- 9780030839931, Chapter 6, Problem 3P
- 9780030839931, Chapter 7, Problem 3P
- 9780030839931, Chapter 9, Problem 4P
- 9780030839931, Chapter 14, Problem 3P
- 9780030839931, Chapter 29, Problem 3P
- 9780030839931, Chapter 31, Problem 9P
- Android Studio
- ABORDAGEM ODONTOLÓGICA AO PACIENTE VÍTIMA DE LESÃO CAUSADA POR PROJÉTIL DE ARMA DE FOGO DE FOGO 22
- Simulado de Programação: Máquina de Café
- O crime de tráfico de drogas é um dos mais comuns entre pessoas negras nas prisões brasileiras. A política de guerra às drogas, historicamente, tem...
- Determine a velocidade de escoamento para uma galeria de concreto (n=0,013) de diâmetro de 800mm, inclinação de 1,0%, sendo que esta galeria transport
- Determine a velocidade de escoamento para uma galeria de concreto (n=0,013) de diâmetro de 600mm, inclinação de 1,5%, sendo que esta galeria transport
- Determine a velocidade de escoamento para uma galeria de concreto (n=0,013) de diâmetro de 1000mm, inclinação de 2,0%, sendo que esta galeria transpor
- A ABNT, através da NBR 12216/1992, permite a existência de um diferencial (redução gradativa) no gradiente de velocidade nas câmaras de floculação de
- É obrigatório que todos os membros da equipe de resposta a emergência: Questão 2Escolha uma opção: a. Sejam atléticos e pratiquem exercícios físi...
- Questão 1/10 - Fundamentos de Desenvolvimento de Software Analise as seguintes afirmativas: I. Back-end: relacionado com desenvolvimento que acontece
- Questao 1/10 Fundamentos de Desenvolvimento de Software Analise as seguintes afirmativas: I. Back-end: relacionado com desenvolvimento que acontece no
- Uma barragem é uma estrutura construída transversalmente a um vale cuja principal função é a contenção de água ou de resíduos provenientes de processo
- Imagine uma comunidade que se organiza historicamente a partir de laços familiares, tradições e papéis sociais herdados; para essa comunidade a aut...
- Quais os principais ensaios de laboratório são utilizados para determinar a toxicidade aquática? Questão 2Escolha uma opção: a. CREA50 b. ErC50...
- Qual a proporção adequada de GLP e Oxigênio para que se tenha a criação de uma atmosfera explosiva? Questão 3Escolha uma opção: a. 2% a 10% de GL...
- Calcular as vazões de dimensionamento Qa indicado na imagem abaixo de um sistema de abastecimento de água para atender uma população de 100.000 hab...
- GOVERNÇA EM TI - AULA 7
- Desafio do Módulo 3 _ 2021-1A - Bootcamp Online - Analista de Cybersecurity
