Relacionar classes

Queria saber qual a melhor forma de relacionar classes? ex: tenho uma classe Cliente e outra classe Conta, eu quero que seja cadastrado 1 cliente que possua 1 conta e outro cliente que possua 2 contas. como ficaria o main??
Agradeço desde já que me ajudar.(os atributos estão todos como protected para não criar gets e sets o código ficar menor)

public class Cliente {
	
	
	 String nome;
	 String endereço;
	 String cpf;
	 int idade;
	Conta cliente;
                           }
public class Conta 

{
   double saldo;
   double limite;
    int numero;
   Cliente titular;

1o vc precisa de um array ou uma lista de contas no seu cliente, para que ele possa ter mais de uma conta.

depois pode usar construtores ou metodos “set” para relacionar um ao outro

abrasss

Valeu amigo, sou iniciante em java, você pode fazer o main o mais simples possivel, só para mim assimilar melhor como vai ficar o codigo?

Boa tarde.

Em primeiro lugar, vamos encapsular a sua classe Cliente, assim:

public class Cliente {  
      
     private String nome;  
     private String endereço;  
     private String cpf;  
     private int idade;

    public String getNome() {
        return nome;
    }

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

    public String getEndereço() {
        return endereço;
    }

    public void setEndereço(String endereço) {
        this.endereço = endereço;
    }

    public String getCpf() {
        return cpf;
    }

    public void setCpf(String cpf) {
        this.cpf = cpf;
    }

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }
    
} 

Bom, agora vamos a exatamente o que você quer fazer, ou seja, uma composição de classes, e isto você vai fazer dentro da classe conta que também vamos encapsular, antes primeiro vamos declarar dentro dela, três atributos (variáveis) do tipo cliente (titular, adicional_1 e adicional_2), além dos que já existem, assim:

public class Conta {
    
    private double saldo;  
    private double limite;
    /* Declare o número da conta como String
        pois além de facilitar em escrever contas
        com caracteres do tipo "-", "/" e outros
        caracteres que não são números, você 
        não vai fazer operações matemáticas 
        com eles, vai ?  */
    private String numero;
   
    // Aqui fazemos a composição com a classe cliente.
    private Cliente titular;
    private Cliente adicional_1;
    private Cliente adicional_2;

    public double getSaldo() {
        return saldo;
    }

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

    public double getLimite() {
        return limite;
    }

    public void setLimite(double limite) {
        this.limite = limite;
    }

    public String getNumero() {
        return numero;
    }

    public void setNumero(String numero) {
        this.numero = numero;
    }

    public Cliente getTitular() {
        if (titular == null) titular = new Cliente();
        return titular;
    }

    public void setTitular(Cliente titular) {
        this.titular = titular;
    }

    public Cliente getAdicional_1() {
        if (adicional_1 == null) adicional_1 = new Cliente();
        return adicional_1;
    }

    public void setAdicional_1(Cliente adicional_1) {
        this.adicional_1 = adicional_1;
    }

    public Cliente getAdicional_2() {
        if (adicional_2 == null) adicional_2 = new Cliente();
        return adicional_2;
    }

    public void setAdicional_2(Cliente adicional_2) {
        this.adicional_2 = adicional_2;
    }
              
}

Repare que dentro dos métodos “get”, onde estão as classes clientes, estou instanciando eles lá dentro, afim de evitar o nullPointer e também isto me facilita não ser preciso instanciá-los dentro da classe main, para depois setar a sua referência dentro da classe conta, criando assim uma única referência deste cliente, e isto facilita e muito. Ai no main, você só ira instanciar a classe conta desta forma:

public class TesteClasses {

    public static void main(String[] args) {
        Conta conta = new Conta();
        
        // Inserindo dados em conta
        conta.setLimite(2500.00);
        conta.setSaldo(2467.00);
        conta.setNumero("5678-9");
        
        /* Repare que aqui e não preciso instaciar o cliente
           isto porque o método getTitular e adicionais
           já farão isto dentro da classe conta.
         */
        
        // Titular
        conta.getTitular().setNome("Sg5001");
        conta.getTitular().setCpf("171.171.171-71"); // kkkkkkkkk
        conta.getTitular().setEndereço("5th avenue, 77, Manhattan, New York");
        
         // Adicional_1
        conta.getAdicional_1().setNome("Sg5002");
        conta.getAdicional_1().setCpf("222.222.222-2"); // kkkkkkkkk
        conta.getAdicional_1().setEndereço("5th avenue, 77, Manhattan, New York");
        
        // Adicional_2
         // Titular
        conta.getAdicional_2().setNome("Sg5003");
        conta.getAdicional_2().setCpf("342.342.342-142"); // 2 X 171 kkkkkkkkk
        conta.getAdicional_2().setEndereço("5th avenue, 77, Manhattan, New York");
        
    }
}

