ola estou com problema em duas classes do meu sistema bancario , a classe cliente especial e a classe gerente, ambas não estão atualizando no executa banco isso está dando problema também no cobrar emprestimo, alguem pode me ajudar
public class Cliente extends Pessoa implements InterfaceCliente{
static final int dividaMaxima = 30000;
static final String tipo = "C";
private int valorContaCorrente;
private int valorDaDivida;
/* Construtor da Classe Cliente
* Este construtor invoca o construtor da classe Pessoa e inicializa os dois atributos
* do objeto que esta sendo instanciado.
*/
Cliente(String nome, int cpf, int valorInicial){
super(nome, cpf);
valorContaCorrente = valorInicial;
valorDaDivida = 0;
}
/* Metodo que retorna o valor do atributo tipo do objeto atual */
String retornaTipo() {
return tipo;
}
protected int getValorContaCorrente() {
return valorContaCorrente;
}
protected int getValorDaDivida() {
return valorDaDivida;
}
protected void setValorContaCorrente(int valor) {
valorContaCorrente = valor;
}
protected void setValorDaDivida(int valor) {
valorDaDivida = valor;
}
/* Metodo para o cliente atual obter um emprestimo de acordo com o valor passado por parametro
* Caso o valor do parametro seja menor ou igual a zero, o metodo deve retornar false
* Caso contrario ha duas situacoes:
* 1a) se o valor do parametro mais o valor do atributo valorDaDivida for maior do
* que o valor da constante dividaMaxima, o metodo deve retornar false
* 2a) caso contrario, o atributo valorDaDivida deve ser incrementado em valor, o atributo
* valorContaCorrente deve ser incrementado em valor e o metodo deve retornar true
*/
public boolean obterEmprestimo(int valor) {
if(valor<= 0) {
return false;}
else {
if(valor+valorDaDivida> dividaMaxima) {
return false;}
else {
valorDaDivida = valorDaDivida + valor;
valorContaCorrente= valorContaCorrente + valor;
return true;}}
}
/* Metodo para o cliente atual pagar parte de sua divida de acordo com o valor passado por parametro
* Caso o valor do parametro seja menor ou igual a zero, o metodo deve retornar false
* Caso contrario ha duas situacoes:
* 1a) se o valor do parametro for maior do que o valorDaDivida ou for maior do que
* valorContaCorrente, o metodo deve retornar false
* 2a) caso contrario, o atributo valorDaDivida deve ser decrementado em valor, o atributo
* valorContaCorrente deve ser decrementado em valor e o metodo deve retornar true
*/
public boolean pagarEmprestimo(int valor) {
if(valor<=0) {
return false;}
else {
if (valor > valorDaDivida || valor > valorContaCorrente) {
return false;}
else{
valorDaDivida = (valorDaDivida - valor);
valorContaCorrente =(valorContaCorrente - valor);
return true;}}}
/* Metodo que retorna true caso valorContaCorrente seja menor do que valorDaDivida.
* Caso contrario, retorna false.
*/
public boolean negativado() {
if(valorContaCorrente < valorDaDivida) {
return true;
}
return false;
}
/* Metodo para o cliente atual realizar um saque do valor passado por parametro
* Caso o valor do parametro seja menor ou igual a zero, o metodo deve retornar false
* Caso contrario ha duas situacoes:
* 1a) se o valor do parametro for maior do que o valor do atributo valorContaCorrente, o
* metodo deve retornar false
* 2a) caso contrario, o atributo valorContaCorrente deve ser decrementado em valor e o
* metodo deve retornar true
*/
public boolean realizarSaque(int valor) {
if(valor<=0) {
return false;}
else {
if(valor > valorContaCorrente) {
return false;}
else {
valorContaCorrente = (valorContaCorrente - valor);
return true;}}
}
}
public class ClienteEspecial extends Cliente{
static final int dividaMaxima = 50000;
static final String tipo = "CE";
/* Construtor da Classe ClienteEspecial
* Este construtor invoca o construtor da classe Cliente.
*/
ClienteEspecial(String nome, int cpf, int valor){
super(nome, cpf, valor);
}
/* Metodo que retorna o valor do atributo tipo do objeto atual */
String retornaTipo() {
return tipo;
}
public boolean obterEmprestimo(int valor) {
int Divida= super.getValorDaDivida();
int ContCor = super.getValorContaCorrente();
if(valor<= 0) {
return false;}
else {
if (valor+Divida> dividaMaxima) {
return false; }
else {
Divida = (Divida-valor);
ContCor = (ContCor - valor);
return true;}
}}
}
//cliente especial é uma subclasse de cliente vai
public class Gerente extends Pessoa implements InterfaceGerente{
private static final String tipo = "G";
private Cliente[] clientes;
private int numClientes;
/* Construtor da Classe Gerente
* Este construtor invoca o construtor da classe Pessoa e inicializa os dois atributos
* do objeto que esta sendo instanciado.
*/
Gerente(String nome, int cpf){
super(nome, cpf);
clientes = new Cliente[20];
numClientes = 0;
}
/* Metodo que retorna o valor do atributo tipo do objeto atual */
String retornaTipo() {
return tipo;
}
/* Metodo para imprimir informacoes sobre os clientes gerenciados pelo gerente atual
*/
void imprimirClientes(){
Cliente atual;
System.out.println("\tNumero de clientes: " + numClientes);
for (int c=0; c < numClientes; c++){
atual = clientes[c];
System.out.println("\t" + (c+1) + "\t" + atual.retornaTipo() + "\t" + atual.nome + "\t" + atual.cpf + "\t" + atual.getValorContaCorrente() + "\t" + atual.getValorDaDivida() + "\t" + atual.negativado());
}
}
/* Metodo para adicionar um cliente no arranjo de clientes do gerente atual.
* Caso o numero de clientes seja igual a 20, nao deve adicionar e deve retornar false.
* Caso contrario, ha duas situacoes:
* 1a: o cliente ja consta no arranjo de clientes (verifique isso usando o numero do cpf),
* neste caso o cliente nao deve ser reinserido e o metodo deve retornar false;
* 1a: o cliente passado como parametro nao consta no arranjo de clientes: o cliente
* deve ser adicionado na posicao numClientes, o atributo numClientes deve ser
* incrementado em 1 e o metodo deve retornar true.
*/
public boolean adicionarCliente(Cliente cliente) {
if(numClientes<20) {
for ( int j=0; j < numClientes; j++) {
if(this.clientes[j].cpf== cliente.cpf) {
return false;}}
if(numClientes< 20 ) {
this.clientes[numClientes]=cliente;
numClientes++;
return true;
}}
return false;
}
/* Metodo para cobrar os emprestimos de todos os clientes do gerente atual.
* Para cada um dos clientes presentes no arranjo clientes, este metodo deve:
* - nao fazer nada para o cliente, caso seu valorDaDivida seja igual a zero
* - caso contrario, ha duas situacoes:
* 1a) se o valorContaCorrente do cliente for maior ou igual ao valorDaDivida, deve
* fazer o cliente pagar a divida, isto e, o valorContaCorrente sera atualizado,
* descontando-se o valor da divida e o valorDaDivida sera zerado.
* 2a) se o valorContaCorrente do cliente for menor do que o valorDaDivida,
* deve fazer o cliente pagar parte da divida, isto e, o valorDaDivida
* sera atualizado, tendo seu valor diminuido pelo valorContaCorrente e
* o valorContaCorrente sera zerado.
*/
public void cobrarTodosEmprestimos() {
Cliente emprest;
for ( int j=0; j < this.numClientes; j++) {
emprest = clientes[j];
int Divida = emprest.getValorDaDivida();
int ContaCorrente = emprest.getValorContaCorrente();
if(Divida==0) {
ContaCorrente = ContaCorrente;
System.out.println(ContaCorrente);}
else {
if(ContaCorrente>=Divida) {
ContaCorrente =(ContaCorrente - Divida);
Divida=0;
System.out.println(ContaCorrente);}
else if(ContaCorrente< Divida) {
Divida= (Divida - ContaCorrente);
ContaCorrente=0;
System.out.println(Divida);
}
}
}
}
}