Ofereço ajuda em Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD
+55 (062) 98553-6711
Ofereço ajuda em PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO
+55 (062) 98243-1195

Você está aqui: Java ::: Dicas & Truques ::: Matemática e Estatística

Como converter de octal para decimal em Java usando uma função recursiva

Quantidade de visualizações: 518 vezes
Muito usado na programação de computador e em hardwares, um número octal é um número na base 8, e é representado pelos dígitos de 0 a 7. Os dígitos 8 e 9 não são usados em números octais.

Já o número decimal, aquele que estamos acostumados a usar no nosso dia-a-dia, é formado pelos dígitos de 0 a 9.

Nesta dica mostrarei como converter um número octal em um número decimal usando recursividade em Java. Em outras dicas do site você encontrará outras formas de realizar esta tarefa, por exemplo, usando laços.

Veja o código Java completo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos pedir um número octal
    System.out.print("Informe um número octal: ");
    int octal = Integer.parseInt(entrada.nextLine());
    
    // mostramos o octal informado
    System.out.println("O otctal informado foi: " + octal);
    
    // agora convertemos de octal para decimal
    int decimal = converterOctalDecimal(octal);
    
    // mostramos o resultado
    System.out.println("O número decimal é: " + decimal);
  }
  
  // método recursivo para converter um número octal
  // em um número decimal
  public static int converterOctalDecimal(int octal){
    // é o caso base? vamos retornar
    if(octal == 0){
      return 0;
    }
    // efetuamos mais uma chamada recursiva
    else{
      return (octal % 10) + (8 * converterOctalDecimal(octal / 10));
    }
  }
}

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

Informe um número octal: 73
O otctal informado foi: 73
O número decimal é: 59

Link para compartilhar na Internet ou com seus amigos:

Java ::: Java + MySQL ::: Metadados da Base de Dados (Database Metadata)

Java MySQL - Como obter os tipos de dados suportados pelo MySQL e seus correspondentes JDBC usando o método getTypeInfo() da interface DatabaseMetaData

Quantidade de visualizações: 6122 vezes
Em algumas situações precisamos obter os tipos de dados suportados pelo MySQL e mapeá-los para seus correspondentes JDBC. Esta não é uma tarefa fácil, mas que, com uma pequena ajuda dos recursos de reflexão do Java, pode ser realizada depois de algumas xícaras de café.

O primeiro passo é obter os tipos de dados suportados pelo MySQL com uma chamada ao método getTypeInfo() da interface DatabaseMetaData. Os campos do ResultSet que nos interessam são TYPE_NAME e DATA_TYPE. TYPE_NAME traz o nome do tipo de dados no MySQL enquanto DATA_TYPE traz o tipo JDBC correspondente como um inteiro. Assim, o que temos que fazer é usar reflexão para obter todos os campos da classe java.sql.Types e efetuar um mapeamento entre os tipos.

Veja o código completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package estudosbancodados;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;

public class EstudosBancoDados{
  static Map mapa; // usado para mapear os tipos JDBC
  
  public static void main(String[] args) {
    // strings de conexão
    String databaseURL = "jdbc:mysql://localhost/estudos";
    String usuario = "root";
    String senha = "osmar1234";
    String driverName = "com.mysql.jdbc.Driver";

    try {
      Class.forName(driverName).newInstance();
      Connection conn = DriverManager.getConnection(databaseURL, usuario, senha);

      // vamos obter um objeto da classe com.mysql.jdbc.DatabaseMetaData
      DatabaseMetaData dbmd = conn.getMetaData();

      // vamos obter os tipos de dados suportados por esta versão do MySQL
      // e seus correspondentes JDBC
      ResultSet tiposDados = dbmd.getTypeInfo();
      while(tiposDados.next()){
        System.out.println("MySQL: " + tiposDados.getString("TYPE_NAME") + " - JDBC: " 
          + getJdbcTypeName(Integer.parseInt(tiposDados.getString("DATA_TYPE"))));
      }
      
      // vamos fechar o ResultSet
      tiposDados.close();
    }
    catch (SQLException ex) {
      System.out.println("SQLException: " + ex.getMessage());
      System.out.println("SQLState: " + ex.getSQLState());
      System.out.println("VendorError: " + ex.getErrorCode());
    }
    catch (Exception e) {
      System.out.println("Problemas ao tentar conectar com o banco de dados: " + e);
    }
  }

