Interpretação de algoritmo!

Boa noite galera, estou com problemas para interpretar e codificar um algoritmo!

Estou fazendo para a facul um trabalho de um “sistema bancário”. Este sistema vai possuir clientes (físico e jurídico) e três tipos de contas (corrente, poupança e especial). Até então tranquila, queria ajudar para terminar a parte da poupança. A conta poupança é uma herança da classe conta corrente. Vou postar o código e no final a dúvida pra não ficar muito longo o post.

ContaCorrente.java

[code]package bancario.contas;

import java.io.Serializable;
import java.util.Date;

public class ContaCorrente implements Serializable {
int numeroConta;
Date dataAbertura;
Date dataEncerramento;
boolean aberta;
int senha;
String identificacao;
double saldo;

public ContaCorrente(int nmro, boolean situacao, double saldo, Date dataAbertura, int senha, String identificacao) {
	this.numeroConta = nmro;
	this.aberta = situacao;
	this.saldo = saldo;
	this.senha = senha;
	this.dataAbertura = dataAbertura;
	this.identificacao = identificacao;
	this.dataEncerramento = null;

}

public String getIdentificacao() {
	return identificacao;
}

public void setIdentificacao(String identificacao) {
	this.identificacao = identificacao;
}

public int getNumeroConta() {
	return numeroConta;
}

private void setNumeroConta(int numeroConta) {
	this.numeroConta = numeroConta;
}

public Date getDataAbertura() {
	return dataAbertura;
}

private void setDataAbertura(Date dataAbertura) {
	this.dataAbertura = dataAbertura;
}

public Date getDataEncerramento() {
	return dataEncerramento;
}

private void setDataEncerramento(Date dataEncerramento) {
	this.dataEncerramento = dataEncerramento;
}

public boolean isAberta() {
	return aberta;
}

private void setAberta(boolean situacao) {
	this.aberta = situacao;
}

public int getSenha() {
	return senha;
}

private void setSenha(int senha) {
	this.senha = senha;
}

public double getSaldo() {
	return saldo;
}

private void setSaldo(double saldo) {
	this.saldo = saldo;
}

public boolean saca(double valor, int senha) {
	if ((validaSenha(senha) == true) && (valorPositivo(valor) == true) && (temSaldo(valor) == true)) {
		double novoSaldo;
		novoSaldo = (this.getSaldo() - valor);
		setSaldo(novoSaldo);
		return true;
	} else {
		return false;
	}
}

private boolean temSaldo(double valor) {
	if ((this.getSaldo() - valor) < 0) {
		return false;
	} else {
		return true;
	}
}

private boolean valorPositivo(double valor) {
	if (valor >= 0) {
		return true;
	} else {
		return false;
	}
}

public boolean deposita(double valor, int senha) {
	if ((validaSenha(senha) == true) && (valorPositivo(valor) == true)) {
		double novoSaldo;
		novoSaldo = (this.getSaldo() + valor);
		setSaldo(novoSaldo);
		return true;
	} else {
		return false;
	}
}

public boolean encerraConta(int senha) {
	if (validaSenha(senha) == true) {
		setAberta(false);
		return true;
	}
	return false;
}

public boolean validaSenha(int s) {
	if (s == this.senha) {
		return true;
	} else {
		return false;
	}
}

}[/code]

Contapoupanca.java

[code]package bancario.contas;

import java.util.Date;

public class ContaPoupanca extends ContaCorrente {

public ContaPoupanca(int nmro, boolean situacao, double saldo, Date dataAbertura, int senha,
		String identificacao) {
	super(nmro, situacao, saldo, dataAbertura, senha, identificacao);
	// TODO Auto-generated constructor stub
}

private String juros;

public String getJuros() {
	return juros;
}

public void setJuros(String juros) {
	this.juros = juros;
}

}
[/code]

OperaContaPoupanca.java (DAO da poupança)

[code]package bancario.DAO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import bancario.contas.ContaPoupanca;;

