Dúvidas, comentários e doaçoes: +55 62 9 8513 2505

Planilha de Dimensionamento de Tubulações Hidráulicas Água Fria e Água Quente Completa
Nossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes.

Java ::: Desafios e Lista de Exercícios Resolvidos ::: Matemática e Estatística

Exercício Resolvido de Java - Como simplificar frações em Java

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

Simplificar uma fração consiste em reduzir o numerador e o denominador por meio da divisão pelo máximo divisor comum aos dois números. Uma fração está totalmente simplificada quando verificamos que seus termos estão totalmente reduzidos a números que não possuem termos divisíveis entre si. Uma fração simplificada sofre alteração do numerador e do denominador, mas seu valor matemático não é alterado, pois a fração, quando tem seus termos reduzidos, torna-se uma fração equivalente.

Escreva um programa Java que pede para o usuário informar o numerador e o denominador de uma fração e mostre a fração simplificada. Use uma classe Fracao para a operação de simplificação. Em outras seções do nosso site você encontra o cálculo do MDC para encontrar o Máximo Divisor Comum.

Sua saída deverá ser parecida com:

Informe o numerador: 32
Informe o denominador: 40
A fração gerada foi: 32/40
A fração simplificada é: 4/5
Resposta/Solução:

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

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 para o usuário informar o numerador
    System.out.print("Informe o numerador: ");
    int numerador = Integer.parseInt(entrada.nextLine());
    
    // vamos pedir para o usuário informar o denominador
    System.out.print("Informe o denominador: ");
    int denominador = Integer.parseInt(entrada.nextLine());
    
    // vamos criar um objeto da classe Fracao
    Fracao f = new Fracao(numerador, denominador);
    
    // vamos mostrar a fração gerada
    System.out.println("A fração gerada foi: " + f.toString());
    
    // agora vamos simplificar esta fração
    System.out.println("A fração simplificada é: " +
      f.simplificar().toString());
  }
}

// classe usada para representar uma Fração
class Fracao{
  int numerador;
  int denominador;

  // construtor da classe 
  public Fracao(int numerador, int denominador) {
    this.numerador = numerador;
    this.denominador = denominador;
  }

  // método que simplifica a fração atual e retorna o
  // resultado como uma fração
  public Fracao simplificar(){
    // cria uma fração temporária
    Fracao temp = new Fracao(this.numerador, this.denominador);
    
    // descobrimos que é maior, o numerador ou o
    // denominador
    int n = temp.numerador, d = temp.denominador, maior;
    
    // o numerador é menor que 0?
    if (temp.numerador < 0) {
      n = -temp.numerador;
    }
    
    // descobrimos o maior
    if (n > d) {
      maior = n;
    } 
    else {
      maior = d;
    }
 
    // encontramos o maior número que divide o numerador e o
    // denominador
    int mdc = 0;
    for (int i = maior; i >= 2; i--) {
      if ((temp.numerador % i == 0) && (temp.denominador % i == 0)) {
        mdc = i;
        break;
      }
    }
 
    // agora dividimos tanto o numerador quanto o denominador
    // pelo mdc encontrado    
    if (mdc != 0) {
      temp.numerador = temp.numerador / mdc;
      temp.denominador = temp.denominador / mdc;
    }
    
    // retorna a fração temporária
    return temp;
  }
  
  // retorna uma representação textual dessa fração
  @Override
  public String toString() {
    return this.numerador + "/" + this.denominador; 
  }
}



Android Java ::: android.widget ::: Button

Como detectar um clique em um botão do Android usando o evento onClick no XML de layout

Quantidade de visualizações: 2592 vezes
Nesta dica mostrarei como podemos detectar um clique em um botão usando o evento onClick diretamente no arquivo XML de layout. No entanto, para usar este artifício, algumas regras devem ser seguidas:

a) O método chamado pelo clique do botão deverá ser public e retornar void;
b) O único parâmetro do método deverá conter apenas um objeto da classe View, representando a view na qual o evento onclick ocorreu.

Veja um exemplo completo no qual detectamos o clique no botão e exibimos uma mensagem AlertDialog contendo apenas um botão OK. Comece analisando o XML de layout (o nome do botão foi definido no arquivo strings.xml):

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="
  http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent">
  tools:context=".MainActivity">

  <Button xmlns:android="
    http://schemas.android.com/apk/res/android"
    android:id="@+id/button_send"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/btn_enviar"
    android:onClick="enviarMensagem"
    />

</LinearLayout>

Veja agora o código Java no MainActivity.java:

package com.example.estudosandroid;

