PPOO 1 2 - Introdução Java

Prévia do material em texto

Práticas de Programação 
Orientada a Objetos
GAC106 – 2022-1
Introdução à Linguagem Java
Julio César Alves DAC/ICET https://julio.dac.ufla.br
Vamos agora conhecer a Linguagem de 
Programação que utilizaremos na 
disciplina: Java.
A Linguagem Java
Como já foi dito a linguagem Java foi pensada inicialmente para sistemas 
embarcados (eletrodomésticos e afins).
E qual era a proposta para isso?
Geralmente, quando compilamos o nosso código é gerado um programa 
executável que roda no sistema operacional e hardware para o qual fizemos 
a compilação.
Em C++, por exemplo, se você quiser rodar seu programa no Windows, você precisa 
criar um programa para Windows gerado por um compilador para o Windows.
Se você quiser agora rodar seu programa no Linux, você precisa compilar novamente 
o programa em um compilador pra Linux, para que seja gerado um programa pra 
Linux.
Java tem uma ideia diferente. Eles criaram o conceito de Máquina Virtual.
Fonte: http://docs.oracle.com/javase/tutorial/getStarted/intro/definition.html
A Máquina Virtual Java (JVM)
Quando você compila um programa em Java, ao invés de ser gerado um executável para 
um sistema específico, é gerado um programa em byte-code (arquivo .class) que pode ser 
executado por uma Máquina Virtual Java (JVM).
Essa JVM é que é responsável por fazer a ponte entre o byte-code e a máquina onde o programa 
vai ser realmente executado.
Portanto, não é gerado um programa para o sistema específico. Mas é necessário que o sistema 
tenha uma máquina virtual capaz de fazer essa tradução.
Qual é a vantagem disso?
A Máquina Virtual Java (JVM)
A grande vantagem é que você pode compilar seu código uma única vez e o byte-code 
gerado pode ser executado em qualquer sistema que tenha uma JVM.
Fonte: http://docs.oracle.com/javase/tutorial/getStarted/intro/definition.html
Classe A Classe B Classe C Classe D
Classe / Programa 
Principal
Código Fonte:
Fonte: Medina e Fertig
A Máquina Virtual Java (JVM)
A ideia em si é bem interessante, pois você não precisa adaptar o seu programa 
para compilá-lo para a infinidade de equipamentos que se pretendia.
Mas quando a linguagem foi lançada, o ponto negativo era que, como o programa 
precisava ser executado pela máquina virtual, ele era muito mais lento que 
programas em C/C++, por exemplo.
Mas atualmente a JVM possui a tecnologia Hotspot que detecta trechos de 
código do programa que são muito executados (provavelmente dentro de 
loops) e, durante a execução do programa, um compilador JIT (just-in-time) é 
usado para compilar esses trechos de código para instruções nativas da 
plataforma, melhorando o desempenho da aplicação.
A Plataforma Java
Hoje em dia a JVM é bem otimizada e o hardware evoluiu muito. Portanto, para uso em 
computadores comuns o desempenho é competitivo com outras linguagens.
Outro ponto importante da linguagem Java é que ela oferece uma API (conjunto de 
classes) bem completa.
Nós chamamos de Plataforma Java essa API mais a máquina virtual Java.
Fonte: http://docs.oracle.com/javase/tutorial/getStarted/intro/definition.html
Programa básico em Java
Para que esses conceitos fiquem bem claros, vamos criar um programa “hello world” em 
Java e realizar o todo o processo de compilação da forma mais manual possível.
A primeira coisa que precisamos fazer é escrever nosso código em um editor de texto 
qualquer (poderia ser o bloco de notas, por exemplo) e salvar o arquivo com extensão “.java”.
1. Podemos escolher qualquer 
nome para nossa classe principal.
2. Mas o arquivo tem que ser salvo 
com o mesmo nome da classe.
3. Assim como em C/C++ um programa 
começa com int main, em Java a classe 
principal do programa precisa ter um 
método main com essa assinatura.
3. System.out.println é usado para exibir dados na 
saída padrão (assim como printf em C ou cout em C++).
Nesse exemplo temos as palavras-chave:
• class: define uma classe em Java.
• public: define a visibilidade das classes e métodos 
como público.
• static: indica que um método ou atributo é estático.
• void: indica que o método não retorna dado.
Já temos nosso código salvo em um arquivo programa.java. O próximo passo é compilá-lo 
para um arquivo byte-code que pode ser usado pela JVM.
Compilação em Java
javac é o compilador Java. Você passa como parâmetro o nome do arquivo 
com o código-fonte que quer compilar.
É gerado então o arquivo .class que pode ser 
executado pela Máquina Virtual Java (JVM).
Execução de um programa em Java
O próximo passo agora é fazer a JVM executar nosso programa.
Usamos o comando java 
para executar o programa.
Você passa como parâmetro o nome 
da classe principal, ou seja, o nome 
do arquivo .class, sem a extensão.
E aí está a execução do 
nosso primeiro programa!
Sintaxe do Java é baseada em C/C++
Os tipos primitivos numéricos em 
Java são similares aos de C/C++:
• int
• float
• double
O tipo booleano é chamado:
• boolean
Já strings não são tipos primitivos, são 
objetos. E a classe é:
• String
Os operadores aritméticos são iguais aos do C/C++:
• + - * / % += -= ++ --
Já os operadores lógicos são como os de C:
• igual: == 
• diferente: !=
• negação: ! 
• e lógico: && 
• ou lógico: ||
A sintaxe das estruturas condicionais (if, 
else) e de repetição (for, while) também são 
iguais às do C/C++.
Comentários também são como C/C++: // ou /* ... */
Vetores são declarados e criados como neste exemplo:
• int[] numeros = new int[10];
Saída de dados via terminal
Como visto no exemplo do primeiro programa, podemos exibir 
uma string na tela e pular para a próxima linha usando:
System.out.println(“meu texto”);
Em Java, podemos concatenar strings com tipos primitivos 
diretamente, sem precisar fazer conversões de dados. Por ex.:
int a = 10;
System.out.println(“Valor de a:” + a);
Podemos usar o comando print ao invés de println se quisermos 
exibir uma string sem pular linha.
System.out.print(“meu texto sem pular linha”);
Entrada de dados via terminal
Uma das formas de obtermos dados do usuário via linha 
de comando é usando um objeto da classe Scanner.
Precisamos criar um objeto da classe 
Scanner, passando como parâmetro a 
entrada padrão (System.in). Depois 
usamos o método nextLine da classe para 
obter informações como string e 
convertemos a string para o tipo desejado.
import java.util.Scanner;
public class Programa {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
String s = entrada.nextLine();
int a = Integer.parseInt(entrada.nextLine());
double d = Double.parseDouble(entrada.nextLine());
...
}
}
Precisamos importar a 
classe Scanner. O comando 
import é similar ao include 
do C/C++.
Obs.: a classe Scanner também possui métodos 
para pegar do usuário dados de acordo com o 
tipo esperado (mas, com eles, é necessário ler 
também o ENTER o que dificulta o uso).
Exemplo de tipos primitivos e estruturas básicas
Programa em Java que exibe 
a soma de todos os 
elementos pares de um 
vetor de inteiros.
import java.util.Scanner;
public class Programa {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
int[] numeros = new int[3];
numeros[0] = Integer.parseInt(entrada.nextLine());
numeros[1] = Integer.parseInt(entrada.nextLine());
numeros[2] = Integer.parseInt(entrada.nextLine());
int soma = 0;
for (int i = 0; i < numeros.length; i++){
if (numeros[i] % 2 == 0) {
soma += numeros[i];
}
}
System.out.println(soma);
}
}
Vetores possuem o atributo 
length que retorna o 
tamanho do vetor.
Exercício 1.1
Agora é com você!
Faça um programa em Java que encontra as raízes de uma equação do segundo grau ax2 + bx + c, 
cujos coeficientes a, b e c são passados pelo usuário:
Para calcular a raiz quadrada de um número n, você pode usar Math.sqrt(n).
17
Observações sobre Strings em Java
Em Java Strings são um caso especial em relação à construção de objetos.
No seguinte comando:
 String texto = “Oi, tudo bem?”