public class OperaContaPoupanca {
private List contasPoupanca = new ArrayList();

public List<ContaPoupanca> getContasPoupanca() {
	return contasPoupanca;
}

public void addConta(ContaPoupanca p) {
	contasPoupanca.add(p);
	escreveVetor();
}

public void atualizaConta(int nmro, ContaPoupanca cp) {
	for (int i = 0; i < contasPoupanca.size(); i++) {
		if (contasPoupanca.get(i).getNumeroConta() == nmro) {
			contasPoupanca.set(i, cp);
			escreveVetor();
		}
	}
}

public void removeConta(ContaPoupanca p) {
	contasPoupanca.remove(p);
	escreveVetor();
}

public void escreveVetor() {
	try {
		// Gera o arquivo para armazenar o objeto
		FileOutputStream arquivoGrav = new FileOutputStream("C:/arquivosRP/contasPoupanca.dat");
		// Classe responsavel por inserir os objetos
		ObjectOutputStream objGravar = new ObjectOutputStream(arquivoGrav);
		// Grava o objeto cliente no arquivo
		// writeObject(objGravar);
		objGravar.writeObject(contasPoupanca);
		objGravar.flush();
		objGravar.close();
		arquivoGrav.flush();
		arquivoGrav.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
}

public void recuperaVetor() {
	try {
		// Carrega o arquivo
		FileInputStream arquivoLeitura = new FileInputStream("C:/arquivosRP/contasPoupanca.dat");
		// Classe responsavel por recuperar os objetos do arquivo
		ObjectInputStream objLeitura = new ObjectInputStream(arquivoLeitura);
		contasPoupanca = (ArrayList<ContaPoupanca>) objLeitura.readObject();
		// readObject(objLeitura);
		objLeitura.close();
		arquivoLeitura.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
}

public void sacaDaContaPoupanca(double valor, int senha, int nmro) {
	for (ContaPoupanca conta : contasPoupanca) {
		if ((conta.getNumeroConta() == nmro) && (conta.saca(valor, senha) == true)) {
			atualizaConta(nmro, conta);
		}
	}
}

public void depositaDaContaPoupanca(double valor, int senha, int nmro) {
	for (ContaPoupanca conta : contasPoupanca) {
		if ((conta.getNumeroConta() == nmro) && (conta.deposita(valor, senha) == true)) {
			System.out.println(" " + conta.getSaldo());
			atualizaConta(nmro, conta);
			System.out.println("depositou ");
		} else {
			System.out.println("Nao depositou ");
		}
	}
}

public void encerraContaPoupanca(int senha, int nmro) {
	for (ContaPoupanca conta : contasPoupanca) {
		if ((conta.getNumeroConta() == nmro) && (conta.encerraConta(senha) == true)) {
			atualizaConta(nmro, conta);
		}
	}
}

public void criaContaPoupanca(int nmro, boolean situacao, double saldo, Date dataAbertura, int senha,
		String identificacao) {
	ContaPoupanca cp = new ContaPoupanca(nmro, situacao, saldo, dataAbertura, senha, identificacao);
	addConta(cp);
}

}
[/code]

Já consigo manipular ela assim como as demais contas, porém preciso implementar esse requisito:

Aceito interpretações desse requisito, de vocês que já manjam e tem uma flexibilidade maior que minha cabeça de como formular isso.

Desde já, agradecido!

Acabei por encontrar um exemplo em um site de um economista, acho que fica mais simples entender.

Exemplo

Por exemplo: caso o cliente resolva sacar R$ 1.200,00, no dia 12 (de qualquer mês), da sua conta poupança que possua um saldo de R$ 2.780,00, o sistema agirá de forma automática retirando o saldo da(s) data(s) base anterior(es) mais próxima(s) ao dia do saque:

Datas base antes do saque

04: R$ 95,00
10: R$ 358,00
11: R$1.034,00
14: R$ 313,00
15: R$ 980,00
Saldo total: R$ 2.780,00

Depois da retirada do dia 12

04: R$ 95,00
10: R$ 192,00 (resgate de R$ 166,00)
11: R$ 0,00 (resgate de R$ 1.034,00)
14: R$ 313,00
15: R$ 980,00
Saldo total: R$ 1.580,00

Como as data base mais próxima do dia 12 era o dia 11, o resgate do valor em questão (R$ 1.200,00) foi feito do saldo (R$ 1.034,00) dessa data. Entretanto, o saldo não foi suficiente e fez-se necessário passar para a data anterior mais próxima, no caso o dia 10, que tinha R$ 358,00 de saldo e com a retirada de R$ 166,00 (para complementar os R$ 1.034,00 e alcançar o valor do saque), restou R$ 192,00.