Viu, isto é o que chamamos de composição de classes, e fica mais fácil trabalhar.

Um abraço.

Muito obrigado discorpio, ajudou bastante. outra duvida minha bem simples se eu criar um menu principal ex:
MENU PRINCIPAL
1-CADASTRAR CLIENTES
2-EDITAR CLIENTES
3-VISUALIZAR CLIENTES
4-SAIR.

Qual o método que você indica? usar Switch-case ?

Boa noite.

Sim, crie primeiro constantes do tipo final, assim:

public static void main(String[] args) {
        
        final int CADASTRAR = 1;
        final int EDITAR = 2;
        final int VISUALIZAR = 3;
        final int SAIR = 4;
        
        int op = 0;
        
        while (op != SAIR){
            System.out.println("Digite uma das opções abaixo");
            System.out.println("----------------------------");
            System.out.println("1 - Cadastrar Clientes");
            System.out.println("2 - Editar Clientes");
            System.out.println("3 - Visualizar Clientes");
            System.out.println("4 - Sair");
            
            Scanner scan = new Scanner(System.in);
            op = scan.nextInt();
            switch (op){
                case CADASTRAR:
                     // Crie um método estático cadastrar e invoque ele aqui
                     break;
                case EDITAR:
                     // Crie um método estático editar e invoque ele aqui
                     break;
                case VISUALIZAR:
                     // Crie um método estático  e invoque ele aqui
                     break;
                default:
                    if (op == SAIR){
                       System.out.println("Saindo do sistema"); 
                    } else {
                       System.out.println("Digite números de 1 a 4"); 
                    }
                    break;
            }
       }
 }

Deixei os métodos estáticos individuais para cada item do menu, para você fazer, afinal você também tem raciocinar uma pouquinho né. :roll:

Crie estes métodos fora do método main, e crie eles como estáticos, para que eles possam ser enxergados dentro método main, assim:


   public static void Cadastrar() {
         ...............
         ..............
   }

Um abraço

Também existe opção de transformar a classe Conta em uma Interface e implementar em cliente.

Discorpio, desculpa incomodar de novo, mas porque você criou Cliente adicional_1 e Cliente adicional_2 se já existia Cliente titular, se eu for criar 10 contas vou ter que ter 10 Clientes adicionais ?? Como posso um cliente que possui 2 contas??
outra coisa como seria esse método estático, pois se colocar no case CADASTRAR e alterar alguma coisa vai modificar todos os atributos da classe e não do objeto especifico ?
Agradeço desde já, você está ajudando muito.
abraço

Discorpio, no caso esses Cliente adicional_1 e Cliente adicional_2 são para as contas que possuem mais de um titular, correto? Método estático vai ser um método que vai servir para toda a classe e não apenas para um objeto instanciado. Como ficaria a estrutura de um método estático para cadastrar, se no minimo eu fosse criar umas 10 contas??
fiz um metodo estatico que funciona para uma conta apenas, como ficaria para no minimo 10 contas?

[code]public static void Cadastrar()
{

System.out.println("CADASTRO DE CONTAS");

Conta conta = new Conta();  
 
 conta.setLimite(2500.00);  
 conta.setSaldo(2467.00);  
 conta.setNumero("5678-9"); 
 conta.getTitular().setNome("Sg5001");  
 conta.getTitular().setCpf("171.171.171-71"); 
 conta.getTitular().setEndereço("5th avenue, 77, Manhattan, New York");  

} [/code]

Boa tarde a todos.

