Olá Luis, infelizmente a formatação não ficou bacana, tentei ajustar aqui para testar porém não foi possível, você poderia enviar as classes novamente ou editar para ajustar a formação?

oi Luis, você poderia editar a postagem e colocar o código formatado? :D

package br.com.caelum.fj11.modelo;
import javax.management.RuntimeErrorException;

import br.com.caelum.fj11.excecao.ValorInvalidoException;

//public abstract class Conta {
public abstract class Conta implements  Comparable<Conta> {// este formato significa que Conta pode ser classificada
//  private double saldo;
    protected double saldo;
    //private int numero;
    protected int numero;
    private String nome;

    public double getSaldo() {
        return this.saldo;
    }

    public void setSaldo(double saldo) {
        this.saldo = saldo;
    }
    public String toString() {    
        return "esse objeto é uma conta com saldo R$ " + this.nome + " " + this.saldo;
    }   


    public int getNumero() {
        return this.numero;
    }
    public int setNumero(int numero) {
        return this.numero = numero;
    }

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


    /**
     * realiza um saque na conta dado o valor passado
     * @param valor_saque valor a ser sacado
     * @return
     * @throws Exception Excption caso saldo seja insuficiente
     */
    public boolean saca(double valor_saque) throws Exception {
        if (this.saldo < valor_saque) {
            //return false;
            throw new SaldoInsuficienteException(saldo);
        }
        else {
            this.saldo = this.saldo - valor_saque;
            return true;
        }
    }

// public void deposita(double valor_dep) {//use este formato quando a classe filha de RuntimeException
     public void deposita(double valor_dep) throws ValorInvalidoException  {//use este formato quando a classe filha de Exception       
//     if (valor_dep > 0) {// neste formato utiliza a exeption do java  
//      this.saldo += valor_dep;
//     }
//     else  {
//         throw new IllegalArgumentException("Você tentou depositar" + " um valor negativo");
//     }
       if (valor_dep > 0) {// neste formato utiliza a exeption pelo programador
          this.saldo += valor_dep;
         }
         else  {
             throw new ValorInvalidoException(valor_dep);
         }       
    }      

     /**
         * atualiza nome e numero de conta
         * 
         */
        public void idConta(int numero, String nome) {
            this.numero = numero;
            this.nome   = nome;

        }

        @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((nome == null) ? 0 : nome.hashCode());
        result = prime * result + numero;
        return result;
    }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Conta other = (Conta) obj;
            if (nome == null) {
                if (other.nome != null)
                    return false;
            } else if (!nome.equals(other.nome))
                return false;
            if (numero != other.numero)
                return false;
            return true;
        }


          public int compareTo(Conta outra) {
              if(this.saldo < outra.saldo) {
                return -1;
            }
            if(this.saldo > outra.saldo) {
                return 1;
            }
            return 0;
        }

   //public void atualiza(double taxa) {                                                                                                   
   //     this.saldo += (this.saldo * taxa);                                                                                                       
   // };       
    abstract public void atualiza(double taxa);

} 
----
package br.com.caelum.fj11.modelo;

public class ContaCorrente extends Conta implements Tributavel {

    public  ContaCorrente(int numero, String nome) {
        this.setNumero(numero); 
        this.setNome(nome); 
        return;
    }

    public void atualiza(double taxa) {
             this.saldo += this.saldo * taxa * 2;
      }

    @Override
    public double calculaTributos() {
        return this.getSaldo() * 0.01;
    }

    public int compareTo(Conta outra) {
        if(this.saldo < outra.saldo) {
            return -1;
        }
        if(this.saldo > outra.saldo) {
            return 1;
        }
        return 0;
    }
}

----
package br.com.caelum.fj11.modelo;

import br.com.caelum.fj11.excecao.ValorInvalidoException;

public class ContaPoupanca extends Conta {

    public  ContaPoupanca(int numero, String nome) {
        this.setNumero(numero); 
        this.setNome(nome); 
        return;
    }

    public void atualiza(double taxa) {
        this.saldo += this.saldo * taxa * 3;
   }