  // Este método retorna o nome de um tipo JDBC
  // O retorno é null se o tipo JDBC não puder ser reconhecido
  public static String getJdbcTypeName(int jdbcType){
    // vamos usar reflection para mapear valores inteiros a seus nomes
    if(mapa == null) {
      mapa = new HashMap();

      // vamos obter todos os campos da classe java.sql.Types
      Field[] campos = java.sql.Types.class.getFields();
      
      // vamos percorrer os campos
      for(int i = 0; i < campos.length; i++){
        try{
          // vamos obter o nome do campo
          String nome = campos[i].getName();

          // vamos obter o valor do campo
          Integer valor = (Integer)campos[i].get(null);

          // vamos adicionar ao mapa
          mapa.put(valor, nome);
        }
        catch(IllegalAccessException e){
          System.out.println("Ops: " + e.getMessage());
        }
      }
    }

    // vamos retornar o nome do tipo JDBC
    return (String)mapa.get(new Integer(jdbcType));
  }
}

O resultado da execução deste código foi:

MySQL: BIT - JDBC: BIT
MySQL: BOOL - JDBC: BIT
MySQL: TINYINT - JDBC: TINYINT
MySQL: TINYINT UNSIGNED - JDBC: TINYINT
MySQL: BIGINT - JDBC: BIGINT
MySQL: BIGINT UNSIGNED - JDBC: BIGINT
MySQL: LONG VARBINARY - JDBC: LONGVARBINARY
MySQL: MEDIUMBLOB - JDBC: LONGVARBINARY
MySQL: LONGBLOB - JDBC: LONGVARBINARY
MySQL: BLOB - JDBC: LONGVARBINARY
MySQL: TINYBLOB - JDBC: LONGVARBINARY
MySQL: VARBINARY - JDBC: VARBINARY
MySQL: BINARY - JDBC: BINARY
MySQL: LONG VARCHAR - JDBC: LONGVARCHAR
MySQL: MEDIUMTEXT - JDBC: LONGVARCHAR
MySQL: LONGTEXT - JDBC: LONGVARCHAR
MySQL: TEXT - JDBC: LONGVARCHAR
MySQL: TINYTEXT - JDBC: LONGVARCHAR
MySQL: CHAR - JDBC: CHAR
MySQL: NUMERIC - JDBC: NUMERIC
MySQL: DECIMAL - JDBC: DECIMAL
MySQL: INTEGER - JDBC: INTEGER
MySQL: INTEGER UNSIGNED - JDBC: INTEGER
MySQL: INT - JDBC: INTEGER
MySQL: INT UNSIGNED - JDBC: INTEGER
MySQL: MEDIUMINT - JDBC: INTEGER
MySQL: MEDIUMINT UNSIGNED - JDBC: INTEGER
MySQL: SMALLINT - JDBC: SMALLINT
MySQL: SMALLINT UNSIGNED - JDBC: SMALLINT
MySQL: FLOAT - JDBC: REAL
MySQL: DOUBLE - JDBC: DOUBLE
MySQL: DOUBLE PRECISION - JDBC: DOUBLE
MySQL: REAL - JDBC: DOUBLE
MySQL: VARCHAR - JDBC: VARCHAR
MySQL: ENUM - JDBC: VARCHAR
MySQL: SET - JDBC: VARCHAR
MySQL: DATE - JDBC: DATE
MySQL: TIME - JDBC: TIME
MySQL: DATETIME - JDBC: TIMESTAMP
MySQL: TIMESTAMP - JDBC: TIMESTAMP


Java ::: Dicas & Truques ::: Programação Orientada a Objetos

Programação orientada a objetos em Java - Como criar e usar interfaces em seus programas Java

Quantidade de visualizações: 11704 vezes
Muitos estudantes de Java torcem o nariz quando nós, professores e instrutores, tocamos no assunto de interfaces. Definitivamente este não é um tópico fácil de entender ao primeiro contato. Comecemos com uma analogia simples. É sabido que é cada vez maior o número de softwares sendo desenvolvidos em equipes, ou seja, o projeto do software é desmembrado e suas funcionalidades são implementadas por grupos diferentes de programadores.

