Você está aqui: Java ::: Fundamentos da Linguagem ::: Estruturas de Controle

Tutorial de Java - Como usar a instrução condicional if e if...else do Java

Quantidade de visualizações: 53955 vezes
Instruções if e if...else permitem executar trechos de códigos baseado em condições. Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Estudos{
  public static void main(String args[]){
    int valor = 5;
    
    if(valor > 3)
      System.out.println("Valor maior que 3");
  }
}

Neste programa, a instrução

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

System.out.println("Valor maior que 3");

será executada somente se o teste (valor > 3) for verdadeiro. Observe que a expressão de teste deverá sempre ser do tipo boolean (true ou false).

Neste exemplo temos apenas uma instrução a ser executada. Isso dispensa o uso das chaves ao redor do bloco de códigos. Se o bloco contiver mais de uma instrução, as chaves são necessárias. Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Estudos{
  public static void main(String args[]){
    int valor = 5;
    
    if(valor > 3){
      System.out.println("Valor maior que 3");
      System.out.println("O valor é: " + valor);
    }
  }
} 

A instrução if...else (se...senão) é usada quando queremos fornecer um caminho alternativo ao código. Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Estudos{
  public static void main(String args[]){
    int valor = 1;
    
    if(valor > 3)
      System.out.println("Valor maior que 3");
    else
      System.out.println("Valor menor que 3");
  }
}

Você pode ainda usar if...else if...else (se...senão se...senão). Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Estudos{
  public static void main(String args[]){
    int valor = 3;
    
    if(valor > 3)
      System.out.println("Valor maior que 3");
    else if(valor < 3)
      System.out.println("Valor menor que 3");
    else
      System.out.println("Valor é igual a 3");
  }
} 


Link para compartilhar na Internet ou com seus amigos:

Java ::: Coleções (Collections) ::: HashMap

Como adicionar novos mapeamentos chave-valor a um HashMap do Java usando o método put()

Quantidade de visualizações: 9495 vezes
Novos mapeamentos chave-valor são adicionados a um HashMap da linguagem Java usando-se o método put(). Veja sua assinatura:

public V put(K key, V value)


Note que este método recebe a chave e o valor a ser inserido e retorna um objeto do mesmo tipo daquele fornecido no segundo argumento. Este retorno é muito útil para sabermos se o novo valor não sobrepôs um valor já existente. Se o retorno for null, o novo valor foi inserido. Caso contrário o retorno será o valor existente antes da sobreposição. Apenas tenha cuidado com valores null existentes como chaves ou valores. Nestes casos o retorno do método put não ajudará em nada.

Veja um exemplo do uso do método put():

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.util.*;

public class Estudos{
  public static void main(String[] args){
    
    // vamos criar uma instância de HashMap
    HashMap<Integer, String> clientes = new HashMap<Integer, String>();

    // vamos adicionar três chaves e seus valores
    clientes.put(new Integer(1), "Osmar J. Silva");
    clientes.put(new Integer(2), "Salvador Miranda de Andrade");
    clientes.put(new Integer(3), "Marcos da Costa Santos");

    // é possível também referenciar o valor adicionado
    // ao HashMap, uma vez que este é o retorno do métoto put()
    String nome = clientes.put(new Integer(2), "Carlos"); 

    if(nome == null){
      System.out.println("Novo valor inserido com sucesso");
    }
    else{
      System.out.println("Valor já existia. Houve sopreposição"); 
    }

    System.exit(0);
  }
}

Ao executar este código Java nós teremos o seguinte resultado:

Valor já existia. Houve sopreposição


Java ::: Desafios e Lista de Exercícios Resolvidos ::: Geometria, Trigonometria e Figuras Geométricas

Exercícios Resolvidos de Java - Como calcular a área de um losango em Java

Quantidade de visualizações: 4694 vezes
Pergunta/Tarefa:

Um losango é um quadrilátero equilátero, ou seja, é um polígono formado por quatro lados de igual comprimento. Um losango é também um paralelogramo. Alguns autores exigem ainda que nenhum dos ângulos do quadrilátero seja reto para que ele seja considerado um losango.

A área (em metros quadrados) de um losango pode ser calculada usando-se a seguinte fórmula:



Onde D1 é a diagonal maior e D2 é a diagonal menor.

Escreva um programa Java que leia a diagonal maior e a diagonal menor e calcule a área do losango. Sua saída deverá ser parecida com:

Informe a medida da diagonal maior: 5
Informe a medida da diagonal menor: 10
A área (em metros quadrados) do losango é: 25
Resposta/Solução:

Veja a resolução comentada deste exercício usando Java console:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);  
    
    // vamos ler os valores das diagonais maior e menor
    System.out.print("Informe a medida da diagonal maior: ");
    int diagonalMaior = Integer.parseInt(entrada.nextLine());
    System.out.print("Informe a medida da diagonal menor: ");
    int diagonalMenor = Integer.parseInt(entrada.nextLine());
    
    // calcula a area do losango
    int area = (diagonalMaior * diagonalMenor) / 2;
    // mostra o resultado
    System.out.println("A área (em metros quadrados) do losango é: " + area);
    
    System.out.println("\n");
  }
}



Java ::: Tratamento de Erros ::: Passos Iniciais

Quais as diferenças entre checked exceptions, runtime exceptions e errors na linguagem Java?

Quantidade de visualizações: 15445 vezes
Checked exceptions (exceções verificadas), runtime exceptions (exceções de tempo de execução) e errors (erros) possuem diferenças importantes e devem ser entendidas perfeitamente para tirarmos maior proveito da plataforma Java.

