Guia prático para iniciantes em Java

Prévia do material em texto

Fornecer aos iniciantes na plataforma Java, um guia prático de onde 
começar com a linguagem. Isto é feito ao demonstrar como criar seus 
primeiros programas utilizando: variáveis, comentários de código, boas 
práticas de convenções de nomeação, leitura de dados do usuário através 
do teclado e a utilização de operadores aritméticos. 
O assunto é de suma importância para quem pretende se tornar um 
bom programador Java. Para alcançar este objetivo, recomenda-se ter o 
domínio sobre todos os conceitos apresentados aqui, pois além do Java SE 
ser utilizado para criar aplicações desktop, ele também é a base para 
desenvolvermos sistemas para web e dispositivos móveis. 
Este artigo possui um foco prático, porém apresenta os conceitos 
essenciais da tecnologia à medida que vamos avançando. O objetivo é 
construir uma aplicação simples que demonstre uma situação útil para 
utilizarmos variáveis e operadores aritméticos em Java, recebendo dados 
do teclado do usuário. 
A aplicação de exemplo ao final é um programa que soluciona equações 
matemáticas do 2º grau utilizando a fórmula de Bhaskara. Para isso, 
apresentamos os conceitos necessários do Java SE, além de classes 
utilitárias como a classe Scanner para receber dados do usuário, e a 
classe Math, que pode nos auxiliar com vários cálculos matemáticos. 
As dúvidas mais comuns de quem pretende começar a desenvolver na 
plataforma Java são: por onde começar? O que preciso instalar? Preciso 
de uma IDE? Java EE, Java ME, Java SE, JSF, JDBC, JSP? Em meio a tantas siglas 
os iniciantes se perdem. 
É importante entender que Java não é apenas uma linguagem de 
programação. Java é uma completa plataforma de desenvolvimento e 
execução, composta por três pilares: 
 A máquina virtual java (JVM); 
 Um completo conjunto de APIs (bibliotecas); 
 A linguagem Java. 
Nas primeiras versões do Java, não era possível desenvolver com outra 
linguagem além da sua padrão. Hoje, a plataforma já suporta várias 
outras linguagens, como Ruby (JRuby), Python (Jython), Scala, Groovy 
entre outras. 
Java é uma tecnologia independente de sistema operacional e hardware. 
Atualmente, ela está presente nos principais sistemas operacionais 
existentes, entre eles: Windows, Linux, Unix, Mac e Solaris. Além de ser 
https://www.devmedia.com.br/guia/programador-java/37809
https://www.devmedia.com.br/java-se-7-plataforma-java-magazine-83/18015
https://www.devmedia.com.br/guia/java-enterprise-edition-java-ee/34474
https://www.devmedia.com.br/guia/jsf-javaserver-faces/38322
https://www.devmedia.com.br/jdbc-tutorial/6638
https://www.devmedia.com.br/introducao-ao-java-server-pages-jsp/25602
utilizado para desenvolvimento de aplicações desktop, podemos adotar 
Java para implementar sistemas para web, dispositivos móveis, cartões 
de crédito, televisões digitais, geladeiras entre outros. 
Pensando nisso, neste artigo iremos apresentar uma parte de 
grande importância da plataforma Java. Conheceremos o Java SE, ou Java 
Standard Edition. O Java SE é utilizado para criarmos aplicações para 
desktop, mas também é a base para desenvolvermos para qualquer tipo 
de sistema, seja para web ou móvel. Portanto, é imprescindível ter um 
domínio sobre ele. 
O segredo da portabilidade 
Como mencionamos anteriormente, Java é independente de sistema 
operacional ou hardware. Isso dá o poder de portabilidade aos nossos 
programas. Sendo assim, um sistema escrito em Java desenvolvido, por 
exemplo, para Windows, pode ser facilmente adaptado para Linux, 
utilizando praticamente o mesmo código. 
Diferentemente do Java, uma aplicação escrita em C, por exemplo, quando 
é compilada para linguagem de máquina, gera um executável com 
instruções de máquina específicas para um sistema operacional e 
hardware, não sendo portável para outros sistemas. 
A Figura 1 demonstra o funcionamento do Java. Quando compilamos o 
código, não é gerado um executável específico para um sistema 
operacional, como acontece em outras linguagens de programação. O 
compilador, chamado javac, traduz o código para bytecodes, e estes 
bytecodes serão interpretados pela JVM. 
A JVM é uma máquina de computação abstrata (não física) que executa 
instruções, vindas de bytecodes, no sistema operacional e hardware 
específico sob o qual está rodando. 
No final das contas, o problema da portabilidade ainda existe, mas não é 
uma preocupação do desenvolvedor. Assim, basta instalar a versão 
correta da JVM no sistema desejado e seu aplicativo será portável. 
https://www.devmedia.com.br/guias/java
https://www.devmedia.com.br/introducao-ao-java-virtual-machine-jvm/27624
Figura 1. A estrutura de 
funcionamento do Java 
Para nossos exercícios, utilizaremos o sistema operacional Windows e 
criar as nossas primeiras aplicações em um simples bloco de notas. Não 
precisamos necessariamente de uma IDE (Integrated Development 
Environment ou em português, Ambiente de Desenvolvimento Integrado) 
como Eclipse ou NetBeans. As IDEs aceleram o desenvolvimento e nos 
dão maior produtividade, mas para iniciar, utilizaremos apenas um bloco 
de notas, que é o ideal até que você se familiarize com a linguagem. No 
entanto, antes de iniciar nossos estudos, vamos preparar o ambiente de 
desenvolvimento. 
Configurando o ambiente de desenvolvimento 
Para desenvolvermos aplicações Java, precisamos fazer o download e 
instalação do JDK (Java Development Kit) – veja o endereço em Links –, 
um conjunto de utilitários, o compilador, a JVM e bibliotecas necessárias 
para criarmos nossos programas. O JDK é o nosso ambiente de 
desenvolvimento. 
Para os usuários finais, que desejam apenas executar aplicações Java, é 
necessária a instalação do JRE (Java Runtime Environment). Este é o 
ambiente de execução Java, possuindo apenas a JVM e algumas APIs. 
Além do JDK, precisamos também configurar as variáveis de ambiente do 
Windows para que possamos usar o compilador Java a partir de qualquer 
diretório do sistema. Para isso, siga os passos a seguir: 
 Entre no Painel de Controle e escolha a opção Sistema; 
 Clique na aba Avançado e depois no botão Variáveis de Ambiente; 
 Adicione uma nova variável com o nome “JAVA_HOME” e o valor 