Quando estamos desenvolvendo software em grupos de programadores, é comum desenvolvermos partes que dependem do trabalho de um outro grupo. E, nem sempre podemos esperar que uma parte da qual dependemos fique pronta para só então progredirmos.

Para isso, um contrato entre os grupos de programadores é firmado. E este contrato é o que chamamos de interface. Suponhamos que em um determinado momento meu grupo está desenvolvendo código que depende da parte de impressão, sendo desenvolvida por outro grupo. Todos se reúnem e decidimos quais funcionalidades a classe de impressão terá e quais métodos públicos serão disponibilizados. Feito isso, uma interface contendo a assinatura destes métodos é disponibilizada para todos e o desenvolvimento continua. Mais tarde, quando a classe de impressão estiver sendo desenvolvida, ela poderá implementar a interface anteriormente disponibilizada e tudo está resolvido.

Sendo assim, uma interface na linguagem de programação Java é um tipo referência, similar a uma classe. A diferença é que uma interface pode conter apenas constantes e assinaturas e métodos. Não há a implementação dos corpos dos métodos. Além disso, interfaces não podem ser instanciadas usando new. Veja o que acontece quando tentamos fazer isso (lembre-se de que List é interface):

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

import java.util.*;

public class Estudos{ 
  public static void main(String args[]){ 
    // cria um objeto da interface List
    List lista = new List();
  } 
}

Ao tentarmos compilar este código teremos a seguinte mensagem de erro:

Estudos.java:6: java.util.List is abstract; 
cannot be instantiated
    List lista = new List();
                 ^
1 error


Interfaces devem ser implementadas por classes ou extendidas por outras interfaces. Agora, um detalhe interessante. Se você verificar a API do Java, verá que a interface List é implementada pelas classes AbstractList, ArrayList, LinkedList e Vector. Desta forma, o código anterior pode ser modificado para:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

import java.util.*;

public class Estudos{ 
  public static void main(String args[]){ 
    // cria um objeto da interface List
    List lista = new ArrayList();
  } 
}

Este código compila normalmente e fortalece nossa discussão a respeito da interface de impressão. O sistema inteiro pode fazer referências a uma interface e, para que ele funcione da forma esperada, só precisamos fornecer a classe que implementa a interface no momento de instanciar os objetos. Isso demonstra que o nome de uma interface pode ser usado em qualquer lugar no qual um tipo da classe que a implementa seja necessário.

Vamos ver agora como criar uma interface chamada Pessoa. Veja:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

public interface Pessoa{
  public void setNome(String nome); 
  public String getNome();
}


Salve esta interface como Pessoa.java e a compile. Pronto! Esta interface já pode ser usada no sistema, contanto que todos do grupo tenham concordado com as assinaturas dos métodos. Agora observe uma classe Cliente que implementa esta interface:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

public class Cliente implements Pessoa{ 
  private String nome;
  private int idade;

  public void setNome(String nome){
    this.nome = nome;
  } 

  public String getNome(){
    return this.nome;
  }
}

Salve este código como Cliente.java e o compile. O primeiro detalhe a observar é o uso da palavra-chave implements para mostrar que a classe implementa a interface Pessoa. Note também que a classe fornece implementação para todos os métodos da interface. Não seguir esta regra geraria o seguinte erro de compilação:

Cliente.java:1: Cliente is not abstract and 
does not override abstract method getNome() in 
Pessoa
public class Cliente implements Pessoa{
       ^
1 error


Em resumo, uma interface define um protocolo de comunicação entre dois objetos e pode conter, além das assinaturas dos métodos, constantes. Neste caso todas estas constantes serão implicitamente public, static e final. Mesmo que estes modificadores sejam omitidos.


Java ::: Desafios e Lista de Exercícios Resolvidos ::: Laços de Repetição

Exercícios Resolvidos de Java - Usando o laço for para exibir a tabela de caracteres ASCII de 1 até 127

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

Escreva um programa Java console que usa o laço for para exibir a tabela de caracteres que são equivalentes aos códigos ASCII de 1 até 127.

Sua saída deverá ser parecida com:



Resposta/Solução:

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

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package arquivodecodigos;

public class Estudos{
  public static void main(String[] args){
    // um laço que começa em 1 e termina em 127
    for(int i = 1; i <= 127; i++){
      // vamos obter o caractere correspondente
      char c = (char)(i);
      // vamos exibí-lo
      System.out.print(c + "   ");
      
      // é hora de quebrar a linha?
      if(i % 10 == 0){
        System.out.println();
      }
    }
    
    System.out.println();
  }
}



Java ::: Dicas & Truques ::: Programação Orientada a Objetos

Como usar encapsulamento em Java - Programação Orientada a Objetos em Java

Quantidade de visualizações: 37917 vezes
Encapsulamento é a técnica de transformar os objetos que compõem uma aplicação em verdadeiras caixas-pretas. De fato, se pensarmos em termos de informática, é possível para um usuário comum usar todas as funcionalidades de uma impressora sem nem mesmo entender seu funcionamento interno. Imagine o desastre que seria se todos os usuários resolvessem abrir suas impressoras para investigar o que há dentro delas.

Da mesma forma, ao construir uma classe, devemos fazê-lo de forma que o usuário desta classe tenha acesso apenas aos métodos que permitem ler informações da classe ou fornecer os dados necessários para sua correta operação. Dados relativos ao funcionamento interno da classe devem permanecer ocultos e acessíveis somente aos métodos da própria classe.

O encapsulamento deve ser aplicado de forma a permitir que alterações na estrutura interna de uma classe não prejudique o funcionamento do código externo que a usa. Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------
 
  class Pedido{
    public List obterProdutos(){
      // monta uma lista de produtos
      // pertecentes a este pedido
      return lista;
    }
  }

A classe Pedido contém um método chamado obterProdutos() que retorna uma lista de produtos pertencentes a um determinado pedido. É aqui que o encapsulamento se torna importante. O código que usa esta classe desconhece completamente como esta lista de produtos é montada. Tudo que nos interessa é a lista de produtos que o método retorna. O programador da classe pode decidir a qualquer momento, talvez para melhorar o desempenho da classe, alterar a forma de montagem da lista. Uma vez que o nome e retorno do método (incluindo a estrutura da lista retornada) continuem sendo os mesmos, o código que usa a classe continuará funcionando como anteriormente.


Java ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Como criar, preencher e exibir os valores de uma matriz de duas dimensões de inteiros em Java - Revisado

Quantidade de visualizações: 12322 vezes
Nesta dica mostrarei como declarar e instanciar uma matriz (array) de duas dimensões de ints em Java. Note que temos duas linhas e cada linha possui duas colunas. Neste exemplo os valores da matriz já estão pré-definidos, mas você pode ver mais dicas nessa seção para aprender como solicitar que o usuário informe os valores de cada linha de coluna.

Veja o código completo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package arquivodecodigos;

public class Estudos{
  public static void main(String[] args){
    int valores[][] = {{1, 2, 3}, {4, 5, 6}};
     
    // varre todos os elementos do array e os
    // exibe usando linhas e colunas
    for(int lin = 0; lin < valores.length; lin++){
      for(int col = 0; col < valores[lin].length; col++){
        System.out.printf("%d  ", valores[lin][col]);
      }
      System.out.println();
    }     
 
    System.exit(0);
  }
}

Ao executar este exemplo nós teremos o seguinte resultado:

1  2  3  
4  5  6


Esta dica foi revisada e testada no Java 8.


Java ::: Classes e Componentes ::: JTree

Java Swing - Como criar sua primeira JTree usando um vetor de nomes de linguagens de programação

Quantidade de visualizações: 13134 vezes
Este exemplo mostra como criar uma JTree bem simples, e que servirá de base para a criação de aplicações Java Swing mais elaboradas. Os itens da JTree são fornecidos como um vetor de objetos, de forma que cada sub-vetor constitui uma seção da árvore. Os elementos (nós) são inseridos em suas devidas posições usando uma função recursiva.

Veja o resultado na figura abaixo:



E agora o código Java completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package arquivodecodigos;

import javax.swing.*;
import java.awt.*;
import javax.swing.tree.*;
 
public class Estudos extends JFrame{
  public Estudos(){
    super("Exemplo de uma JTree simples");
     
    Object[] linguagens = {
      "Linguagens",
      new Object[]{
        "Compiladas",
        "C++",
        "Delphi"
      }, 
      new Object[]{
        "Interpretadas",
        "JavaScript",
        "Python",
        "Ruby"
      }
    };
 
    DefaultMutableTreeNode raiz = montar(linguagens);
    JTree arvore = new JTree(raiz);  
 
    Container c = getContentPane();
    c.setLayout(new FlowLayout());
             
    JScrollPane scrollPane = new JScrollPane(arvore);
    c.add(scrollPane);
         
    setSize(400, 300);
    setVisible(true);
  }
     
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
 
