A maior rede de estudos do Brasil

Grátis
106 pág.
Apostila de JSE Lógica de Programação

Pré-visualização | Página 7 de 22

apenas como referências a essas áreas. É por esse motivo que não 
devemos comparar duas strings em Java usando o sinal de igualdade (==), e sim o método equals, existente 
nos objetos dessa classe. 
Quando comparamos duas strings usando ==, não será feita uma comparação do conteúdo, mas sim da 
posição de memória ocupada pelo objeto. Mas, quando usamos equals(), a comparação é feita precisamente 
pelo conteúdo. Por isso, sempre que precisar comparar strings por valor em Java, prefira usar equals().
Mas há uma outra questão importante, também relativa ao uso de memória em Java. Toda vez que de-
claramos um objeto da classe String, estamos definindo uma cadeia de caracteres imutável. Isso significa 
simplesmente que, após definir o conteúdo de uma string, não podemos mais modificar seu conteúdo. Ou 
Java JSE: Programação Básica
29
seja, não podemos acrescentar, remover ou trocar caracteres dentro dela. Isso só pode ser feito por meio de 
uma reatribuição.
Para entender melhor, veja o exemplo no quadro 11.
Quadro 11 - Exemplo de mudança de uma string usando reatribuição
String resultado = “”;
resultado = resultado + “Nome do candidato 1\n”;
resultado = resultado + “Nome do candidato 2\n”;
Suponha que estejamos construindo uma string que vai conter uma lista de nomes de candidatos aprova-
dos em um concurso. O código anterior resulta em uma lista impressa na tela semelhante a:
Nome do candidato 1
Nome do candidato 2
Pode-se tirar duas conclusões nisso: obteve-se o resultado pretendido e foi possível mudar o valor da string 
resultado, pois concatenamos a ela duas linhas novas de texto. Mas isso não é realmente o que aconteceu.
A string resultado continua imutável. O que fizemos foi, nas duas últimas linhas do código, reatribuir um 
valor a ela, composto do seu conteúdo anterior concatenado com a nova linha. Isso resulta em duas cópias 
(para cada linha de concatenação) da variável na memória.
Em um exemplo como esse, ou com algumas poucas linhas a mais, não haveria grandes problemas em 
relação a uso de memória e desempenho do programa. Porém suponha que estejamos montando uma string 
resultante da concatenação (usando reatribuição) de centenas de linhas em um laço. Isso significa centenas 
de cópias desnecessárias da variável na memória, com seu conteúdo crescendo exponencialmente, ou seja, 
muita memória desperdiçada e sérios problemas de desempenho para o aplicativo.
Em casos como esse, é muito mais interessante usar a classe StringBuilder do Java, que foi criada justa-
mente para essa finalidade: proporcionar a criação de uma string mutável sem degradação do desempenho. 
É, literalmente, um construtor de strings.
Para usar StringBuilder, basta instanciá-la em um objeto e usar o método append dela para que um novo 
conteúdo seja concatenado à string, com mínimo prejuízo de memória e desempenho. O exemplo do quadro 
11, usando StringBuilder, ficaria como apresentado no quadro 12. 
Java JSE: Programação Básica
30
Quadro 12 - Criando uma string concatenada com StringBuilder
StringBuilder resultado = new StringBuilder();
resultado.append(“Nome do candidato 1\n”);
resultado.append(“Nome do candidato 2\n”);
String stringResultante = resultado.toString();
Posteriormente, para obter do objeto StringBuilder uma string tradicional, basta usar o método toString().
Uso do operador ternário
Ignorado por muitos, o operador ternário ? : é uma forma conveniente de se obter um resultado com 
base no teste verdadeiro ou falso de uma condição, tudo em uma única linha. Pode ser usado para substituir 
estruturas if...else, tornando o código mais conciso. Sua sintaxe é a seguinte:
resultado = condição ? valorSeVerdadeiro : valorSeFalso
Caso a condição seja avaliada como verdadeira, o resultado receberá valorSeVerdadeiro. Caso seja avalia-
da como falsa, receberá valorSeFalso. Exemplo prático em Java:
String resultadoDoAluno = (nota >= 6 ? “Aprovado” : “Reprovado”);
Projeto calculadora
Para praticar conversão de string para valores numéricos, uso de operadores aritméticos e concatenação 
de strings, vamos implementar um projeto de uma calculadora simples que solicitará inicialmente dois nú-
meros ao usuário, por meio de JOptionPane.showInputDialog(), e exibirá, usando apenas um JOptionPane.
showMessageDialog, o resultado das quatro operações matemáticas básicas usando ambos. Ao final, o pro-
jeto deverá funcionar de modo semelhante à sequência de execução definida na figura 25.
Figura 25 - Sequência de execução para a calculadora, recebendo os números 16 e 2. 
Para começar, crie um projeto chamado Calculadora. Dentro da pasta src desse projeto, adicione um paco-
te chamado calculadora. Por fim, nesse pacote, crie uma classe chamada Calc, contendo um método main(). 
Você deverá ficar com uma estrutura de projeto como a exibida na figura 26.
Java JSE: Programação Básica
31
Figura 26 - Estrutura do projeto Calculadora. 
Nosso programa deverá executar as seguintes etapas:
• Obter o primeiro número. Caso o usuário digite caracteres inválidos, será exibido um aviso e atribuído 
0 ao valor.
• Obter o segundo número, fazendo a mesma validação realizada para o primeiro.
• Calcular soma, subtração, divisão e multiplicação desses números.
• Montar uma string que exiba os resultados das quatro operações.
• Exibir a string ao usuário em uma janela.
Conseguiremos realizar facilmente esses passos usando os conceitos aprendidos até agora. Um forma de 
implementar esse exercício é mostrada no quadro 13. 
Quadro 13 – Código-fonte do arquivo Calc.java
Java JSE: Programação Básica
32
Vamos entender o que está sendo feito nos principais pontos da listagem.
• Linhas 9 a 11: declaração de variáveis double para os valores e para os resultados das operações ma-
temáticas. Note que zeramos os valores de valor1 e valor2. Isso é necessário pois o uso do try...catch 
na conversão de string para double (que temos posteriormente) faz com que o compilador Java indique 
um possível cálculo com valor não inicializado nas operações. Além do mais, definimos anteriormente 
que valores fornecidos incorretamente ficarão zerados, então já começamos com essa consideração.
• Linha 13: declaramos uma única variável string para poder apenas guardar o valor retornado pelos 
métodos showInputDialog.
• Linhas 15 a 20: solicitamos o valor1 ao usuário. Caso seja informado um valor inválido, ocorrerá uma 
exceção de formatação. Nesse caso, exibimos uma mensagem de alerta, indicando que o valor para o 
número em questão ficará zerado.
• Linhas 22 a 27: fazemos o mesmo processo das linhas 15 a 20, só que agora para o segundo número 
(variável valor2).
• Linhas 29 a 32: realizamos aqui as quatro operações matemáticas básicas usando os valores forne-
cidos.
• Linhas 34 a 38: para montar a string que será exibida ao usuário, contendo as quatro operações, 
realizaremos várias concatenações. Por isso, como vimos anteriormente, nada melhor que utilizar um 
objeto StringBuilder, juntando valores e símbolos por meio do seu método append. Veja que, ao final 
da cada operação matemática, concatenamos também a string “\n”. Esse é um caractere de escape, 
oriundo da linguagem C, que resulta em uma quebra de linha na impressão do texto.
• Linha 40: encerramos o programa exibindo a string criada no objeto StringBuilder.
Exercícios do Módulo 1 
1) Projeto Potência:
• Crie um projeto no Eclipse chamado Potencia, com um pacote chamado potencia (em letras mi-
núsculas) e uma classe também denominada Potencia, com um método main().
• Dentro de método main(), solicite, usando um JOptionPane por vez, uma base e um expoente. 
Armazene-os como tipo double.
• Caso o usuário forneça uma base ou um expoente inválidos, dê uma mensagem informando o 
fato e dizendo que o programa será fechado.
• Se a base e o expoente forem válidos, calcule a potência usando os valores passados.