com o diretório de onde o Java foi instalado. Geralmente 
é: C:\Arquivos de Programas\Java\jdk1.6.0_18; 
 Adicione outra variável com o nome “CLASSPATH” e com o valor 
“.;%JAVA_HOME%\lib” (observe o ponto no início); 
 Edite a variável “PATH” e adicione ao final do seu valor 
“;%JAVA_HOME%\bin”; 
 Abra o prompt de comando e teste o comando javac – version. Se tudo 
foi configurado corretamente, a versão do compilador javac será 
exibida na tela. Se isso não ocorrer, revise as configurações. 
Com o ambiente de desenvolvimento configurado corretamente, estamos 
prontos para desenvolver na plataforma Java. Vamos aprender por 
onde começar. 
Como começar um programa? 
A linguagem Java possui várias regras que devem ser seguidas para 
que um programa possa ser entendido e executado pela JVM. Uma 
dessas regras é a própria sintaxe da linguagem, que é derivada de 
linguagens como C e C++. Não se preocupe se no início você estranhar a 
sintaxe. Com o tempo você se acostuma e logo será tão simples quanto 
escrever seu próprio nome! 
Dito isso, a primeira coisa a se fazer é criar uma classe, que em Java é 
definida da seguinte forma: 
class MinhaClasse { 
 
 //variáveis, métodos 
 
 } 
Como podemos observar, a sintaxe é simples. Utilizamos a palavra 
chave class, em seguida informamos o nome da classe e abrimos e 
fechamos as chaves. Entre as chaves devemos colocar o código que 
definirá o estado (variáveis, atributos) e as ações (métodos) da classe. Ao 
longo do artigo iremos aprender a usar variáveis e métodos, que definem 
as características e comportamento das classes. 
As classes são abstrações do mundo real para o código. Por exemplo, se 
precisarmos criar um cadastro de alunos, podemos criar uma classe 
chamada Aluno com atributos e métodos, de modo semelhante ao 
exemplo a seguir: 
class Aluno {String nome; 
 String matricula; 
 
 public void realizarMatricula() {} 
 
 } 
Declarando Variáveis 
As variáveis são locais na memória utilizados para armazenar algum 
valor, para que este possa ser utilizado e/ou tratado posteriormente. 
Existem dois tipos de variáveis em Java, as variáveis de referência e os 
tipos primitivos. 
Dois dos tipos primitivos são: 
 char: contém apenas um caracter, exemplo: ‘a’, ‘b’, ‘c’; 
 boolean: um valor booleano pode ser apenas true ou false. 