import androidx.appcompat.app.AppCompatActivity;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.View;
import android.app.AlertDialog;

public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
  }

  // método público que será chamado ao clicarmos no botão
  public void enviarMensagem(View view) {
    AlertDialog dialogo = new 
      AlertDialog.Builder(MainActivity.this).create();
    dialogo.setTitle("Aviso");
    dialogo.setMessage("Esta é uma mensagem de aviso");
    dialogo.setButton(AlertDialog.BUTTON_NEUTRAL, "OK",
      new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, 
          int which){
          dialog.dismiss(); // fecha o AlertDialog
        }
      }
    );

    dialogo.show();
  }
}



Java ::: Pacote java.awt.event ::: KeyEvent

Java Swing - Como usar o método getKeyCode() da classe KeyEvent para detectar as teclas de Espaço, Enter ou Esc

Quantidade de visualizações: 6626 vezes
Em algumas situações nós precisamos detectar o pressionamento das teclas de Espaço, Enter ou Esc. Para isso podemos usar o método getKeyCode() da classe KeyEvent e testar se o código equivale a uma das constantes KeyEvent.VK_SPACE (espaço), KeyEvent.VK_ENTER (Enter) ou KeyEvent.VK_ESCAPE (Esc).

Veja um trecho de código no qual testamos se alguma destas três teclas foi pressionada:

package estudos;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class Janela extends JFrame implements KeyListener{
  public Janela(){
    super("Eventos do Teclado");
    Container c = getContentPane();
    FlowLayout layout = new FlowLayout(FlowLayout.LEFT);
    c.setLayout(layout);
    
    // vamos adicionar o objeto listener 
    addKeyListener(this);

    setSize(350, 250);
    setVisible(true);
  }
    
  @Override
  public void keyPressed(KeyEvent e){
    // a tecla Space foi pressionada?
    if(e.getKeyCode() == KeyEvent.VK_SPACE){
      JOptionPane.showMessageDialog(null, "A tecla de espaço foi pressionada");
    }
    // a tecla Enter foi pressionada?
    else if(e.getKeyCode() == KeyEvent.VK_ENTER){
      JOptionPane.showMessageDialog(null, "A tecla Enter foi pressionada");
    }
    // a tecla Esc foi pressionada?
    else if(e.getKeyCode() == KeyEvent.VK_ESCAPE){
      JOptionPane.showMessageDialog(null, "A tecla Esc foi pressionada");
    }
    else{
      JOptionPane.showMessageDialog(null, "Outra tecla foi pressionada");  
    }
  }
    
  @Override
  public void keyReleased(KeyEvent e){
    // sem implementação
  }

  @Override
  public void keyTyped(KeyEvent e){
    // sem implementação
  }   
  
  public static void main(String args[]){
    Janela j = new Janela();
    j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

É importante observar que as teclas Space, Enter e Esc podem ser detectadas somente nos eventos keyPressed e keyReleased.


C# ::: Dicas & Truques ::: Data e Hora

Como calcular a quantidade de dias decorridos em C# usando um objeto TimeSpan

Quantidade de visualizações: 8898 vezes
Em algumas ocasiões precisamos saber a quantidade de dias decorridos deste uma determinada data usando a linguagem C#. O trecho de código abaixo mostra como isso pode ser feito. Veja que usamos o construtor da estrutura DateTime para construir a data no passado e então a subtraímos da data atual. Em seguida obtemos a quantidade de dias do TimeSpan resultante:

using System;

namespace Estudos {
  class Program {
    static void Main(string[] args) {
      // vamos obter a quantidade de dias decorridos entre
      // 10/06/2009 e a data atual
      DateTime data_anterior = new DateTime(2009, 6, 10);  // 10/06/2009
      DateTime hoje = DateTime.Now;

      // obtém a quantidade de dias decorridos
      TimeSpan dif = hoje.Subtract(data_anterior);
      int decorridos = dif.Days;

      // exibe o resultado
      System.Console.WriteLine("Dias decorridos desde 10/06/2009: " +
        decorridos);

      Console.WriteLine("\n\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

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

Dias decorridos desde 10/06/2009: 4662


Nossas 20 dicas & truques de programação mais populares

Você também poderá gostar das dicas e truques de programação abaixo

Nossas 20 dicas & truques de programação mais recentes

Últimos Projetos e Códigos Fonte Liberados Para Apoiadores do Site

Últimos Exercícios Resolvidos

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


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 Apenas R$ 32,90

Planilha Web - Planilhas e Calculadoras online para estudantes e profissionais de Engenharia Civil, Engenharia Elétrica e Engenharia Mecânica.


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