Entre as checked exceptions podemos citar FileNotFoundException, ClassNotFoundException e IOException. Agora veja: problemas tais como um arquivo não encontrado, uma classe não encontrada ou problemas com entrada e saída (talvez a impressora parou de responder ou a rede caiu) fogem completamente do domínio da aplicação. Tais exceções não são provocadas por código mal escrito ou mal testado. Desta forma, o Java força que todas as checked exceptions estejam em um bloco try...catch. Vamos ver se isso é verdade? Observe o trecho de código abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import java.io.*;

public class Estudos{
  public static void main(String[] args){
    DataInputStream in = new DataInputStream(
      new BufferedInputStream(
        new FileInputStream("conteudo.txt")));
        
    while(in.available() != 0)
      System.out.print((char) in.readByte());
    
    System.exit(0);
  }
}

Se tentarmos compilar este código teremos o seguinte resultado:

Estudos.java:7: unreported exception 
java.io.FileNotFoundException; must be caught 
or declared to be thrown
  new FileInputStream("conteudo.txt")));
  ^
Estudos.java:9: unreported exception 
java.io.IOException; must be caught or 
declared to be thrown
  while(in.available() != 0)
           ^
Estudos.java:10: unreported exception 
java.io.IOException; must be caught or 
declared to be thrown
  System.out.print((char) in.readByte());
                             ^
3 errors


Aqui nós temos uma exceção FileNotFoundException e duas exceções IOException. Vamos nos concentrar na exceção gerada pelo construtor da classe FileInputStream. Folheando a documentação do Java nós encontramos:

public FileInputStream(String name)
  throws FileNotFoundException


É aqui que as coisas começam a ficar interessantes. Todos os métodos Java que podem atirar exceções verificadas são marcados com throws e o tipo de exceção lançada. A palavra throws é usada para transferir a responsabilidade do tratamento do erro para o chamador de tais métodos. Outro exemplo é o método readByte() da classe DataInputStream:

public final byte readByte()
  throws IOException


Para corrigir as exceções acima, só precisamos usar um bloco try...catch. Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import java.io.*;

public class Estudos{
  public static void main(String[] args){
    try{
      DataInputStream in = new DataInputStream(
        new BufferedInputStream(
          new FileInputStream("conteudo.txt")));
        
      while(in.available() != 0)
        System.out.print((char) in.readByte());
    } 
    catch(IOException e){
      System.out.print(e.getMessage());
    }

    System.exit(0);
  }
}  

Exceções verificadas são todas aquelas que descendem de Exception mas não descendem de RuntimeException.

As exceções de tempo de execução (runtime exceptions) são provocadas por código mal escrito ou mal testado, ou seja, são causadas por nós programadores. Entre estas exceções podemos citar ArithmeticException, IndexOutOfBoundsException e NoSuchElementException. De fato, um erro aritmético é responsabilidade do programador, pois cabe a este verificar se os valores estão dentro da faixa permitida por cada tipo de dados.

Ao contrário das exceções verificadas, o compilador não força o uso do bloco try...catch para as runtime exceptions. De fato, isso é fácil de compreender, uma vez que tais exceções não deveriam jamais aparecer.

Contudo, pode ser desejável usar o bloco try...catch em casos em que os valores de uma operação são definidos pelo usuário. Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import java.util.*;

public class Estudos{
  public static void main(String[] args){
    Scanner in = new Scanner(System.in);
    
    System.out.print("Informe um inteiro: ");
    int valor = in.nextInt();

    System.out.print("Informe outro inteiro: ");
    int valor2 = in.nextInt();

    System.out.println("O resultado é " + 
      valor / valor2);
  }
}

Se executarmos este código e informarmos o valor 0 para o segundo inteiro, teremos a seguinte exceção:

Informe um inteiro: 4
Informe outro inteiro: 0
Exception in thread "main" 
  java.lang.ArithmeticException: / by zero
  at Estudos.main(Estudos.java:13)


Uma forma de corrigir isso é testando os valores informados para verificar suas faixas ou lançar uma exceção. Veja como usamos esta última alternativa:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import java.util.*;

public class Estudos{
  public static void main(String[] args){
    Scanner in = new Scanner(System.in);
    
    System.out.print("Informe um inteiro: ");
    int valor = in.nextInt();

    System.out.print("Informe outro inteiro: ");
    int valor2 = in.nextInt();

    try{
      System.out.println("O resultado é " + 
        valor / valor2);
    }
    catch(ArithmeticException e){
      System.out.println("Uma exceção " +
       "ArithmeticException ocorreu, " +
       "possivelmente uma tentativa de " +
       "divisão por zero.");
    }
  }
}

Agora se informarmos zero para o segundo inteiro, teremos:

Informe um inteiro: 5
Informe outro inteiro: 0
Uma exceção ArithmeticException ocorreu, 
possivelmente uma tentativa de divisão
por zero.


As runtime exceptions (causadas por falha nossa, os programadores) descedem de java.lang.RuntimeException.

Além das runtime exceptions e das checked exceptions, temos também os errors, que descedem de java.lang.Error e não devem jamais ser atirados ou tratados em blocos try...catch. Este tipo de erro é reservado para indicar problema na JVM. Entre tais erros temos OutOfMemoryError, que é lançado quando a Java Virtual Machine não consegue alocar um objeto porque sua fatia de memória esgotou e o Garbage Collector ainda não liberou mais memória. Não há razão para tratarmos isso em um bloco try...catch uma vez que, ao contrário de C++, a liberação de memória só é feita pelo GC. O melhor a fazer é deixar mesmo o programa ser encerrado e encontrar alternativas para a correção do problema.


Desafios, Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 96 usuários muito felizes estudando em nosso site.