Os outros tipos primitivos são todos numéricos. Estes números podem 
ser negativos (menores que 0 e representados com sinal de menos) ou 
positivos (maiores que 0 e sem sinal). Cada um dos tipos numéricos 
possui um intervalo diferente. Este intervalo se refere ao menor número 
negativo possível e o maior número positivo que cada tipo pode ter. A 
fórmula para calcular o intervalo negativo é -2(bits -1) e para o intervalo 
positivo temos 2(bits - 1) – 1. 
Estes são os tipos primitivos numéricos: 
 byte: inteiro de 8 bits; 
 short: inteiro de 16 bits; 
 int: inteiro de 32 bits; 
 long: inteiro de 64 bits; 
 double: decimal de 32 bits; 
 float: decimal de 64 bits. 
Tipos primitivos não são orientados a objeto, mas devido à sua grande 
precisão e velocidade de processamento, nunca foram retirados do Java. 
As variáveis de referência são usadas para acessarmos um objeto. Após 
uma variável ter seu tipo declarado, ele nunca pode ser alterado. Neste 
artigo não falaremos muito sobre elas, mas para usarmos as 
classes String e Scanner, por exemplo, precisaremos de variáveis de 
referência. 
A declaração de variáveis é feita informando um tipo e seu identificador. 
Elas devem ser declaradas e inicializadas antes de serem utilizadas, e seu 
identificador deve ser único dentro de seu escopo. Logo mais falaremos 
sobre escopo. 
O identificador (nome da variável) é formado por caracteres Unicode. 
Eles podem ser formados por letras, cifrão ($), underline (_) e números. 
Um identificador não pode iniciar com um número, mas após o primeiro 
caractere números podem ser utilizados. A Listagem 1 exemplifica a 
declaração de variáveis válidas e inválidas. Se você tentar compilar esta 
classe, as declarações inválidas irão gerar um erro em tempo de 
compilação. 
Caracteres Unicode: Unicode é um padrão que fornece um número único para 
cada caractere, não importando a plataforma, o programa e nem a linguagem. Por 
exemplo: os números 65 e 66 se referem às letras A e B (maiúsculas), e os números 
97 e 98 às letras a e b (minúsculas). Este padrão tem sido adotado por líderes do 
setor de informática como a Apple, HP, IBM, Microsoft, Oracle, SAP e muitos outros. 
public class Variaveis { 
 
 public static void main(String args[]){ 
 String nome; // válido 
 int $idade; // válido 
 double 1preco; // inválido 
 double preco1; // válido 
 int ___$; // válido 
 String :nome; // inválido 
 } 
 
} 
Listagem 1. Variaveis.java: exemplo de declaração de variáveis válidas e inválidas; 
esta classe não compila 
Uma vez declarada, a variável deve ser inicializada, e após isso ser 
modificada e utilizada. Como mostra o exemplo abaixo, elas podem ser 
declaradas e inicializadas em uma mesma linha de código: 
String nome; // declara uma variável do tipo String 
nome = “Frederico Maia”; // inicializa com um valor 
int idade = 21; // declara e inicializa na mesma linha 
System.out.println(nome+” ”+idade); // imprime o valor das variáveis na tela 
Convenções de Código Java 
As convenções de código são uma boa prática de programação. Utilizando 
corretamente as convenções somos capazes de desenvolver códigos mais 
legíveis, com mais qualidade, que possam ser entendidos mais 
rapidamente, e seguindo os padrões recomendados pela Sun. 
Segundo a própria Sun, 80% do tempo e dos custos gastos com softwares 
estão relacionados com as atividades de manutenção. Seria ótimo se 
pudéssemos nos preocupar apenas com códigos que nós mesmos 
produzimos, mas esta não é a realidade. 
Uma atividade comum a todo desenvolvedor é a atividade de manutenção 
em aplicações. Nestes casos, se desenvolvedor que criou o sistema não se 
preocupou em seguir os padrões de código, podemos ter vários 
problemas. Podemos encontrar problemas como código mal identado, 
várias instruções na mesma linha, nomes confusos e sem significado, 
entre outras más práticas que resultam em maior dificuldade para o 
entendimento deste, prejudicando significativamente a manutenção da 
aplicação. 
Pensando nisso, a Sun criou um conjunto de padrões e publicou com o 
nome “Convenções de Código Java”. É extremamente recomendado que 
todos os desenvolvedores Java sigam esses padrões. 
A seguir listamos uma pequena parte dos padrões de nomeação 
recomendados pela Sun para alguns elementos da linguagem Java: 
 Classes e interfaces: o nome das classes e/ou interfaces deve ter a 