Sim, os atributos “adicional_1” e “adicional_2” são para as contas que contém mais de um titular. Agora se você quiser criar dez contas para um mesmo cliente, isto já é outra coisa, pois terá que cadastrar o mesmo 10 vezes com um número de conta diferente e como titular, para isto terá que invocar o método cadastrar dez vezes, ou você pode criar um método a parte, que com um loop “for” ou “while”, você insira o mesmo cliente, bastando tão somente fornecer ao método um parâmetro do tipo inteiro indicando o número de vezes que você quer criar as contas, e um outro parâmetro do tipo Cliente com as informações do cliente.

Quanto aos métodos estáticos, estes são métodos globais para serem utilizadas em toda a aplicação. Para serem acessados, estes métodos não precisam que a classe onde estão declarados seja instanciada, bastando tão somente fazer referência a eles com o nome da classe seguido de um ponto e logo depois o nome do método. Ex.

  public class MinhaClasse {

     public static void fazAlgo() {
           System.out.println("Estou fazendo algo dentro de um método estático");
     }

  }


   /* Invocando o método estático.
       Assim compila   */
   MinhaClasse.fazAlgo()

   // Assim não compila
   MinhaClasse mc = new MinhaClasse();
   mc.fazAlgo();

Como você pode perceber, métodos estáticos são membros apenas de classes, e não de instância.

Qual é a finalidade dos métodos estáticos :?:

Simples, como disse antes, estes métodos são globais a toda aplicação, não havendo a necessidade de instanciar a classe onde eles estão contido, em outras palavras, você terá acesso ao método em qualquer parte da aplicação dentro de qualquer classe, bastando tão somente fazer referência a eles com o nome da classe onde estão declarados.

Em outras linguagens de programação, tal como o Object Pascal do Delphi, estes métodos globais não precisam ser declarados no escopo de classe, bastando tão somente serem declarados na seção “Interface” de uma unit (Unidade). Já na linguagem Java, que é uma linguagem fortemente Orientada a Objetos, nada pode ser declarado fora do escopo de classe ou interface, portanto qualquer atributo ou método tem que ser declarado dentro do escopo de classes, incluindo-se os métodos globais.

Só toma cuidado ao criar métodos estáticos em demasia, isto porque quando a sua aplicação inicia, ela aloca memória para todos os métodos estáticos declarados em diversas classes de sua aplicação, isto pois é que faz com que as classes não precisem serem instanciadas, e cria um ponteiro de cada método estático fazendo referência ao nome da classe, se sua classe possuir mais de um método estático, ele cria um vetor de ponteiros para o nome daquela classe, por isso antes de criar métodos estáticos na sua aplicação pense 10 vezes antes de criá-lo, pois isto pode comprometer a velocidade de performance de sua aplicação.

Apenas recomendei que você criasse métodos estáticos no seu caso, porque você estaria acessando eles dentro do método “main” que também é estático, quer fazer um teste, cria um método não estático e tente acessar ele dentro do main, e vê se você vai conseguir.

Um abraço.

Entendi tudo em relação a métodos estáticos, quando eu perguntei como ficaria o método para 10 contas estava me referindo a criar 10 contas(ou mais) para 10 clientes(ou mais) diferentes. Ex: vou criar um programa para cadastrar um numero n de contas para n clientes, no qual não existe um limite para a quantidade de contas e clientes criados, neste caso como ficaria o método cadastrar()? Queria que toda a informação cadastrada ficasse guardada…
Agradeço desde já a sua ajuda, você realmente gosta de ajudar as pessoas.
Abraço

Boa tarde.

Olha existe duas maneiras de você fazer isto, uma é declarando um atributo como vetor de objetos Cliente, assim:

   Cliente[] cli = new Cliente[10]; // Tipando o vetor como 10 instâncias de Cliente contando de 0 a 9
   cli[0] = new Cliente();
   .......
   .......
   cli[9] = new Cliente();

Repare que além de ter que tipar o vetor como dez instâncias de Cliente, tenho que instanciar uma por uma.

A outra maneira é mais prática e recomendável é utilizar um “ArrayList” que permite a armazenagem de objetos, adicionando eles dinamicamente sem precisar especificar o índice. então vamos.

public class TesteClasses {

    // ArrayList de Objetos do tipo Cliente
    private static List<Cliente> cli = new ArrayList<Cliente>();