  private DefaultMutableTreeNode montar(Object[] hier){
    DefaultMutableTreeNode no = new DefaultMutableTreeNode(hier[0]), filho;
     
    for(int i = 1; i < hier.length; i++){
      Object n_no = hier[i];
      if(n_no instanceof Object[]){ // nó possui filhos
        filho = montar((Object[])n_no);
      }
      else{
        filho = new DefaultMutableTreeNode(n_no); // folha
      }
      
      no.add(filho);
    }
 
    return(no);
  }
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico

Exercício Resolvido de Java - Escreva um algoritmo Java que leia o nome de um vendedor, o seu salário fixo e o total de vendas efetuadas por ele no mês

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

Escreva um algoritmo Java que leia o nome de um vendedor, o seu salário fixo e o total de vendas efetuadas por ele no mês (em dinheiro). Sabendo que este vendedor ganha 15% de comissão sobre suas vendas efetuadas, informar o seu nome, o salário fixo e o salário no final do mês.

Sua saída deverá ser parecida com:

Nome do vendedor: CAMILA REIS
Informe o salário fixo: 1850
Total de vendas efetuadas: 5000

Resultados:

Nome do vendedor: CAMILA REIS
Salário fixo: 1850.0
Salário final do mês: 2600.0
Resposta/Solução:

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

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos ler o nome do vendedor
    System.out.print("Nome do vendedor: ");
    String nome = entrada.nextLine();
    
    // vamos ler o salário fixo
    System.out.print("Informe o salário fixo: ");
    double salario_fixo = Double.parseDouble(entrada.nextLine());
    
    // vamos o total de vendas efetuadas pelo vendedor
    System.out.print("Total de vendas efetuadas: ");
    double total_vendas = Double.parseDouble(entrada.nextLine());
    
    // agora vamos calcular o total da comissão a ser paga
    double total_comissao = total_vendas * (15.0 / 100.0);
    
    // calculamos o salário final
    double salario_final = salario_fixo + total_comissao;
    
    // e mostramos os resultados
    System.out.println("\nResultados:\n");
    System.out.println("Nome do vendedor: " + nome);
    System.out.println("Salário fixo: " + salario_fixo);
    System.out.println("Salário final do mês: " + salario_final);
  }
}



Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico

Exercícios Resolvidos de Java - Como somar o primeiro e o último dígito de um número inteiro informado pelo usuário em Java

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

Escreva um programa Java que pede para o usuário informar um número inteiro e mostre a soma do primeiro dígito com o último dígito. Atenção: você deve usar apenas os operadores matemáticos e a função log10().

Sua saída deverá ser parecida com:

Informe um número inteiro: 48763
A soma do primeiro e do último dígito é: 7
Resposta/Solução:

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

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

package estudos;
 
import java.util.Scanner;
 
public class Estudos{ 
  public static void main(String args[]){ 
    // vamos usar a classe Scanner para a leitura dos dados
    Scanner entrada = new Scanner(System.in);
    
    // vamos pedir para o usuário informar um número inteiro
    System.out.print("Informe um número inteiro: ");
    int numero = Integer.parseInt(entrada.nextLine());
    
    // vamos obter a quantidade (-1) de dígitos no número informado
    int quant = (int)Math.log10(numero);
    int primeiro_digito = (int)(numero / Math.pow(10, quant));
    int ultimo_digito = numero % 10;
  	
    // soma o primeiro e o último dígito
    int soma = primeiro_digito + ultimo_digito;
	
    // mostra o resultado
    System.out.println("A soma do primeiro e do último dígito é: " + soma);
  }
}



Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

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á 24 usuários muito felizes estudando em nosso site.