Autor Tema: Programa de Java: ArrayIndexOutOfBoundsException Error  (Leído 454 veces)

jmoney

  • Sin experiencia
  • *
  • APR2.COM
  • Mensajes: 5
    • Ver Perfil
Programa de Java: ArrayIndexOutOfBoundsException Error
« en: 08 de Junio 2021, 04:53 »
Hola a tod@s!

Estoy batallando con un programa que estoy trabajando - el programa debe de cumplir con lo siguente, entre varias cosas.

Citar
1. Escribe una clase llamada Deck, que representará el deck o conjunto de cartas de poker.
2. Escribe una clase llamada Card, que representará una carta de poker.
3. Deck deberá tener dos atributos de algún tipo definido en el Collection Framework.
4. Card deberá tener tres atributos.

    a. Palo: tréboles, corazones, picas o diamantes.
    b. Color: rojo, negro.
    c. Valor: 2 al 10, A, J, Q o K.

5. En Deck se inicializarán las 52 cartas de poker y las almacenará en uno de los atributos del tipo de estructura de datos seleccionada del Collection Framework.

En donde estoy batallando, es al inicializarán las 52 Cartas del Deck, si intendo inicializar con 52, Java me da el Error "ArrayIndexOutOfBoundsException".

-Tal cual y como esta el programa, inicializa con 104 Cartas.

Card
Código: [Seleccionar]
import java.util.ArrayList;

public class Card {

            ArrayList<String> deck = new ArrayList<String>();

            String[] palo = {"trébol", "corazones", "picas", "diamantes"};
            String[] color = {"rojo", "negro"};
            String[] valor = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "A", "J", "Q", "K" };


}


Deck
Código: [Seleccionar]
    public static void main(String[] args)
    {
        Card card = new Card();

        System.out.println("Deck de Cartas para Iniciar:");
        ArrayList<String> deck = new ArrayList<String>();
        for (int i = 0; i < 52; i++) {
            for (int j = 0; j < card.palo.length; j++) {
                deck.add(card.palo[j]+ " " + card.color[0] + " " + card.valor[i]);
                deck.add(card.palo[j]+ " " + card.color[1] + " " + card.valor[i]);
            }
        }

Gracias de antemano!
« Última modificación: 08 de Junio 2021, 04:58 por jmoney »

Kabuto

  • Moderador Global
  • Experto
  • *******
  • Mensajes: 725
    • Ver Perfil
Re: Programa de Java: ArrayIndexOutOfBoundsException Error
« Respuesta #1 en: 08 de Junio 2021, 12:22 »
Tu clase Card, no está modelando una Carta.
Has creado una clase que contiene los valores posibles con los que se puede modelar una Carta, pero no representa una Carta.

Una Card/Carta tiene tres atributos: palo, color y valor.
Y cuando se vaya a crear un objeto Card, dichos atributos han de adquirir uno de esos posibles valores.
Esos posibles valores se los haremos llegar desde otra clase, pero la clase Card debería ser como esta:

Código: [Seleccionar]
public class Card {

private String palo;
private String color;
private String valor;

public Card(String palo, String color, String valor) {
this.palo = palo;
this.color = color;
this.valor = valor;
}

public String getPalo() {
return palo;
}

public void setPalo(String palo) {
this.palo = palo;
}

public String getColor() {
return color;
}

public void setColor(String color) {
this.color = color;
}

public String getValor() {
return valor;
}

public void setValor(String valor) {
this.valor = valor;
}

}

Luego, tu clase Deck, no representa un mazo de Cards.
En Deck has puesto el método main() (que no debería ir aquí)  y un ArrayList de String llamado deck.
Si ahí metes cadenas String, entonces no estás metiendo objetos Card. Y el objetivo del programa es ese, modelar un Deck de Cards

Por tanto la clase Deck, sí debe usar un ArrayList, pero que contenga objetos Card, no String.

En esta clase Deck, es donde podemos incluir los valores posibles de los atributos para construir las Card, es decir, los arrays que tú habías puesto en la clase Card

En el constructor de Deck, se inicializará el ArrayList de Card y comenzará el proceso de construcción de cartas.

En tu proceso de construcción cometes un pequeño fallo. Construyes cartas de ambos colores por igual.
Es decir, en tu mazo de cartas pueden haber Corazones negros y rojos, Tréboles negros y rojos, etc.... por eso consigues hasta 104 cartas.

Pero eso no es correcto. Cada palo es de un único color: Tréboles/Picas son de color negro y Corazones/Diamantes son de color rojo, formando un total de 52 cartas.

Si queremos respetar esto, hace que automatizar la creación de las cartas sea un poquito más complicado, pero no mucho más.
Lo más rápido, para no buscar fórmulas ingeniosas y complejas, sería crear primero las de un color y luego las del otro.
En el array de los cuatro PALOS disponibles, nos será más cómodo si los ordenamos por colores, por ejemplo primero los PALOS correspondientes al color ROJO (corazones/diamantes) y luego los del color NEGRO.

Esta podría ser la clase Deck:

Código: [Seleccionar]
import java.util.ArrayList;

public class Deck {

//Posibles valores de los atributos para construir objetos Card
private final String[] PALO = {"corazones", "diamantes", "trébol", "picas"};
private final String[] COLOR = {"rojo", "negro"};
private final String[] VALOR = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "A", "J", "Q", "K"};

//Mazo de cartas
private ArrayList<Card> deck;

public Deck() {
deck = new ArrayList<Card>();

//Construimos cartas de color ROJO
for (int palo = 0; palo < 2; palo++) //Se usa PALO[0] y PALO[1]
for (int valor = 0; valor < VALOR.length; valor++)
deck.add(new Card(PALO[palo], COLOR[0], VALOR[valor]));

//Construimos cartas de color NEGRO
for (int palo = 2; palo < 4; palo++) //Se usa PALO[2] y PALO[3]
for (int valor = 0; valor < VALOR.length; valor++)
deck.add(new Card(PALO[palo], COLOR[1], VALOR[valor]));
}

/**
* Retorna cuantas cartas tiene este mazo.
* El tamaño correcto tras la creación debería ser 52 cartas.
* @return Tamaño actual del mazo.
*/
public int getSize() {
return deck.size();
}

}