    public static void main(String[] args) {
        
        final int CADASTRAR = 1;
        final int EDITAR = 2;
        final int VISUALIZAR = 3;
        final int SAIR = 4;
        
        int op = 0;
        
        while (op != SAIR){
            System.out.println("Digite uma das opções abaixo");
            System.out.println("----------------------------");
            System.out.println("1 - Cadastrar Clientes");
            System.out.println("2 - Editar Clientes");
            System.out.println("3 - Visualizar Clientes");
            System.out.println("4 - Sair");
            
            Scanner scan = new Scanner(System.in);
            op = scan.nextInt();
            switch (op){
                case CADASTRAR:
                     System.out.println("Digite o número de clientes que deseja cadastrar");
                     cadCliente(scan.nextInt());
                     break;
                case EDITAR:
                     // Crie um método estático editar e invoque ele aqui
                     break;
                case VISUALIZAR:
                     listCliente();
                     break;
                default:
                    if (op == SAIR){
                       System.out.println("Saindo do sistema"); 
                    } else {
                       System.out.println("Digite números de 1 a 4"); 
                    }
                    break;
            }
        }
    }

    public static void cadCliente(int numcli){
        for (int i=0; i < numcli; i++){
            Scanner s = new Scanner(System.in);
            Cliente cliente = new Cliente();
            System.out.println("Digite o nome do "+(i+1)+"º cliente");
            cliente.setNome(s.nextLine());
            System.out.println("Digite o cpf do cliente");
            cliente.setCpf(s.nextLine());
            System.out.println("Digite o endereço do cliente");
            cliente.setEndereço(s.nextLine());
            System.out.println("Digite a idade do cliente");
            cliente.setIdade(s.nextInt());
            cli.add(cliente);
        }    
    }
    
    public static void listCliente(){
        int n = 0;
        Iterator it = cli.iterator();
        while (it.hasNext()){
            n++;
            Cliente clien = (Cliente)it.next();
            System.out.println(n+"º Cliente");
            System.out.println("------------");
            System.out.println("Nome: "+clien.getNome());
            System.out.print("CPF: "+clien.getCpf());
            System.out.println("Endereço: "+clien.getEndereço());
            System.out.println("Idade: "+clien.getIdade());
        }
    }
}

Repare que com o ArrayList você adiciona e remove de uma lista de objetos sem se preocupar com o índice e sem apagar qualquer outro dado que está armazenado lá, ao passo que isto não é possível com um vetor de objetos.

Repare que já até adiantei o método List, agora é sua vez de fazer o método Editar.

Um abraço

Boa noite discopio,obrigado pela ajuda. Consegui fazer o método editar, ficou bem implementado??

