Iniciando na linguagem Java

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 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.

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.

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
  }

} 

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.

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!”);
    }
  } 

Agora, abra o prompt de comando a partir 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 + "!");
    }
   
  } 

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);
    }
   
  } 

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 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.

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);   
  }

}

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”
  }

} 

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.

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;
  } 
} 

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

O que é JDBC?

Curso