primeira letra maiúscula. Caso o nome seja formado por várias 
palavras, a primeira letra de cada palavra seguinte também deve 
ser maiúscula. Para classes, os nomes devem ser substantivos, 
como Pessoa, ContaBancaria e Aluno. Para interfaces, os nomes 
devem ser adjetivos, como Executavel, Serializavel; 
 Métodos: o nome dos métodos deve ter a primeira letra minúscula. 
Caso o nome também seja formado por várias palavras, a primeira 
letra de cada palavra seguinte deve ter a primeira letra maiúscula. 
Estes nomes seguem o padrão camelCase. Além disso, é 
recomendado que os nomes sejam formados por um verbo e por 
um substantivo, indicando que é uma ação sobre algo ou alguém. 
Exemplos: getName() (obterNome), saveCustomer() (salvarCliente); 
 Variáveis: a nomeação das variáveis segue o mesmo padrão dos 
métodos. São recomendados nomes curtos e significativos, como 
nomeDoAluno, saldoDaConta; 
 Constantes: variáveis que são constantes são criadas marcando-as 
como static e final. Devem ser nomeadas com todas as letras 
maiúsculas, e se houver mais de uma palavra formando o nome, 
estas palavras devem ser separadas por underline, 
como VALOR_FIXO e TITULO_TEXTO. 
Neste momento já temos conhecimento suficiente para criar nossa 
primeira aplicação. Vamos a ela! 
Criando nosso primeiro programa 
Nossa primeira aplicação, chamada HelloApp, irá simplesmente imprimir 
na tela a mensagem “Hello World!”. Para isso, primeiramente iremos criar 
um arquivo com o código fonte escrito em Java, depois iremos compilar 
este arquivo com o compilador javac, e então rodar o programa com o 
comando java. Como falamos anteriormente, precisamos do JDK instalado 
e configurado corretamente, e de um simples editor de texto. No nosso 
caso, utilizaremos o próprio Bloco de Notas do Windows. 
Com todo o ambiente de desenvolvimento configurado, entre no 
diretório c:\ do seu computador e crie uma pasta chamada java. Agora 
abra o Bloco de Notas e digite o mesmo código que se encontra 
na Listagem 2, mas com atenção, pois Java é Case Sensitive. 
Java é Case Sensitive: isto significa que o Java diferencia letras maiúsculas de 
minúsculas, por exemplo: uma variável chamada mensagem é diferente de outra 
chamada Mensagem. 
O nome do arquivo deve ser o mesmo nome da classe pública do seu 
código e ter a extensão .java. Portanto, salve este arquivo 
como HelloApp.java dentro da pasta que acabamos de criar. Logo, teremos 
um arquivo com o caminho c:/java/HelloApp.java. 
Você poderia escrever todo este código em apenas uma linha que a 
máquina virtual Java iria entender normalmente, mas para que nós 
humanos entendamos melhor o código, é uma boa prática e uma das 
recomendações das Convenções de Código da Sun, pularmos linhas e 
usarmos identação no código. 
public class HelloApp { 
 public static void main(String args[]) { 
 System.out.println(“Hello World!”); 
 } 
 } 