Incluyo también un método para saber cuántas cartas tiene el mazo.

Ahora, en una tercera clase, pondremos un main() para poner a prueba la construcción del mazo de cartas.
Código: [Seleccionar]
public class Test {

public static void main(String[] args) {

Deck mazo = new Deck();

//Confirmamos en pantalla cuantas Cards se han construido
System.out.println("Mazo construido. Cantidad de cartas: " + mazo.getSize());

}

}

Y al ejecutarlo veremos que tenemos la cantidad correcta de cartas:
Citar
Mazo construido. Cantidad de cartas: 52

Y listo. Con esto ya tenemos lo que pide el enunciado.
Una clase que modele una Card, con sus tres atributos.
Y otra clase que modele un Deck, que es un conjunto de Card´


Si algo no te ha quedado claro, no dudes en preguntar.
Un saludo.
NO respondo dudas por mensaje privado
Publicando vuestras dudas en el foro público conseguimos:
- Que más gente aporte respuestas mejores o complementarias.
- Que otras personas puedan aprender de vuestras dudas.

Mejor en PÚBLICO que en privado. Gracias

jmoney

  • Sin experiencia
  • *
  • APR2.COM
  • Mensajes: 5
    • Ver Perfil
Re: Programa de Java: ArrayIndexOutOfBoundsException Error
« Respuesta #2 en: 09 de Junio 2021, 02:50 »
Muchas gracias Kabuto!

Sé que estoy haciendo algo mal - pero no he podido salirme de este problema.

Antes de implementar los cambios que sugeriste, el código corría completo (pero con 104 cartas). Después de realizar los cambios, los cuales estoy 100% que los hice mal, ahora me surgen otros errores.



Card
Código: [Seleccionar]
import java.util.ArrayList;

public class Card {

    private String palo;
    private String color;
    private String valor;

    public Card(String palo, String color, String valor) {
        this.palo = palo;
        this.color = color;
        this.valor = valor;
    }

    public Card() {
    }

    public String getPalo() {
        return palo;
    }