[code]public static void editarCliente()
{

	 Scanner sc = new Scanner(System.in); 
     int op_1,op_2=0,op_3 = 0;
     while(op_2!=2)
     
     {
    	 
     
	 System.out.println("Digite uma das opções abaixo");  
     System.out.println("----------------------------");  
     System.out.println("1 - Pesquisar Clientes");  
     System.out.println("2 - voltar");  
     op_2=sc.nextInt();
       
	if(op_2==1)
	{
	
	
	Iterator<Cliente> busca = cli.iterator(); 
	while (busca.hasNext()){       //resolveu o problema de reconhecer o primeiro da lista
	Cliente clienteBusca = (Cliente)busca.next();  
	
	 
	System.out.println("Digite o nome do cliente");
	String nomeBusca;
	nomeBusca=sc.next();
	
	if(clienteBusca.getNome().equals(nomeBusca)) {
		//string dentro do indice
		System.out.println(clienteBusca.getNome()+" Está cadastrado!");
		int indice = cli.indexOf(clienteBusca); 
		System.out.println(indice+" indice"); //verificar pq ta dando -1
		System.out.println(" Desejá alterar dados deste cliente? (1-sim) (2-não)");
		op_1=sc.nextInt();
		
		
		if(op_1==1)
			
		{
			while(op_3!=7){
			
		    System.out.println("Digite uma das opções abaixo");  
            System.out.println("----------------------------");  
            System.out.println("nome atual : "+ clienteBusca.getNome());  
            System.out.println("1 - Editar nome"); 
            
            System.out.println("cpf atual : " + clienteBusca.getCpf()); 
            System.out.println("2 - Editar cpf"); 
            
            System.out.println("endereço atual : "+clienteBusca.getEndereço());  
            System.out.println("3 - Editar endereço");  
          
            System.out.println("idade atual : " +clienteBusca.getIdade() ); 
            System.out.println("4 - Editar idade"); 
            
            System.out.println("numero de conta atual : " +clienteBusca.getConta_1()); 
            System.out.println("5 - Editar numero de conta");  
            
            System.out.println("Limite atual da conta :  " + clienteBusca.getConta_1().getLimite()); 
            System.out.println("6 - Editar limite da conta");
            
            System.out.println("7 - Voltar menu principal");
              
            op_3=sc.nextInt();
            
            switch(op_3)
            {
            case 1 :
            
            	System.out.println("Digite o nome do cliente");
				cli.get(indice).setNome(sc.next());
				break;
           
            case 2:
            	
            	System.out.println("Digite o cpf do cliente");
				cli.get(indice).setCpf(sc.next());
				break;
            case 3:	
				
            	System.out.println("Digite o endereço do cliente");
				cli.get(indice).setEndereço(sc.next());
				break;
				
            case 4:	
				
            	System.out.println("Digite a idade do cliente");
				cli.get(indice).setIdade(sc.nextInt());
				break;	
            case 5:	
				
            	System.out.println("Digite o numero de conta do cliente");
				cli.get(indice).getConta_1().setNumero(sc.next());
				if(cli.get(indice).getContaAdicional_2().getNumero()!=null)
				{
				System.out.println("Digite o numero de conta adicional do cliente");	
				cli.get(indice).getContaAdicional_2().setNumero(sc.next());	
				}
				break;
				
            case 6:
            	
            	System.out.println("Digite o novo limite da conta do cliente");
				cli.get(indice).getConta_1().setLimite(sc.nextInt());
				if(cli.get(indice).getContaAdicional_2().getNumero()!=null)
				{
				System.out.println("Digite o novo limite da conta adicional do cliente");	
				cli.get(indice).getContaAdicional_2().setLimite(sc.nextInt());	
				}
				break;
				
			default :
				
				break;
				
            }
            
			}
			
			
		
		}
		
		
		
	}
	else  {
        System.out.println(nomeBusca+" Não está cadastrado!");  
	}
	
	}
	 
	}

	else{
		
	}
	
     }
	
	
	
}[/code]

Boa noite Sg5001.

Rapaz, na verdade eu estava pensando em te passar uma coisa, e acabei passando outra totalmente diferente.

Como assim, outra ?

Sim, lembra quando fiz você fazer composição de classes :?: Pois é, na verdade não era para fazer pesquisa com a classe Cliente, e sim com a classe Conta, onde utilizando o método getTitular(), você iria automaticamente instanciar a classe Cliente dentro de Conta. Talvez era isso que estava dando erro.

Me perdoe :!:

Eu fiz algumas modificações assim:

