Escreva a classe ConversaoDeTempo com métodos estáticos para a conversão aproximada de unidades de tempo segundo a lista abaixo. Por exemplo, para uma entrada de 5 minutos, a saída esperada é 300 segundos. Por sua vez, para uma entrada de 3 semanas, a saída esperada é 21 dias, e assim por diante.
  • 1 minuto = 60 segundos;
  • 1 hora = 60 minutos;
  • 1 dia = 24 horas;
  • 1 semana =7 dias;
  • 1 mês = 30 dias;
  • 1 ano = 365 dias.

Passo 1

O enunciado pede que eu escreva a classe chamada ConversaoDeTempo que contenha métodos estáticos para converter unidades de tempo usando as aproximações dadas. As conversões e dados fornecidos são:
  • 1 minuto = 60 segundos;
  • 1 hora = 60 minutos;
  • 1 dia = 24 horas;
  • 1 semana =7 dias;
  • 1 mês =30 dias;
  • 1 ano =365 dias.
Exemplos explícitos do enunciado: converter 5 minutos resulta em 300 segundos; converter 3 semanas resulta em 21 dias.
Essas são todas as informações que o enunciado dá. A partir disso preciso fornecer a implementação da classe com métodos estáticos que realizem essas conversões (tanto métodos específicos quanto um método geral é uma boa prática).

Passo 2

Escolha do método de implementação (o “como” técnico):
Vou implementar em Java (linguagem usual em cursos de programação) uma classe pública final chamada ConversaoDeTempo com:
  • constantes estáticas para os fatores de conversão (por exemplo, segundos por minuto);
  • métodos estáticos para conversões elementares pedidas (por exemplo, minutesToSeconds, weeksToDays, monthsToDays, yearsToDays);
  • um método geral estático convert(double valor, Unidade origem, Unidade destino) que permite converter entre quaisquer unidades listadas usando segundos como unidade-base intermediária.
Por que usar segundos como unidade-base? Porque 1 minuto, 1 hora e 1 dia têm relações diretas com segundos (por multiplicação por 60 e 24), e se eu transformar qualquer valor primeiro em segundos e depois de segundos para a unidade de destino, eu cubro todas as conversões de forma simples e consistente.

Passo 3

Explicando as constantes (matemática por trás dos números):
Vamos definir constantes inteiras (ou long) que representam os fatores básicos:
  • \text{SEGUNDOS\_POR\_MINUTO} = 60 porque 1 minuto = 60 segundos.
  • \text{MINUTOS\_POR\_HORA} = 60 porque 1 hora = 60 minutos.
  • \text{HORAS\_POR\_DIA} = 24 porque 1 dia = 24 horas.
  • \text{DIAS\_POR\_SEMANA} = 7.
  • \text{DIAS\_POR\_MES} = 30.
  • \text{DIAS\_POR\_ANO} = 365.
A partir dessas, calculamos:
  • \text{SEGUNDOS\_POR\_HORA} = \text{SEGUNDOS\_POR\_MINUTO} \times \text{MINUTOS\_POR\_HORA} (ou seja, 60\times60);
  • \text{SEGUNDOS\_POR\_DIA} = \text{SEGUNDOS\_POR\_HORA} \times \text{HORAS\_POR\_DIA} (ou seja, 60\times60\times24);
    e analogamente para semanas/meses/anos multiplicando por 7, 30 ou 365 dias.

Passo 4

Estrutura pública e enum para as unidades:
Vou expor um enum interno chamado Unidade com os valores:
  • SEGUNDO, MINUTO, HORA, DIA, SEMANA, MES, ANO
O método geral irá receber um valor do tipo double e duas Unidades (origem e destino). A ideia do algoritmo:
  1. transformar o valor da unidade origem em segundos (usa multiplicações conforme Passo 3);
  2. transformar os segundos obtidos em valor na unidade destino (usa divisões inversas).
Matematicamente:
  • Se v é o valor em unidade origem e f_{\text{orig}} é o número de segundos por uma unidade origem, então segundos s = v \times f_{\text{orig}}.
  • Se f_{\text{dest}} é o número de segundos por uma unidade destino, então resultado r = \dfrac{s}{f_{\text{dest}}}.
    Ou seja:
r = v \times \frac{f_{\text{orig}}}{f_{\text{dest}}}.

Passo 5

Implementação dos métodos específicos (pedagogia passo-a-passo):
Vou implementar métodos estáticos simples que o enunciado sugere, cada um retornando um tipo numérico (usei double para permitir frações quando necessário):
  • minutesToSeconds:
    • fórmula: \text{segundos} = \text{minutos} \times 60.
    • exemplo: para \text{minutos}=5, \text{segundos}=5 \times 60 = 300.
  • hoursToMinutes:
    • fórmula: \text{minutos} = \text{horas} \times 60.
  • hoursToSeconds:
    • fórmula: \text{segundos} = \text{horas} \times 60 \times 60 (ou \text{horas} \times \text{SEGUNDOS\_POR\_HORA}).
  • daysToHours:
    • fórmula: \text{horas} = \text{dias} \times 24.
  • weeksToDays:
    • fórmula: \text{dias} = \text{semanas} \times 7.
    • exemplo: para \text{semanas}=3, \text{dias}=3 \times 7 = 21.
  • monthsToDays:
    • fórmula: \text{dias} = \text{meses} \times 30.
  • yearsToDays:
    • fórmula: \text{dias} = \text{anos} \times 365.
