[RESOLVIDO] Problema com passagem de array como parâmetro

Estando ordenado ou embaralhado, um Baralho é um Baralho. Não vejo o porquê de criar duas classes distintas.

Eu pensei em não perder o baralho original…

Bom, como eu já te disse, seus arrays estão declarados errados.

Também concordo que não é necessária outra classe. Se quer embaralhar, apenas crie um método para isso.

Terceiro que seu construtor recebe um array de Cartas e vc está tentando passar um objeto Baralho.

Entendi, estou alterando aqui para tentar resolver na própria classe Baralho.

Por curiosidade, como seria a passagem correta?

Aí depende. Como tá sua classe baralho? Tem um array de Carta lá?
Se tiver vc pode fazer um método getCartas(), que retorne esse array de Carta.

Ou vc pode mudar no construtor, ao invés de receber Carta[] baralhoX, recebe Baralho baralhoX.

Tudo depende do que vc quer fazer e de como está implementado o resto.

Ta assim:

public class Carta {

    private Nipe nipe;
    private Valor valor;

    public Carta(Valor valor, Nipe nipe) {

        this.valor = valor;
        this.nipe = nipe;
    }

    public Nipe getNipe() {
        return nipe;
    }

    public Valor getValor() {
        return valor;
    }

    @Override
    public String toString() {
        String carta = "";
        carta = this.getValor() + " de " + this.getNipe();
        return carta;
    }
}

public class Baralho {

    public static final int QTD_CARTAS = Nipe.getQTD_NIPES() * Valor.getQTD_VALORES();
    private Carta baralho[];
    private Carta baralhoEmbaralhado[];

    public Baralho() {

        baralho = new Carta[QTD_CARTAS];

        int cont = 0;

        for (Nipe nipe : Nipe.values()) {

            for (Valor valor : Valor.values()) {

                Carta carta = new Carta(valor, nipe);

                baralho[cont] = carta;

                cont++;
            }

        }
    } // ---> FIM CONSTRUTOR
    
    public void exibirBaralho(){
        for (Carta carta : baralho){
            System.out.println(carta);
        }
    } // ---> FIM exibirBaralho
    
       public void embaralhar() {

        baralhoEmbaralhado = new Carta[QTD_CARTAS];

        Random aleatorio = new Random();

        int cont = 0;

        while (cont < QTD_CARTAS) {

            int iAleatorio = aleatorio.nextInt(QTD_CARTAS);

            this.baralhoEmbaralhado[iAleatorio] = this.baralho[cont];

            cont++;
        }
                
    } // ---> FIM CONSTRUTOR
} // ---> FIM CLASS

Agora to tentando embaralhar...

Beleza, não acho que precisaria de dois baralhos, mas blz.

O problema agora é o seguinte. Você pega um número “randômico”, mas ninguém disse que esse número não pode repetir certo?
Então antes de atribuir o this.baralhoEmbaralhado[iAleatorio] = this.baralho[cont];, vc precisa verificar se o iAleatorio já não foi sorteado.

Pois é, eu tinha feito outro método para fazer isso, mas agora estou tentando só embaralhar primeiro. Pois não esta funcionando ainda…

Não está funcionando pelo que te falei. O randon.nextInt() pode retronar o mesmo valor.

Pense em um exemplo simples:

vetor[1, 2, 3, 4, 5];
vetorEmbaralhado[];

1ª iteração: iAleatorio = 0;
vetorEmbaralhado[0] = vetor[0];

2ª iteração: iAleatorio = 4;
vetorEmbaralhado[4] = vetor[1];

3ª iteração: iAleatorio = 3;
vetorEmbaralhado[3] = vetor[2];

4ª iteração: iAleatorio = 0;
vetorEmbaralhado[0] = vetor[3]; // 0 já havia sido sorteado, sobreescreve o valor

5ª iteração: iAleatorio = 4;
vetorEmbaralhado[4] = vetor[4];  // 4 já havia sido sorteado, sobreescreve o valor

Fim do seu while e vc não conseguiu sortear os números 1 e 2. Entendeu?
Seu vetorEmbaralhado possui [4, null, null, 3, 5]

felipeaps, muito obrigado pela paciência e pelas respostas.

public class BeanBaralho {
    public static void main(String[] args){
     Baralho baralho = new Baralho();
     baralho.exibirBaralho();
        
     baralho.embaralhar();
     
     System.out.println("################");
     
     Baralho baralhoEmbaralhado = new Baralho();
        
     baralhoEmbaralhado.exibirBaralhoEmbaralhado();
     
    }
}

Criei outro método para exibir por não ter conseguido passar o baralho ordenado para o método exibirBaralho.

Cara, acho que vc está precisando de uns conceitinhos básicos.

Quando vc executa Baralho baralhoEmbaralhado = new Baralho();, vc está criando uma nova instância da classe baralho.
Portanto, não adianta vc fazer baralho.embaralhar(); e depois dar um “new”.

Faz assim:

public class BeanBaralho {  
    public static void main(String[] args){  
     Baralho baralho = new Baralho();  
     baralho.exibirBaralho();  
          
     baralho.embaralhar();  
       
     System.out.println("################");    
          
     baralho.exibirBaralhoEmbaralhado();        
    }  
}

Mas de novo, seu método de embaralhar não vai funcionar se vc não arrumou aquilo que falei.

Outra coisa. Pensando em orientação a objetos. Sua classe baralho representa 1 e apenas 1 único baralho.
Portanto não faz sentido vc ter 2 objetos dentro dela. O certo seria vc ter apenas 1 objeto Carta[].
Quando for embaralhar, vc embaralha ele mesmo, não sei pra que vc quer manter o original.
Desse modo, vc nao precisa do método exibirBaralhoEmbaralhado().

Eu tenho certeza…

Vou seguir essa linha de só um baralho e esquecer esse lance de querer manter o ordenado…

Vou tentar fazer primeiro então a verificação do número aleatório repetido.

Mais uma vez, muito obrigado pelas ideias…

Disponha =)