package testeclasses;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class TesteClasses {
    
    // ArrayList de Objetos do tipo Conta
    private static List&lt;Conta&gt; conta_corrente = new ArrayList&lt;Conta&gt;();

    public static void main(String[] args) {
        
        final int CADASTRAR = 1;
        final int EDITAR = 2;
        final int VISUALIZAR = 3;
        final int SAIR = 4;
        
        int op = 0;
        
        while (op != SAIR){
            System.out.println(&quot;Digite uma das opções abaixo&quot;);
            System.out.println(&quot;----------------------------&quot;);
            System.out.println(&quot;1 - Cadastrar Contas&quot;);
            System.out.println(&quot;2 - Editar Contas&quot;);
            System.out.println(&quot;3 - Visualizar Contas&quot;);
            System.out.println(&quot;4 - Sair&quot;);
            
            Scanner scan = new Scanner(System.in);
            op = scan.nextInt();
            switch (op){
                case CADASTRAR:
                     System.out.println(&quot;Digite o número de clientes que deseja cadastrar&quot;);
                     cadConta(scan.nextInt());
                     break;
                case EDITAR:
                     editaContas();
                     break;
                case VISUALIZAR:
                     int n = 0;
                     Iterator it = conta_corrente.iterator();
                     while (it.hasNext()){
                         n++;
                         listaContas(n, (Conta)it.next());
                     }
                     break;
                default:
                    if (op == SAIR){
                       System.out.println(&quot;Saindo do sistema&quot;); 
                    } else {
                       System.out.println(&quot;Digite números de 1 a 4&quot;); 
                    }
                    break;
            }
        }
    }
    
    public static void cadConta(int numcli){
        for (int i=0; i &lt; numcli; i++){
            Scanner s = new Scanner(System.in);
            Conta conta = new Conta();
            System.out.println(&quot;Digite o número da &quot;+(i+1)+&quot;º conta&quot;);
            conta.setNumero(s.nextLine());
            System.out.println(&quot;Digite o limite da &quot;+(i+1)+&quot;º conta&quot;);
            conta.setLimite(s.nextDouble());
            System.out.println(&quot;Digite o saldo da &quot;+(i+1)+&quot;º conta&quot;);
            conta.setSaldo(s.nextDouble());
            System.out.println(&quot;Digite o nome do titular da &quot;+(i+1)+&quot;º conta&quot;);
            s = new Scanner(System.in);
            conta.getTitular().setNome(s.nextLine());
            System.out.println(&quot;Digite o cpf&quot;);
            conta.getTitular().setCpf(s.nextLine());
            System.out.println(&quot;Digite o endereço&quot;);
            conta.getTitular().setEndereço(s.nextLine());
            System.out.println(&quot;Digite a idade&quot;);
            conta.getTitular().setIdade(s.nextInt());
            System.out.println(&quot;Tem adicional ?&quot;);
            s = new Scanner(System.in);
            String adic = s.nextLine();
            if (adic.equals(&quot;y&quot;)){
                System.out.println(&quot;Digite o nome do 1º adicional da &quot;+(i+1)+&quot;º conta&quot;);
                conta.getAdicional_1().setNome(s.nextLine());
                System.out.println(&quot;Digite o cpf&quot;);
                conta.getAdicional_1().setCpf(s.nextLine());
                System.out.println(&quot;Digite o endereço&quot;);
                conta.getAdicional_1().setEndereço(s.nextLine());
                System.out.println(&quot;Digite a idade&quot;);
                conta.getAdicional_1().setIdade(s.nextInt());
                System.out.println(&quot;Tem outro adicional ?&quot;);
                adic = s.nextLine();
                if (adic.equals(&quot;y&quot;)){
                    System.out.println(&quot;Digite o nome do 2º adicional da &quot;+(i+1)+&quot;º conta&quot;);
                    conta.getAdicional_2().setNome(s.nextLine());
                    System.out.println(&quot;Digite o cpf&quot;);
                    conta.getAdicional_2().setCpf(s.nextLine());
                    System.out.println(&quot;Digite o endereço&quot;);
                    conta.getAdicional_2().setEndereço(s.nextLine());
                    System.out.println(&quot;Digite a idade&quot;);
                    conta.getAdicional_2().setIdade(s.nextInt());
                }
            }
            // Adicionando a conta a lista de contas
            conta_corrente.add(conta);
        }    
    }
    
    public static void editaContas(){
        String filtro = &quot;&quot;;
        System.out.println(&quot;Digite uma das opções abaixo&quot;);
        System.out.println(&quot;----------------------------&quot;);
        System.out.println(&quot;1 - Editar por número da conta&quot;);
        System.out.println(&quot;2 - Editar por nome do cliente&quot;);
        Scanner s = new Scanner(System.in);
        int opcao = s.nextInt();
        if (opcao == 1){
           System.out.println(&quot;Digite o número da conta&quot;);
           s = new Scanner(System.in);
           filtro = s.nextLine();
        } else {
           System.out.println(&quot;Digite o nome do titular da conta&quot;);
           s = new Scanner(System.in);
           filtro = s.nextLine(); 
        }
        for (int i = 0; i &lt; conta_corrente.size(); i++){
           String numero = conta_corrente.get(i).getNumero();
           String nome = conta_corrente.get(i).getTitular().getNome();
           if (numero.equals(filtro) || nome.equals(filtro)){
               // Para atualizar o registro você precisa ver o que está registrado lá.
               listaContas(i+1, conta_corrente.get(i));
               atualizaConta(conta_corrente.get(i));
               break;
           }
        }
    }
    
    public static void listaContas(int indice, Conta c){
        System.out.println(indice+&quot;º Cliente&quot;);
        System.out.println(&quot;------------&quot;);
        System.out.println(&quot;Conta nº. &quot;+c.getNumero());
        System.out.println(&quot;Limite = &quot;+c.getLimite());
        System.out.println(&quot;Saldo = &quot;+c.getSaldo());
        System.out.println(&quot;Nome do titular: &quot;+c.getTitular().getNome());
        System.out.println(&quot;CPF: &quot;+c.getTitular().getCpf());
        System.out.println(&quot;Endereço: &quot;+c.getTitular().getEndereço());
        System.out.println(&quot;Idade: &quot;+c.getTitular().getIdade());
        if (!c.getAdicional_1().getNome().equals(&quot;&quot;)){
            System.out.println(&quot;Nome do primeiro adicional: &quot;+c.getAdicional_1().getNome());
            System.out.println(&quot;CPF: &quot;+c.getAdicional_1().getCpf());
            System.out.println(&quot;Endereço: &quot;+c.getAdicional_1().getEndereço());
            System.out.println(&quot;Idade: &quot;+c.getAdicional_1().getIdade());
        }
        if (!c.getAdicional_2().getNome().equals(&quot;&quot;)){
            System.out.println(&quot;Nome do segundo adicional: &quot;+c.getAdicional_2().getNome());
            System.out.print(&quot;CPF: &quot;+c.getAdicional_2().getCpf());
            System.out.println(&quot;Endereço: &quot;+c.getAdicional_2().getEndereço());
            System.out.println(&quot;Idade: &quot;+c.getAdicional_2().getIdade());
        }
    }
    
    public static void atualizaConta(Conta c){
        /* Agora aqui você implementa do
            seu jeito, sempre utilizando conta_corrente,
            ou seja, você faz tudo de uma vez só, utilizando
            apenas uma Classe (Conta), onde você utiliza 
            também o recurso da composição de classes,
            basta olhar os exemplos da listagem de contas e
            inserção de contas.
       */
    }
}