Também vou incluir daysToSeconds para facilitar conversões que usem dias como via intermediária:
  • daysToSeconds:
    • fórmula: \text{segundos} = \text{dias} \times 24 \times 60 \times 60.
Esses métodos são diretos multiplicativos e fáceis de aplicar na prova sem calculadora quando os números são pequenos.

Passo 6

Implementação do método geral convert e cuidados numéricos:
O método geral segue a ideia do Passo 4. Pseudocálculo que será codificado:
  1. calcular f_{\text{orig}} = segundos por uma unidade de origem;
  2. calcular f_{\text{dest}} = segundos por uma unidade de destino;
  3. calcular resultado r = v \times \dfrac{f_{\text{orig}}}{f_{\text{dest}}}.
No código vou escrever duas funções auxiliares privadas:
  • segundosPor(Unidade u) que retorna quantos segundos tem uma unidade u;
  • convert(double valor, Unidade origem, Unidade destino) que usa segundosPor para computar o resultado.
Cuidados:
  • Usei double para permitir resultados fracionados (útil por exemplo ao converter 1 segundo em minutos: \tfrac{1}{60}).
  • Para valores inteiros exatos (como 5 minutos), o resultado será um double com valor inteiro exato ( 300{,}0), que normalmente é aceitável em aplicações. Se você quiser long, seria fácil adaptar.

Passo 7

Exemplos didáticos de uso (como aplicar na prova):
  • Para converter 5 minutos para segundos: use minutesToSeconds(5) ou convert(5, Unidade.MINUTO, Unidade.SEGUNDO). Passo a passo: 5 \times 60 = 300.
  • Para converter 3 semanas para dias: use weeksToDays(3) ou convert(3, Unidade.SEMANA, Unidade.DIA). Passo a passo: 3 \times 7 = 21.
  • Para converter 2 anos para dias: yearsToDays(2) -> 2 \times 365 = 730.
  • Para converter 1 mês para segundos: convert(1, Unidade.MES, Unidade.SEGUNDO) -> primeiro 1 mês =30 dias, depois 30 dias =30\times24\times60\times60 segundos.

Resposta

public final class ConversaoDeTempo {
public enum Unidade {
    SEGUNDO, MINUTO, HORA, DIA, SEMANA, MES, ANO
}

private static final long SEGUNDOS_POR_MINUTO = 60L;
private static final long MINUTOS_POR_HORA = 60L;
private static final long HORAS_POR_DIA = 24L;
private static final long DIAS_POR_SEMANA = 7L;
private static final long DIAS_POR_MES = 30L;
private static final long DIAS_POR_ANO = 365L;

private static final long SEGUNDOS_POR_HORA = SEGUNDOS_POR_MINUTO * MINUTOS_POR_HORA; // 3600
private static final long SEGUNDOS_POR_DIA = SEGUNDOS_POR_HORA * HORAS_POR_DIA; // 86400

private ConversaoDeTempo() {
    // construtor privado para evitar instanciação
}

/* Métodos específicos pedidos / úteis */

public static double minutesToSeconds(double minutos) {
    return minutos * SEGUNDOS_POR_MINUTO;
}

public static double hoursToMinutes(double horas) {
    return horas * MINUTOS_POR_HORA;
}

public static double hoursToSeconds(double horas) {
    return horas * SEGUNDOS_POR_HORA;
}

public static double daysToHours(double dias) {
    return dias * HORAS_POR_DIA;
}

public static double weeksToDays(double semanas) {
    return semanas * DIAS_POR_SEMANA;
}

public static double monthsToDays(double meses) {
    return meses * DIAS_POR_MES;
}

public static double yearsToDays(double anos) {
    return anos * DIAS_POR_ANO;
}

public static double daysToSeconds(double dias) {
    return dias * SEGUNDOS_POR_DIA;
}

/* Método geral de conversão entre quaisquer unidades definidas em Unidade */
public static double convert(double valor, Unidade origem, Unidade destino) {
    double segundosOrigem = segundosPor(origem);
    double segundosDestino = segundosPor(destino);
    return valor * (segundosOrigem / segundosDestino);
}

private static double segundosPor(Unidade u) {
    switch (u) {
        case SEGUNDO:
            return 1.0;
        case MINUTO:
            return (double) SEGUNDOS_POR_MINUTO;
        case HORA:
            return (double) SEGUNDOS_POR_HORA;
        case DIA:
            return (double) SEGUNDOS_POR_DIA;
        case SEMANA:
            return DIAS_POR_SEMANA * (double) SEGUNDOS_POR_DIA;
        case MES:
            return DIAS_POR_MES * (double) SEGUNDOS_POR_DIA;
        case ANO:
            return DIAS_POR_ANO * (double) SEGUNDOS_POR_DIA;
        default:
            throw new IllegalArgumentException("Unidade desconhecida: " + u);
    }
}
}

Exercícios relacionados