Um objeto String está sendocriado na memória Heap, com o texto 
informado. O comando é apenas um atalho (sugar sintax) para:
 String texto = new String(“Oi, tudo bem?”).
Além disso, uma String em Java é imutável, então se você atribuir um novo 
texto a uma String, na verdade um novo objeto String é criado e atribuído à 
variável.
Mesmo os métodos de alteração de String como o replace, na verdade, 
criam novas Strings.
18
Observações sobre Strings em Java
Por fim, o Java tenta reutilizar os mesmos objetos String quando 
possível. Ou seja, se duas variáveis String possuem o mesmo 
texto, é provável (mas não garantido) que elas referenciem o 
mesmo objeto.
Portanto, se você deseja saber se duas variáveis Strings 
possuem o mesmo texto, você não deve fazer:
 if (string1 == string2) X
Isso compara a referência (endereço) de cada variável. Para 
comparar o conteúdo da String você precisará usar o método 
equals.
 if (string1.equals(string2)) ✔
Que tal trabalharmos agora com algo mais divertido?
Um jogo talvez?
Acesse a página da disciplina no Campus Virtual e baixe o projeto Nave 2.0.
A dinâmica do jogo é simples.
• Você controla a nave da esquerda usando as setas do teclado.
• E pode atirar digitando a tecla Ctrl.
• A tecla ENTER pausa o jogo.
• O inimigo se move aleatoriamente na vertical e também atira aleatoriamente.
• Seu objetivo é destruir o maior número de inimigos possível sem ser morto.
• Você ganha 50 pontos a cada inimigo morto.
• Se você morrer, você pode reiniciar o jogo apertando F2.
Jogue um pouco e veja quantos pontos consegue alcançar:
• Mas não se esqueça de continuar os exercícios ☺
• A classe executável é a JogoNave.
Exercício 2.1 – Conhecendo o Jogo
Esse é um jogo bem simples, mas que será interessante para reforçarmos mais alguns conceitos 
de OO.
• Veja que existem seis classes no projeto:
• Nave, Inimigo, Placar, Cenario, Tiro e TesteJogo.
Abra o código da classe Nave.
• Estude o código identificando os atributos e métodos.
Repare que vários métodos começam com a palavra get.
• É muito comum chamar de getAlgumaCoisa, métodos que retornam o valor de atributos chamados 
AlgumaCoisa.
• Quando estudarmos encapsulamento ficará claro porque usamos isso.
Você consegue chutar o que o método atirar faz?
• Ele cria e retorna um novo objeto da classe Tiro toda vez que é chamado.
• Se a nave estiver viva, claro.
Exercício 2.2 – Conhecendo o código
Estude agora o código das classes Tiro e Placar
• Identifique os atributos e métodos.
Agora estude a classe Inimigo
• Avalie também os atributos e métodos.
Veja que a classe Inimigo tem como atributo um objeto da classe Random.
• Esse objeto é usado para gerar números aleatórios.
• É ele que permite fazer com que a nave se mova e atire aleatoriamente durante o jogo.
• Encontre onde ele está sendo criado e onde ele está sendo usado.
A classe Cenario nós vamos ignorar, por enquanto.
• Ela usa muitos conceitos que ainda veremos mais adiante.
• Mas se estiver curioso fique à vontade.
Exercício 2.3 – Conhecendo o código Parte 2
A classe Nave possui um método chamado getTextoExibicao.
• Repare que atualmente ele retorna uma String vazia.
• Coloque algum texto na String, compile o programa, e inicie o jogo pra ver o que acontece.
Você viu que o texto aparece ao lado da Nave.
• Vamos aproveitar isso para criar um atributo novo na classe Nave para guardar o nome do jogador.
• Crie então um atributo do tipo String chamado nomeJogador.
• Crie um método chamado alterarNome, que recebe um novo nome por parâmetro e atualiza o 
atributo nomeJogador.
• Por fim, altere o método getTextoExibicao para que ele exiba o valor do atributo nomeJogador.
• Na classe TesteJogo, chame o método alterarNome do objeto da classe Nave antes de executar o 
loopDeJogo.
Teste suas alterações.
Obs:
• Veja que o código está todo comentado!
• Portanto, não bagunce as coisas ☺ comente também todo código que criar.
Exercício 2.4 – Alterando o código
A Nave atualmente é muito fraca, certo?
• Com apenas um tiro ela morre!
• E que tal se ela tivesse escudos?
• Assim quando ela tomar um tiro ela perde um escudo, mas só morre se não tiver mais nenhum.
Altere a classe Nave de forma que ela passe a ter escudos.
• Crie um atributo numeroDeEscudos.
• Avalie em qual método ele deve ser inicializado e faça com que a nave sempre comece o jogo com três 
escudos.
• Qual parte do código deve ser alterada para que a nave não morra com um único tiro, mas sim perca 
os escudos primeiro?
• Faça a alteração no método necessário.
Jogue e teste os escudos da Nave.
Exercício 2.5 – Melhorando a Nave
Bom, foi bacana nossa nave ter ficado mais forte
• Mas quem está jogando não sabe quantos escudos a nave tem!
Altere o método getTextoExibicao para exibir o número de escudos.
• Exiba, na frente do nome do jogador, um asterisco para cada escudo que a nave possua.
Jogue novamente e teste a alteração.
• Agora ficou bem melhor!
Exercício 2.6 – Melhorando a usabilidade
Vamos deixar a dificuldade do jogo um pouco mais imprevisível
• Crie um método na classe Nave chamado gerarEscudos.
• Nesse método faça com que o atributo numeroDeEscudos receba um valor aleatório entre 0 e 5.
• Altere então a inicialização do atributo numeroDeEscudos, retirando o código atual que inicializa com 
3 e chamando o método gerarEscudos.
Jogue o jogo e reinicie-o algumas vezes ao morrer.
• Deu certo, conforme esperado?
• Senão o que ficou faltando?
Obs:
• Estude o uso do objeto da classe Random que é usado na classe Inimigo.
• Repare em todos os lugares que o atributo random é usado e veja o que precisará ser feito igual na classe Nave.
Exercício 2.7 – Comportamento aleatório
A gente facilitou as coisas colocando os escudos.
• Agora vamos dificultar um pouco.
Vamos fazer com que cada tiro do inimigo possa ter uma velocidade diferente.
• A classe tiro sabe quando um tiro é do inimigo ou da nave.
• Altere então o construtor da classe (aquele método que tem o nome igual ao da classe)
• De forma que a velocidade do tiro do inimigo (apenas dele) possa ser de 1 a 4 vezes a velocidade 
normal (sorteado aleatoriamente).
Jogue o jogo e teste a alteração
• E aí, ficou mais divertido?
Exercício 2.8 – Deixando o jogo mais difícil