Listagem 2. HelloApp.java: imprime uma simples mensagem na tela 
Agora, abra o prompt de comando apartir do menu Iniciar > Executar e 
digite cmd. No prompt, digite os seguintes comandos: 
cd c:/java // entra no diretório c:/java 
javac HelloApp.java // compila a classe HelloApp.java e gera o arquivo HelloApp.class 
java HelloApp // executa o arquivo HelloApp.class e imprime na tela: “Hello World” 
Ao compilar uma classe, estamos transformando o código Java em 
bytecodes. Uma vez que o programa é compilado com sucesso, você pode 
executar sua aplicação em qualquer JVM de qualquer sistema operacional. 
O arquivo gerado terá o mesmo nome da classe, mas com a extensão 
.class. 
Quando uma classe é executada, a máquina virtual procura pelo 
método main(). Este método é o ponto de partida de todas as aplicações 
Java, e deve ser assinado desta forma: 
public static void main(String args[]) {} 
Os modificadores public e static podem ser escritos em qualquer ordem 
(public static ou static public), mas a convenção é usar como 
demonstramos: public static. No entanto, o nome do array passado por 
parâmetro não precisa necessariamente se chamar args. Estando de 
acordo com as regras de identificadores, podemos nomeá-lo da forma 
como desejarmos. 
Utilizando comentários no código 
Agora que executamos nossa primeira aplicação, vamos aprender a criar 
comentários e entender a sua importância para nós desenvolvedores. 
Comentários em Java, assim como em outras linguagens, são textos 
ignorados pelo compilador, mas que podem ser útil para nós humanos. 
Através dos comentários podemos explicar a funcionalidade de 
determinado código, para que quem esteja lendo possa compreender de 
forma mais clara a nossa intenção ao codificar. 
Existem três formas de criarmos comentários em um código Java: 
 Comentários de apenas uma linha, utilizando duas barras (//). O 
compilador ignora a partir das duas barras até o final da linha. Veja 
um exemplo: 
// texto ignorado pelo compilador 
 Comentários que podem ter mais de uma linha, com /* no início 
e */ no final: 
 /* texto que pode conter 
 várias linhas */ 
 Comentários de documentação também podem possuir várias 
linhas. O diferencial está no fato da ferramenta javadoc utilizar este 
tipo de comentário no momento de gerar a documentação para a 
aplicação: 
 /** comentários de documentação, 
 começam com barra e dois asteriscos */ 
Conhecendo os Arrays 
Para entendermos os programas seguintes, precisamos saber o que é um 
array. Um array é um objeto que pode armazenar vários valores. Contudo, 
cada array pode armazenar apenas valores de um mesmo tipo. Isto 
significa que se criarmos um array de int, só poderemos guardar dentro 
dele vários valores do tipo int. Um detalhe importante é que os arrays não 
variam de tamanho, isto é, seu tamanho é fixo, sendo definido no 
momento de sua instanciação. 
Podemos criar arrays de duas formas diferentes: 
int[] arrayDeInteiros = new int[2]; 
 arrayDeInteiros[0] = 10; 
 arrayDeInteiros[1] = 45; 
 int[] outroArray = {230,150,2011}; 
O primeiro (arrayDeInteiros) é um array que pode armazenar apenas 
dois elementos. Este tamanho foi definido no momento de sua 
instanciação (criação). O segundo array (outroArray), por sua vez, 
recebeu os valores no momento de sua criação, e teve, implicitamente, 
seu tamanho definido para três. Cada item de um array é chamado de 
elemento, e cada elemento é acessado pelo seu índice. Para acessarmos o 
primeiro elemento de um array utilizamos o índice 0, logo um array de 5 
elementos, por exemplo, possui posições de índice que variam de 0 a 4. 
Passando parâmetros pelo prompt de comando 
Como puderam perceber, o método main(String args[]) recebe um array de 
String como parâmetro. Portanto, podemos passar informações a este 
método quando executarmos o programa através do prompt de comando. 
A classe OlaNome.java, apresentada na Listagem 3, demonstra como 
podemos utilizar valores passados para o método main(). Neste exemplo, 
criamos uma variável do tipo String chamada nome, e atribuímos a esta 
variável o valor que está na posição 0 (primeira posição) do array args[]. 
Este valor é passado no momento em que executamos nossa aplicação. 
Para testar a aplicação, crie uma classe como a OlaNome.java e salve no 
diretório c:/java. Como fizemos na primeira aplicação HelloApp, entre no 
diretório c:/java e compile a sua classe. Para executar a aplicação, entre 
com o comando java OlaNome “Seu Nome” no prompt. Mantendo as 
aspas, substitua “Seu Nome” pelo seu nome. Ao executar, será impresso 
na tela uma mensagem como: Olá Frederico Maia! 
 
 
public class OlaNome { 
 
 public static void main(String args[]){ 
 String nome = args[0]; 
 System.out.println(“Olá ” + nome + "!"); 
 } 
 
 } 
Listagem 3. OlaNome.java: recebe uma String por parâmetro pelo prompt 
Escopo das variáveis 
Para trabalhar com variáveis em Java, precisamos entender algumas 
características importantes. Uma delas é o escopo das variáveis, que 
define se a variável estará disponível ou não para ser acessada em certo 
momento. 
As regras que definem onde uma variável é válida (acessível) chamam-se 
regras de escopo. Estas regras definem, por exemplo, que uma variável 
declarada dentro de um método só existe dentro dele, e não pode ser 
acessada de outro local. Referindo-se a escopo, existem dois tipos de 
variáveis: 
 variáveis globais: são declaradas dentro do corpo da classe (entre 
as chaves que a delimita) e fora de qualquer método. São acessíveis 
por qualquer método desta classe; 
 variáveis locais: são declaradas dentro dos métodos ou até em 
blocos menores, e só existem dentro deste bloco. 
A Listagem 4 apresenta algumas variáveis com escopos diferentes. As 
variáveis nome e idade são variáveis globais, portanto podem ser 
acessadas a partir de qualquer local ou método dentro da classe. Já a 
variável altura é uma variável local de método e tem um escopo menor, 
existindo apenas dentro do método imprimeDados(). Outro exemplo de 
variável local é a variável i, que foi criada dentro do bloco for. Esta possui 
um escopo ainda menor que o da altura e não pode ser acessada fora da 
estrutura de repetição for. 
Outro conceito importante que precisamos saber é sobre modificadores 
de acesso. Modificadores de acesso controlam a forma como os membros 
(atributos e métodos) de uma classe são visíveis (acessíveis) por outras 
classes. Os modificadores de acesso 
são: public, private, protected e default (default é quando não há nenhum 
modificador explícito). Para saber mais sobre modificadores, confira o 
artigo: Modificadores de Acesso em Java, publicado na segunda edição da Easy 
Java. 
public class TesteEscopo { 
 
 String nome = “Frederico Maia”; 
 int idade = 18; 
 
 public void imprimeDados(){ 
 double altura = 1.70; 
 
 for(int i=0; i<3; i++){ 
 System.out.println(i); 
 } 
 
 System.out.println(“Nome: “+nome+”\nIdade: “+idade); 
 System.out.println(“Altura: “+altura); 
 } 
 
 } 
Listagem 4. TesteEscopo.java: exemplo de variáveis em escopos diferentes 
Recebendo dados do teclado 
A forma mais comum de recebermos dados informados pelo usuário é 
através do teclado. Devido a isso, Java já possui em sua API uma classe 
para nos auxiliar com estes procedimentos. 
Observe a Listagem 5, que apresenta um programa que captura dados 
informados pelo usuário. Este programa tem uma funcionalidade simples, 
que é armazenar o nome de um aluno e suas três notas, fazer o cálculo da 
média a partir destas notas e imprimir na tela o nome e a média deste 
aluno. 
A classe padrão do Java, mais utilizada para trabalharmos com entrada de 
dados, é a classe Scanner. Podemos usá-la, por exemplo, para entrada de 
dados através de um arquivo de texto ou, como em nosso caso, através do 
https://www.devmedia.com.br/modificadores-de-acesso-do-java/27065
teclado. A classe Scanner possui métodos (funcionalidades) que permitem 
ao usuário informar valores do tipo: int, long, float,double e String. 
A Tabela 1 apresenta alguns métodos de exemplo e seus respectivos 
tipos de retorno. 
Método Tipo de Retorno 
int nextInt() Retorna o valor lido como um int. Se o valor não for 
um inteiro, ou estiver fora de sua faixa, lança uma 
exceção. 
long nextLong() Retorna o valor lido como um long. Se o valor não for 
um long, ou estiver fora de sua faixa, lança uma 
exceção. 
float 
nextFloat() 
Retorna o valor lido como um float. Se não for um float 
ou estiver fora de sua faixa, lança uma exceção. 
double 
nextDouble() 
Retorna o valor lido como um double. Se não for um 
double ou estiver fora de sua faixa, lança uma exceção. 
String next() Retorna o valor lido como uma String. A função 
termina ao encontrar um espaço em branco. Caso 
entre com um valor como “Sou Java”, apenas a palavra 
“Sou” será capturada pelo método e retornada. 
String 
nextLine() 
Retorna a String informada, mesmo com espaços. 
Neste caso, se entrar com um valor como “Sou Java”, 
este mesmo texto será retornado. 
void close() Fecha o Scanner. 
Tabela 1. Métodos e tipos de retorno da classe Scanner 
import java.util.Scanner; 
 
public class Media { 
 
 public static void main(String[] args) { 
 String nome = ""; 
 double nota1 = 0.0; 
 double nota2 = 0.0; 
 double nota3 = 0.0; 
 double media = 0.0; 
 
 Scanner entrada = new Scanner(System.in); 
 
 System.out.println("Iforme seu nome: "); 
 nome = entrada.nextLine(); 
 System.out.println("Informe o valor da nota 1: "); 
 nota1 = entrada.nextInt(); 
 System.out.println("Informe o valor da nota 2: "); 
 nota2 = entrada.nextInt(); 
 System.out.println("Informe o valor da nota 3: "); 
 nota3 = entrada.nextInt(); 
 
 media = (nota1+nota2+nota3)/3; 
 
 System.out.println("Olá "+nome+" sua média é: "+media); 
 } 
 
} 
Listagem 5. Media.java: recebe dados do usuário. 
Na primeira linha da classe Media (exibida na Listagem 5) importamos a 
classe Scanner do pacote java.util. Depois criamos uma instância dessa classe, 
com o nome entrada, passando por parâmetro System.in. Isto informa à 
instância que utilizaremos a entrada padrão do computador, que é o 
teclado. 
Através do objeto de nome entrada podemos acessar os métodos da 
classe Scanner. Então, solicitamos ao usuário que informe o valor de suas 
notas, somamos e depois dividimos por três. Observe que formamos uma 
expressão normal, assim como na Matemática, para realizarmos o cálculo. 
A soma das três notas está entre parênteses, o que faz com que sejam 
calculadas antes de qualquer outra operação, depois dividimos o valor 
total por 3 e obtemos a média. 
Operadores Aritméticos 
Agora que sabemos declarar e inicializar variáveis, vamos aprender como 
trabalhar com elas. Uma das formas de tratar e utilizar variáveis é através 
de operadores. Eles são símbolos ou palavras-chave que realizam algum 
tipo de operação e geralmente nos retornam um resultado. 
Alguns deles nós já vimos anteriormente, como o mais usado deles, que é 
o de atribuição, representado pelo sinal de igualdade (=). A função deste 
operador é atribuir um valor à variável que está à sua esquerda, como por 
exemplo: int numero = 10;. 
O Java possui operadores para a realização de funções como: adição, 
subtração, multiplicação e divisão. Assim como na álgebra, estes possuem 
uma ordem de precedência, ou seja, alguns cálculos são realizados antes 
de outros. A precedência dos operadores de multiplicação e divisão é 
maior que a dos de soma e subtração, portanto executam primeiro. Para 
tratar essas operações podemos utilizar parênteses, da mesma forma que 
na Matemática, e como já fizemos no exemplo anterior. Os símbolos de 
operadores aritméticos são: 
 + – Operador de adição (também utilizado para concatenar 
Strings); 
 - – Operador de subtração; 
 / – Operador de divisão (retorna apenas a parte inteira da divisão, 
ignorando o resto); 
 * – Operador de multiplicação; 
 % – Operador de resto (retorna o resto da divisão). 
Provavelmente, o único operador que você não conheça dessa lista seja o 
“%”, que nos retorna o resto da divisão. Por exemplo: 5 dividido por 2 tem 
como resultado 2 e resto 1, logo 5%2 é igual a 1. 
A Listagem 6 demonstra algumas operações básicas, inclusive do 
operador +, que é sobrecarregado e também realiza a função de 
concatenação de Strings. Neste código podemos perceber que as 
expressões são bem similares a expressões matemáticas. 
public class OperadoresAritmeticos { 
 
 public static void main(String args[]){ 
 int resultado = 0; 
 resultado = 10 + 5; 
 System.out.println(resultado); // imprime 15 
 
 resultado = resultado - 5; 
 System.out.println(resultado); // imprime 10 
 
 resultado = resultado / 2; 
 System.out.println(resultado); // imprime 5; 
 
 resultado = resultado * 10; 
 System.out.println(resultado); // imprime 50 
 
 resultado = resultado + 2; 
 resultado = resultado % 5; 
 System.out.println(resultado); // imprime 2 
 System.out.println(“Resultado: ” + resultado); //imprime “Resultado: 2” 
 } 
 
} 
Listagem 6. OperadoresAritmeticos.java: exemplo de uso de operadores 
aritméticos. 
A Listagem 7 apresenta um exemplo onde utilizamos o Java e seus 
operadores aritméticos para implementarmos uma classe que soluciona 
equações utilizando a fórmula de Bhaskara (lê-se Báscara). Para quem 
não conhece ou não se lembra, a Figura 2 apresenta a fórmula de 
Bhaskara que é utlizada para calcular equações de 2º grau completas. 
No código da Listagem 7, criamos um método separado do método main(), 
chamado calculaDelta(), e também utilizamos uma classe utilitária 
chamada Math, para calcular a raiz quadrada do valor de delta. 
Figura 2. Fórmula de Bhaskara. 
import java.util.Scanner; 
 
public class CalculoBhaskara { 
 
 public static void main(String[] args) { 
 
 /* instanciamos a classe Scanner e passamos por parâmetro System.in, 
 que informa à classe que a entrada de dados acontecerá pelo teclado */ 
 Scanner entrada = new Scanner(System.in); 
 
 //declaramos todas as varáveis que iremos precisar e instanciamos com valor 0 
 int delta = 0; 
 int a=0,b=0,c=0; 
 double x1 = 0; 
 double x2 = 0; 
 
 //solicitamos ao usuário que informe os valores de a, b e c e armazenamos 
 System.out.println("Informe o valor de a: "); 
 a = entrada.nextInt(); 
 System.out.println("Informe o valor de b: "); 
 b = entrada.nextInt(); 
 System.out.println("Informe o valor de c: "); 
 c = entrada.nextInt(); 
 
 /* nesse momento chamamos o método estático calculaDelta() e passamos 
 para ele os valores de a, b e c. Este método nos retorna um valor inteiro */ 
 delta = calculaDelta(a, b, c); 
 
 /* já com o valor de delta, calculamos o valor de x1 e x2. 
 Utilizamos o método sqrt() da classe Math para calcular a raiz quadrada*/ 
 x1 = (-b+Math.sqrt(delta)); 
 x1 = x1/(2*a); 
 
 x2 = (-b-Math.sqrt(delta)); 
 x2 = x2/(2*a); 
 
 //imprimimos na tela os valores encontrados 
 System.out.println("Delta: " + delta); 
 System.out.println("X1: " + x1); 
 System.out.println("X2: " + x2); 
 } 
 
 //método estático que calcula o valor de delta 
 public static int calculaDelta(int a, int b, int c) { 
 return (b*b)-4*a*c; 
 } 
} 
Listagem 7. CalculoBhaskara.java: classe que resolve equações de 2º grau. 
Classe Math: A classe Math possui vários métodos que podem nos auxiliar em 
cálculos matemáticos, como nos dar o valor de PI, gerar números aleatórios dentro 
de um intervalo, calcular a raiz quadrada, retornar valores absolutos, calcular 
logaritmo, exponenciais, seno, entre várias outras funções. Para utilizar a 
classe Math não precisamos de nenhuma diretiva de import, pois ela está no 
pacote java.lang, que é importado automaticamente em tempo de compilação. Veja a 
documentação oficial da classe Math naseção Links. 
Equações do 2º Grau Completas: Denomina-se equação do 2º grau completa, 
toda equação do tipo ax²+bx+c, com coeficientes numéricos a, b e c. Sendo que a, b 
e c devem ser diferentes de 0. 
Conclusões 
Neste artigo apresentamos um pouco dos conceitos básicos e exemplos 
práticos para iniciantes na plataforma Java. Conhecemos um pouco sobre 
a plataforma em si e que Java não é apenas uma linguagem. Além disto, 
vimos que não precisamos necessariamente de uma IDE para programar 
em Java e que, para quem está iniciando com a linguagem, é recomendado 
apenas um bloco de notas. 
Através do bloco de notas e do prompt de comando, criamos nossos 
primeiros programas e aprendemos a declarar e inicializar variáveis com 
identificadores válidos. Aprendemos também boas práticas com as 
convenções de nomeação, e o que é realmente necessário para se iniciar 
na linguagem. 
Este é apenas o início, o primeiro passo de uma prazerosa jornada sobre o 
tão admirado e importante Java. Um bom desenvolvedor deve sempre 
buscar o aprimoramento, e isso não se refere apenas à linguagem. É 
preciso conhecer as principais APIs e frameworks para se tornar um bom 
profissional. No entanto, para avançarmos na tecnologia, é preciso 
dominar os conceitos discutidos neste artigo. 
Confira também 
 
 
Linguagem Java 
Curso 
 
 
 
Cursos de Java 
Cursos 
https://www.devmedia.com.br/curso/linguagem-java-hello-word/367
https://www.devmedia.com.br/curso/linguagem-java-hello-word/367
https://www.devmedia.com.br/curso/linguagem-java-hello-word/367
https://www.devmedia.com.br/curso/linguagem-java-hello-word/367
https://www.devmedia.com.br/cursos/java
https://www.devmedia.com.br/cursos/java
https://www.devmedia.com.br/cursos/java
https://www.devmedia.com.br/cursos/java
 
 
 
O que é JDBC? 
Curso 
 
Links 
Página de downloads para JDK, JRE entre outros componentes da plataforma 
Java. 
http://www.oracle.com/technetwork/java/javase/downloads/index.html 
Documentação Oracle oficial sobre o Java SE. 
http://www.oracle.com/technetwork/java/javase/documentation/index.html 
Documentação oficial da classe Math, utilizada para cálculos matemáticos. 
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/Math.html 
Tutoriais oficiais da Oracle sobre a linguagem Java. 
http://download.oracle.com/javase/tutorial/java/nutsandbolts/index.html 
Livros 
Livro preparatório para certificação de Programador Profissional Java SE 
6.0. 
Certificação Sun para Programador Java 6 - Guia de Estudo (Exame 310-065), 
Kathy Sierra e Bert Bates, Alta Books, 2010 
Livro com conceitos inovadores de ensino para iniciantes na linguagem Java. 
Use a Cabeça Java 2ª Edição, Kathy Sierra e Bert Bates 
https://www.devmedia.com.br/curso/o-que-e-jdbc/1990
https://www.devmedia.com.br/curso/o-que-e-jdbc/1990
https://www.devmedia.com.br/curso/o-que-e-jdbc/1990
https://www.devmedia.com.br/curso/o-que-e-jdbc/1990