Um abraço.

Consegui terminar o programa, valeu mesmo pela ajuda. só outra coisa, esses metodos estaticos ficam dentro da classe onde está o main ou dentro da classe conta?

e se o cliente tiver 4…5 contas…

fiz um código diferente, segue:

[code]public class Cliente {

private String nome;     
private String endereço;     
private String cpf;     
private int idade;   

public String getNome() {
return nome;
}

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

public String getEndereço() {
return endereço;
}

public void setEndereço(String endereço) {
this.endereço = endereço;
}

public String getCpf() {
return cpf;
}

public void setCpf(String cpf) {
this.cpf = cpf;
}

public int getIdade() {
return idade;
}

public void setIdade(int idade) {
this.idade = idade;
}
} [/code]

[code]public class Conta {

private double saldo;     
private double limite;   
private String numero;   
private Cliente cliente;  

public double getSaldo() {   
    return saldo;   
}   

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

public double getLimite() {   
    return limite;   
}   

public void setLimite(double limite) {   
    this.limite = limite;   
}   

public String getNumero() {   
    return numero;   
}   

public void setNumero(String numero) {   
    this.numero = numero;   
}   

public void setCliente(Cliente cliente) {   
    this.cliente = cliente;   
}

public Cliente getCliente() {   
    return cliente;   
}

}
[/code]

[code]import java.util.ArrayList;
import java.util.Scanner;