    public void setPalo(String palo) {
        this.palo = palo;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getValor() {
        return valor;
    }

    public void setValor(String valor) {
        this.valor = valor;
    }

}


Deck
Código: [Seleccionar]
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Deck {

    public static void main(String[] args)
    {
        Card card = new Card();
         final String[] PALO = {"corazones", "diamantes", "trébol", "picas"};
         final String[] COLOR = {"rojo", "negro"};
         final String[] VALOR = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "A", "J", "Q", "K"};

        System.out.println("Deck de Cartas para Iniciar:");
        ArrayList<Card> deck = new ArrayList<Card>();
        for (int palo = 0; palo < 2; palo++) //Se usa PALO[0] y PALO[1]
            for (int valor = 0; valor < VALOR.length; valor++)
                deck.add(new Card(PALO[palo], COLOR[0], VALOR[valor]));
        for (int palo = 2; palo < 4; palo++) //Se usa PALO[2] y PALO[3]
            for (int valor = 0; valor < VALOR.length; valor++)
                deck.add(new Card(PALO[palo], COLOR[1], VALOR[valor]));

        for (Card elemento : deck) {
            System.out.print(elemento + " / ");
        }
        System.out.println("\n");
        suflle(deck);
        System.out.println("\n");
        head(deck);
        System.out.println("\n");
        pick(deck);
        System.out.println("\n");
        hand(deck);
    }

    public static void suflle(ArrayList deck){
        Collections.shuffle(deck);
        System.out.println("Se mezcló el Deck.");
        for (String elemento : (Iterable<String>) deck) {
            System.out.print(elemento + " / ");
        }
    }

    public static void head(ArrayList deck){
        System.out.println(deck.get(0));
        deck.remove(0);
        System.out.println("Quedan " + deck.size() + " cartas");
    }

    public static void pick(ArrayList  deck){
        Random random = new Random();
        System.out.println(deck.get(random.nextInt(deck.size())));
        deck.remove(random.nextInt(deck.size()));
        System.out.println("Quedan " + deck.size() + " cartas");
    }

    public static void hand(ArrayList deck){
        for(int i=0; i<=4; i++){
            System.out.println(deck.get(i));
        }
        for(int i=0; i<=4; i++){
            deck.remove(i);
        }
        System.out.println("Quedan " + deck.size()+ " cartas");
    }
}

