Passos para Resolver Desafios com //TODO

1. Compreenda o que é necessário

Antes de começar a codificar, leia o comentário //TODO cuidadosamente. Muitas vezes, o comentário traz uma descrição clara do que é esperado de você, como uma função que precisa ser implementada ou uma lógica específica que deve ser aplicada.

Exemplo:

// TODO: Implemente a lógica para verificar se o saque é permitido considerando o saldo e o limite:

Aqui, a instrução é clara: você precisa verificar se o saque é permitido com base no saldo e no limite.

2. Identifique o que já está implementado

Na maioria dos casos, o código já está parcialmente pronto. Isso significa que você não precisa se preocupar em criar a estrutura básica, mas apenas preencher os detalhes. Então, antes de adicionar qualquer código, veja o que já foi feito.

3. Entenda o contexto antes de implementar

Verifique as variáveis, as classes e as funções já existentes. Muitas vezes, o que você precisa fazer está diretamente relacionado a outras partes do código.

Por exemplo, se a classe Conta já tem um atributo saldo, você sabe que a lógica de verificação do saldo provavelmente envolverá esse atributo. A chave é entender as entradas e saídas esperadas.

4. Preencha o //TODO com a lógica correta

Agora é hora de preencher o código no lugar do //TODO com a lógica que é solicitada. Certifique-se de seguir a descrição do comentário e use o que já foi implementado no código.

Exemplo:

Se o desafio pede para implementar a lógica de um saque em uma conta bancária com limite, o código poderia ficar assim:

public void sacar(double valor) {
  // TODO: Implemente a lógica para verificar se o saque é permitido considerando o saldo e o limite:
  if (saldo - valor >= -limite) { 
      saldo -= valor; 
      System.out.printf("Saque realizado: %.2f%n", valor);
  } else {
      System.out.println("Saque invalido: Excede limite");
  }
}

5. Teste o código

Depois de preencher os //TODO, execute o código e verifique se está funcionando corretamente. Teste com diferentes entradas para garantir que a lógica implementada está funcionando como esperado.

6. Refatore, se necessário

Após passar pelos testes iniciais, observe se há alguma parte do código que pode ser melhorada ou simplificada. Talvez você possa otimizar ou melhorar a legibilidade da sua implementação.

Dicas Úteis:

• Mantenha a clareza: A lógica que você implementa deve ser clara e simples. Evite complicar desnecessariamente.
• Siga as orientações do enunciado: Como o código geralmente já está parcialmente pronto, siga o que foi indicado nos comentários para preencher as partes faltantes corretamente.
• Evite modificar outras partes do código: Concentre-se apenas nos lugares onde há o //TODO. Modificar o que já foi feito pode causar erros ou tornar o código mais difícil de manter.

Exemplo Completo:

Desafio: Implementar um saque em uma conta bancária

Imagine que o enunciado do desafio seja criar uma classe ContaBancária, onde você precisa implementar a lógica para fazer um saque, levando em consideração o saldo e o limite de crédito.

abstract class Conta {
  protected double saldo; 

  public Conta(double saldo) {
      this.saldo = saldo;
  }

  public abstract void sacar(double valor);

  public void exibirSaldo() {
      System.out.printf("Saldo Atual: %.2f%n", saldo);
  }
}

class ContaCorrente extends Conta {
  private double limite;

  public ContaCorrente(double saldo, double limite) {
      super(saldo);
      this.limite = limite;
  }

  @Override
  public void sacar(double valor) {
      // TODO: Implemente a lógica para verificar se o saque é permitido considerando o saldo e o limite:
      if (saldo - valor >= -limite) { 
          saldo -= valor; 
          System.out.printf("Saque realizado: %.2f%n", valor);
      } else {
          System.out.println("Saque invalido: Excede limite");
      }
      exibirSaldo();
  }
}

class ContaPoupanca extends Conta {

  public ContaPoupanca(double saldo) {
      super(saldo);
  }

  @Override
  public void sacar(double valor) {
      // TODO: Implemente a lógica para verificar se o saque é permitido considerando apenas o saldo:
      if (saldo >= valor) { 
          saldo -= valor; 
          System.out.printf("Saque realizado: %.2f%n", valor);
      } else {
          System.out.println("Saque invalido: Saldo insuficiente");
      }
      exibirSaldo();
  }
}

public class Main {
  public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
      
      String tipoConta = scanner.next(); // Recebe o tipo de conta (Corrente ou Poupança)
      double saldoInicial = scanner.nextDouble(); // Recebe o saldo inicial

      Conta conta;

      // TODO: Implemente a lógica para criar uma instância de ContaCorrente ou ContaPoupanca:
      if (tipoConta.equals("Corrente")) {
          double limite = scanner.nextDouble(); // Recebe o limite de cheque especial para Conta Corrente
          conta = new ContaCorrente(saldoInicial, limite);
      } else {
          conta = new ContaPoupanca(saldoInicial);
      }

      // Realiza os saques
      while (scanner.hasNextDouble()) {
          double valorSaque = scanner.nextDouble();
          conta.sacar(valorSaque); 
      }

      scanner.close();
  }
}

Conclusão

Resolver desafios da DIO com //TODO pode parecer intimidador no começo, mas é uma excelente maneira de aprimorar suas habilidades. O processo envolve:

1. Ler e entender o que precisa ser feito nos //TODO.
2. Preencher as lacunas com a lógica correta.
3. Testar o código e garantir que funciona corretamente.
4. Refatorar e melhorar o código se necessário.

Lembre-se de que a prática constante e a resolução desses desafios são cruciais para se tornar um desenvolvedor mais eficiente e confiante.