   public void deposita(double valor) throws ValorInvalidoException {
        if (valor > 0) {
            this.saldo += valor - 0.10;
        }
        else {
            throw new ValorInvalidoException("Depósito de valor negativo");
        }
   }

}
----
package Testes;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import br.com.caelum.fj11.excecao.ValorInvalidoException;
import br.com.caelum.fj11.modelo.Conta;
import br.com.caelum.fj11.modelo.ContaCorrente;

public class TestaColecoes {
public static void main(String[] args) {
    //ArrayList nomes = new ArrayList<>(); // neste formato aceita qualquer coisa

    // utilizando ArrayList
    //ArrayList<String> nomes = new ArrayList<String>(); // neste fformato somente aceita string

    // utilizando a interface List com ArrayList
    //List<String> nomes = new ArrayList<String>(); // neste fformato somente aceita string

    // utilizando a interface List com LinkedList
    List<String> nomes = new LinkedList<String>(); // neste fformato somente aceita string

    nomes.add("Mauricio");
    nomes.add("Guilherme");
    System.out.println(nomes.get(0));
    System.out.println(nomes.contains("Guilherme")); // nesta caso retorna "true" porque encontrou o nome
    System.out.println(nomes.contains("Fulano")); // nesta caso retorna "false" porque não encontrou o nome

    Collections.sort(nomes); //classifica o array
// assim --for
    for (int i = 0; i < nomes.size(); i++) {
        System.out.println(nomes.get(i));
    }

// ou assim -- for it
    for (String nome : nomes) {
        System.out.println(nome);
    }

    //ArrayList contas = new ArrayList();
    ArrayList<Conta> contas = new ArrayList<Conta>();//somente aceita dados referente a contas

    //atualiza conta corrente
    ContaCorrente cc1 = new ContaCorrente(1, "Leonardo");

    try {
        cc1.deposita(2000);
    } 
   // catch (IllegalArgumentException e) {// neste formato utiliza excption do java
    catch (ValorInvalidoException e) {            
      //System.out.println("Você tentou depositar um valor inválido na sua conta corrente");
        System.out.println(e.getMessage()); //utilizando mensagem ca classe ValorInvalidoException
    }

    ContaCorrente cc2 = new ContaCorrente(2, "Eduardo");
    try {
        cc2.deposita(1500);
    } 
   // catch (IllegalArgumentException e) {// neste formato utiliza excption do java
    catch (ValorInvalidoException e) {            
          System.out.println(e.getMessage()); //utilizando mensagem ca classe ValorInvalidoException
    }

    ContaCorrente cc3 = new ContaCorrente(3, "Eduardo");
    try {
        cc3.deposita(0);
    } 
   // catch (IllegalArgumentException e) {// neste formato utiliza excption do java
    catch (ValorInvalidoException e) {            
          System.out.println(e.getMessage()); //utilizando mensagem ca classe ValorInvalidoException
    }

    contas.add(cc1);
    contas.add(cc2);
    contas.add(cc3);


    //System.out.println(contas.get(1));

    //
    //System.out.println(contas.get(1));

//    Collections.sort(contas); // neste caso não funciona porque conta não é uma estrutura que da pára classifica
//para conseguir classificar conta, tem que ir no metodo conta e informar que a Conta
//é comparavem com outra Conta.    
//public abstract class Conta implements  Comparable<Conta> {// este formato significa que Conta pode ser classificada    

    // para Collections.sort funcionar para conta o metodo compareTo
    // também teve que ser implementado na classe3 Conta
    Collections.sort(contas);

    for (Conta c : contas) {
        System.out.println(c);
    }

    }
}

Boa tarde Luis Carlos,

Bom se eu entendi bem, você quer que o texto informando o valor que tem na conta especifique que é Conta Corrente ou Conta Poupança, certo?

Para isso você pode ir em cada uma dessas classes e sobrescrever o método toString e dessa forma você pode deixar a mensagem de saída mais específica:

class ContaCorrente extends Conta {

    // Código omitido 

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "esse objeto é uma Conta Corrente com saldo R$ " + this.getNome() + " " + this.getSaldo();
    }

}

class ContaPoupanca extends Conta {

    // código omitido

   @Override
    public String toString() {
           return "esse objeto é uma Conta Pupança com saldo R$ " + this.getNome() + " " + this.getSaldo();
    }
}

Espero ter ajudado