Sé que me falta mucha práctica, pero donde comúnmente batallo es en organizar bien las clases y no juntar todo dentro de main(). :(


Kabuto

  • Moderador Global
  • Experto
  • *******
  • Mensajes: 725
    • Ver Perfil
Re: Programa de Java: ArrayIndexOutOfBoundsException Error
« Respuesta #3 en: 09 de Junio 2021, 12:48 »
Hola.

Puedes poner el main() en la clase Deck, sin embargo, no es lo ideal.
Cuando escribimos clases que modelan entidades del "mundo real": un carta, un mazo de cartas, un coche, una lavadora... suele ser preferible hacer que NO sean autoejecutables, es decir, que no tengan método main()

Imagina ahora que te piden hacer un programa donde tienes que usar 4 objetos Deck (4 mazos de cartas) para intercambiar cartas entre ellos, o simular una partida Poker o lo que sea..
Entonces te encontrarías con que cada uno de esos 4 objetos Deck tienen su propio método main().
Y en realidad no molestarían, porque en este supuesto estarías ejecutando el main() que simula la partida de Poker.
Pero en esos objetos Deck, tendrías código innecesario, métodos main() que no aportan nada.
Pero hay un problema mayor: muchas de las funciones que has puesto pick, suffle, head, hand.... son métodos estáticos pensados para ser ejecutados desde ese main()

En el supuesto programa que simularía la partida de Poker, los 4 Deck (mazos) que intervienen en la partida, no tendrían disponibles esas funciones de pick, hand, etc.... ¡¡a pesar de estar escritas en su clase Deck!!

Por eso yo hice una clase Card, una clase Deck y para ejecutar el programa, una clase a parte con el main().

Luego, otras cosas a mencionar sobre tu código.

Comienzas el programa creando una carta:

Citar
public class Deck {

    public static void main(String[] args)
    {
        Card card = new Card();

No se por qué lo haces, quizás piensas que es necesario para luego poder usar la clase Card... no se.

Pero no, no es necesario para nada. Ahí lo que estás haciendo es crear una carta.

Una carta sin atributos definidos (ni palo, ni valor, ni color), que estaría fuera del mazo, y que no interviene para nada en el resto del programa.

Así que esa línea la puedes borrar, porque no aporta absolutamente nada.


Más cosas, tras crear las cartas, intentas mostrarlas en pantalla.
Código: [Seleccionar]
for (Card elemento : deck) {
System.out.print(elemento + " / ");
}

Pero lo que haces es pasarle al System.out.print() directamente un objeto Card.

El System.out ni tiene ni pajolera idea de qué es un Card, no sabe como debe mostrar "eso" en pantalla, así que lo único que acierta a hacer, es mostrar en pantalla el identificador interno de esos objetos Card:
Citar
cardPoker2.Card@2f92e0f4 / cardPoker2.Card@28a418fc / cardPoker2.Card@5305068a / cardPoker2.Card@1f32e575

Y claro, no es eso lo que queremos.

El System.out básicamente solo sabe manejarse con objetos String, porque son cadenas de texto y eso es fácil de mostrar en pantalla.

Entonces, si queremos mostrar los datos de una Card en pantalla, tenemos dos opciones:
- Recurrir a los métodos getter
Código: [Seleccionar]
for (Card elemento : deck) {
System.out.println("Palo: " + elemento.getPalo());
System.out.println("Color: " + elemento.getColor());
System.out.println("Valor: " + elemento.getValor());
System.out.println("\n***************");
}
Y ahora en pantalla sí tenemos la información deseada:
Citar
Deck de Cartas para Iniciar:
Palo: corazones
Color: rojo
Valor: 2

***************
Palo: corazones
Color: rojo
Valor: 3

***************
Palo: corazones
Color: rojo
Valor: 4

***************
Palo: corazones
Color: rojo
Valor: 5

***************

Hay una segunda opción, que es más adecuada. Y es "enseñarle" a la clase Card cómo construir un String con sus datos, para que System.out y métodos similares, puedan utilizar ese String.

Para ello, añadimos este método a la clase Card:
Código: [Seleccionar]
    @Override
    public String toString() {
    return "Palo: " + palo + "\nColor: " + color +
    "\nValor: " + valor;
    }
En realidad, lo que hacemos es "sobreescribir" el método toString() que TODAS las clase Java heredan automáticamente de la clase Object (Object es una superclase, nivel Dios..., de las que todas las clases Java son hijas)
Por eso añadimos la etiqueta @Override, para indicar al compilador que no estamos creado un nuevo método, si no que estamos sobreescribiendo uno que ya existe por herencia de una superclase.

No importa si ahora mismo no entiendes bien esto de la herencia entre clases, la cuestión es que ahora la clase Card ya sabe como ha de construir un String que la represente.
Y el método System.out cuando recibe un objeto que NO es un String, lo que hace es consultar si dicho objeto dispone de un método toString().
Y como ahora Card ya lo tiene, ya si podemos mostrar cartas en pantalla sin tener que recurrir a los getters:

Código: [Seleccionar]
for (Card elemento : deck) {
System.out.println(elemento); //Aquí interviene el método toString()
System.out.println("\n***************");
}


Bien, más cosas.
En los métodos pick, hand, etc... pones que van a recibir un ArrayList pero sin especificar que clase van a contener esos ArrayList:
Citar
   public static void head(ArrayList deck){
      System.out.println(deck.get(0));
      deck.remove(0);
      System.out.println("Quedan " + deck.size() + " cartas");
   }
Esto, hoy día Java lo permite (en versiones más antiguas no lo permitía) pero no está bien visto.
Lo correcto es indicar la clase que va a contener esta colección. Además a la hora de leer el código otro programador que no seas tú, le será más informativo poder ver indicado que se trata de ArrayList que contienen Card.

Es más, esto nos puede ahorrar, posibles errores posteriores, como veremos después.
Así que a TODOS los métodos, hay que especificar la clase del ArrayList:
Citar
   public static void head(ArrayList<Card> deck){
      System.out.println(deck.get(0));
      deck.remove(0);
      System.out.println("Quedan " + deck.size() + " cartas");
   }


Y esto enlaza con el principal problema, al error que lanza tu programa.

En el método suflle, haces un Iterable de tipo String, para recorrer el ArrayList:

Citar
   public static void suflle(ArrayList deck){
      Collections.shuffle(deck);
      System.out.println("Se mezcló el Deck.");
      for (String elemento : (Iterable<String>) deck) {
         System.out.print(elemento + " / ");
      }
   }

Pero claro, el ArrayList no contiene objetos String, lo que contiene son Card.
Entonces al ejecutar el programa, Java se encuentra con que le pides que trate a un Card, como si fuera un String. Y entonces te avisa de que no sabe como hacer eso, mediante este error:
Citar
Exception in thread "main" java.lang.ClassCastException: class cardPoker2.Card cannot be cast to class java.lang.String

Este es un error de "ejecución", es decir, que ocurre mientras se ejecuta el programa.

Si hubieras especificado en el método suflle que el ArrayList es de Card, entonces habrías tenido un error de "compilación", que siempre es preferible a uno de "ejecución".

Es decir, como no especificabas qué clase contiene el ArrayList, el compilador dio por bueno que luego hicieras un Iterable de String.
Pero claro, eso no es correcto y se produce un error de "ejecución".

Si hubieras especificado la clase del ArrayList:
Citar
   public static void suflle(ArrayList<Card> deck){
      Collections.shuffle(deck);
      System.out.println("Se mezcló el Deck.");
      for (String elemento : (Iterable<String>) deck) {
         System.out.print(elemento + " / ");
      }
   }

entonces el compilador JAMÁS te habría permitido hacer un Iterable de String, y te habrías dado cuenta del problema antes de poder ejecutar el programa.
Si quieres usar un Iterable, ha de ser de clase Card, como el ArrayList.
Y como además ahora Card tiene un método toString(), ya si se mostrará en pantalla correctamente:

Citar
   public static void suflle(ArrayList<Card> deck){
      Collections.shuffle(deck);
      System.out.println("Se mezcló el Deck.");
      for (Card elemento : (Iterable<Card>) deck) {
         System.out.print(elemento + " / "); //Método toString() hace que se vea en pantalla
      }
   }

Sin embargo, no se necesita ningún Iterable (para los ArrayList nunca son necesarios), ya hemos visto al principio que basta con un for.
Código: [Seleccionar]
public static void suflle(ArrayList<Card> deck){
Collections.shuffle(deck);
System.out.println("Se mezcló el Deck.");
for (Card elemento : deck) {
System.out.print(elemento + " / ");
}
}

Y bueno, eso es todo.

Solo recalcar que lo ideal sería que la clase Deck, no tuviera main().
Ha de ser un programa que modele un mazo, pero no un programa que se ejecute.

Un saludo.
« Última modificación: 09 de Junio 2021, 12:51 por Kabuto »
NO respondo dudas por mensaje privado
Publicando vuestras dudas en el foro público conseguimos:
- Que más gente aporte respuestas mejores o complementarias.
- Que otras personas puedan aprender de vuestras dudas.

Mejor en PÚBLICO que en privado. Gracias

jmoney

  • Sin experiencia
  • *
  • APR2.COM
  • Mensajes: 5
    • Ver Perfil
Re: Programa de Java: ArrayIndexOutOfBoundsException Error
« Respuesta #4 en: 15 de Junio 2021, 02:38 »
¡Muchas gracias por toda tu ayuda Kabuto!!!!! <3

¡Ya terminé el programa! Te lo comparto para completar el thread. (si tienes algún otro feedback, por favor - adelante!)

Main
Código: [Seleccionar]
public class Main {

    public static void main(String[] args) {

        Deck mazo = new Deck();

        System.out.println("Deck de Cartas para Iniciar: " + mazo.getSize());

        for (Card elemento : mazo.getDeck()) {
            System.out.print(elemento + " / ");
        }
        System.out.println("\n");
        mazo.suflle();
        System.out.println("\n");
        mazo.head();
        System.out.println("\n");
        mazo.pick();
        System.out.println("\n");
        mazo.hand();

    }

}

Card
Código: [Seleccionar]
public class Card {

    private final String palo;
    private final String color;
    private final String valor;

    public Card(String palo, String color, String valor) {
        this.palo = palo;
        this.color = color;
        this.valor = valor;
    }

    @Override
    public String toString() {
        return "Palo: " + palo + " | " + "Color: " + color +
                " | " + "Valor: " + valor;
    }
}

Deck
Código: [Seleccionar]
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Deck {

    private final String[] paloDeck = {"corazones", "diamantes", "trébol", "picas"};
    private final String[] colorDeck = {"rojo", "negro"};
    private final String[] valorDeck = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "A", "J", "Q", "K"};

    private ArrayList<Card> deck;

    public Deck() {
        deck = new ArrayList<Card>();

        for (int palo = 0; palo < 2; palo++)
            for (int valor = 0; valor < valorDeck.length; valor++)
                deck.add(new Card(paloDeck[palo], colorDeck[0], valorDeck[valor]));

        for (int palo = 2; palo < 4; palo++)
            for (int valor = 0; valor < valorDeck.length; valor++)
                deck.add(new Card(paloDeck[palo], colorDeck[1], valorDeck[valor]));
    }

    public int getSize() {
        return deck.size();
    }

    public ArrayList<Card> getDeck() {
        return deck;
    }

    public void suflle() {
        Collections.shuffle(deck);
        System.out.println("Se mezcló el Deck.");
        for (Object elemento : deck) {
            System.out.print(elemento + " / ");
        }
    }

    public void head(){
        System.out.println(deck.get(0));
        deck.remove(0);
        System.out.println("Quedan " + deck.size() + " cartas");
    }


    public void pick() {
        Random random = new Random();
        System.out.println(deck.get(random.nextInt(deck.size())));
        deck.remove(random.nextInt(deck.size()));
        System.out.println("Quedan " + deck.size() + " cartas");
    }

    public void hand() {
        for(int i=0; i<=4; i++){
            System.out.println(deck.get(i));
        }
        for(int i=0; i<=4; i++){
            deck.remove(i);
        }
        System.out.println("Quedan " + deck.size()+ " cartas");
    }
}

Ya pude limpiar mucho la clase main()... honestamente se ve más bonita así... sin tanto código dentro de ella.

¡Gracias otra vez Kabuto!

Kabuto

  • Moderador Global
  • Experto
  • *******
  • Mensajes: 725
    • Ver Perfil
Re: Programa de Java: ArrayIndexOutOfBoundsException Error
« Respuesta #5 en: 15 de Junio 2021, 11:26 »
Muy bien.

Efectivamente, el main lo ideal es que tenga el menor código posible. Es decir, la mayor parte de la lógica y funcionalidades debería estar en las otras clases.
El main solo debería invocarlas para ponerlas en marcha.

Esto implica que ahora tus clases Deck y Card son "autónomas". No están ligadas ni sometidas a ningún "main" en concreto y por tanto podrían ser usadas desde cualquier otro programa Java que las incluyese en sus librerías.

Solo comentar una cosita, de escasa importancia.
En la clase Deck, tras barajar las cartas las muestras con un foreach referenciando las cartas como Object.
Citar
    public void suflle() {
        Collections.shuffle(deck);
        System.out.println("Se mezcló el Deck.");
        for (Object elemento : deck) {
            System.out.print(elemento + " / ");
        }
    }

Esto funciona bien y no pasa nada.
Pero quizás sería más lógica referenciarlas directamente como Card

Citar
    public void suflle() {
        Collections.shuffle(deck);
        System.out.println("Se mezcló el Deck.");
        for (Card elemento : deck) {
            System.out.print(elemento + " / ");
        }
    }


Un saludo.
NO respondo dudas por mensaje privado
Publicando vuestras dudas en el foro público conseguimos:
- Que más gente aporte respuestas mejores o complementarias.
- Que otras personas puedan aprender de vuestras dudas.

Mejor en PÚBLICO que en privado. Gracias

 

Sobre la educación, sólo puedo decir que es el tema más importante en el que nosotros, como pueblo, debemos involucrarnos.

Abraham Lincoln (1808-1865) Presidente estadounidense.

aprenderaprogramar.com: Desde 2006 comprometidos con la didáctica y divulgación de la programación

Preguntas y respuestas

¿Cómo establecer o cambiar la imagen asociada (avatar) de usuario?
  1. Inicia sesión con tu nombre de usuario y contraseña.
  2. Pulsa en perfil --> perfil del foro
  3. Elige la imagen personalizada que quieras usar. Puedes escogerla de una galería de imágenes o subirla desde tu ordenador.
  4. En la parte final de la página pulsa el botón "cambiar perfil".