public class Banco {

Scanner s = new Scanner(System.in);
ArrayList<Cliente> clientes = new ArrayList<Cliente>();
ArrayList<Conta> contas = new ArrayList<Conta>();

public void menuPrincipal(){
	
	int op = 0;
	do{
		System.out.println("Digite uma das opções abaixo");   
	    System.out.println("1 - Contas");   
	    System.out.println("2 - Clientes");
	    System.out.println("3 - Sair");
		op = s.nextInt();
		switch (op){   
        case 1:   menuContas(); break;   
        case 2:   menuClientes(); break;   
        case 3:   break;  
		};
	}while(op!=3);
	
}   

private void menuClientes() {
	int op = 0;
	do{
		System.out.println("Menu de Clientes");
		System.out.println("1 - Cadastrar Clientes");   
	    System.out.println("2 - Mostrar Clientes");
	    System.out.println("3 - voltar");
	    op = s.nextInt();
		switch (op){   
        case 1:   cadastrarCliente(); break;   
        case 2:   mostrarClientes(); break;   
        case 3:   break;  
		};
	}while(op!=3);
	
}

private void menuContas() {
	int op = 0;
	do{
		System.out.println("Menu de Contas");
		System.out.println("1 - Cadastrar Conta");   
	    System.out.println("2 - Mostrar Contas");
	    System.out.println("3 - voltar");
	    op = s.nextInt();
		switch (op){   
        case 1:   cadastrarConta(); break;   
        case 2:   mostrarContas(); break;   
        case 3:   break;  
		};
	}while(op!=3);
	
}  

private void cadastrarCliente() {
	String c;
	Cliente cliente = new Cliente();
	System.out.println("Digite as Informações do Cliente:");
	System.out.println("nome do cliente:");
	cliente.setNome(s.next());
	//terminar os atributos
	clientes.add(cliente);
	System.out.println("Cliente Cadastrado!:");
	System.out.println("Deseja Cadastrar uma Conta para este Cliente? S - Sim, N - Nao");
	c = s.next();
	if(c.equalsIgnoreCase("s")){
		cadastrarConta(cliente);
	}
			
}

private void mostrarClientes() {
	for(Cliente cliente: clientes){
		System.out.println("Nome do Cliente:" +cliente.getNome());
		System.out.println("Contas do Cliente:");
		ArrayList<Conta> contasCliente = getContasbyCliente(cliente);
		for(Conta conta: contasCliente){
			System.out.println("Limite:" +conta.getLimite());	
		}	
	}
}


private void cadastrarConta() {
	String op;

	System.out.println("Ja existe Cliente Cadastrado? S- SIM, N - Não");
	op = s.next();
	if(op.equalsIgnoreCase("s")){
		System.out.println("Digite o primeiro nome do cliente para localizar-mos");
		Cliente cliente = getClienteByName(s.next());
		if(cliente.getNome() == ""){
			System.out.println("Cliente não localizado");
		}
		else 
		{ 
			cadastrarConta(cliente);
		}
	}
	else if(op.equalsIgnoreCase("n")){
		cadastrarCliente();	
	}
	else{
		System.out.println("opção incorreta - retornando...");
	}
	
	
}
private void cadastrarConta(Cliente cliente)
{
	Conta conta = new Conta();
	conta.setCliente(cliente);
	System.out.println("Digite as Informações da conta do cliente:" + cliente.getNome());
	System.out.println("Limite:");
	conta.setLimite(s.nextDouble());
	//terminar os atributos
	contas.add(conta);
	System.out.println("Conta Cadastrada!!");
}

private void mostrarContas() {
	// TODO Auto-generated method stub
	for (Conta conta : contas) {
		System.out.println("Nome do Cliente:" +conta.getCliente().getNome());
		System.out.println("Limite:" +conta.getLimite());		
	}
}

private ArrayList<Conta> getContasbyCliente(Cliente cliente) {
	// TODO Auto-generated method stub
	ArrayList<Conta> contasCliente = new ArrayList<Conta>();
	for (Conta conta : contas) {
		if(conta.getCliente() == cliente){
		contasCliente.add(conta);	
		}
	}
	return contasCliente;
}

private Cliente getClienteByName(String nome) {
	for (Cliente cliente : clientes) {
		if(cliente.getNome().toLowerCase().contains(nome.toLowerCase())){
		    return cliente;	
		}
	}
	return new Cliente();
}

}[/code]

[code]public class Main {

public static void main(String[] args) {

	Banco banco = new Banco();
	
	banco.menuPrincipal();

}

}[/code]

Bom dia a todos.

Métodos estáticos podem ser declarados em qualquer classe, porém no seu caso, por você estar invocando-os dentro do método main que está na classe main, é recomendável que eles esteja então na classe main, veja bem, eu disse recomendável, não necessariamente que isto seja obrigatório, pois você pode declarará-los em outra classe e invocá-los com a referência do nome da classe seguida de um ponto e em seguida o nome do método com a sua respectiva assinatura.

Contudo, se você estiver instanciando as outras classes, lembra do que falei sobre regras de criação de métodos estáticos, pois é, já que você está instanciando esses classes, então o porque de não declará-los como dinâmicos (não estáticos), e acessá-lo como membro de instância ? Fica bem melhor porque assim você só alocará o método, bem como toda a classe instanciada em memória, no momento em que estiver usando toda a classe, podendo descartá-los da memória tão logo acabe de usá-los, e é para isto que o conceito de Orientação a Objetos foi criado.

Um abraço.