Muchas gracias por responder.

La verdad es que estoy tratando de hacer el juego de la "Snake" (lo he visto como reto en la sección C++, en donde usan las bibliotecas SDL y Allegro, pero quiero intentarlo con Java en modo GUI usando los JFrame, de paso que aprendo sobre este lenguaje, que lo llevaré como curso el ciclo entrante).

Como aún no he avanzado mucho quiero probar antes cómo serían las funciones para agregar un JLabel y que se muestre (esto sería cuando se ha "comido" un objeto determinado y la Snake debe crecer).

Este es el código que he escrito referente a ello:

    private void formWindowOpened(java.awt.event.WindowEvent evt) {                                  
        ArrayList<javax.swing.JLabel> Bloques = new ArrayList<>();
        Bloques.add( new javax.swing.JLabel("/SnakePackage/imgs/body.gif") );
        MyMain.add(Bloques.get(0));
        Bloques.get(0).setLocation(0, 0);
    }     

No estoy totalmente seguro, pero me parece que esta función se activa una sola vez cuando se inicia el programa.
Estoy creando un ArrayList para almacenar allí los JLabel que se vayan creando. Estos JLabel en realidad no contienen texto y son una imagen muy pequeña (10x10px me parece).

Hasta antes conseguía que un JLabel con la misma imagen se moviera (derecha, izquierda, arriba, abajo) según se presionen las teclas correspondientes y allí cambiaba la posición con setLocation(x, y).

El error me dice que un método non-static no puede ser referenciado de un contexto static. ¿Cómo es eso?

Bueno, MyMain es el nombre que le puse al JFrame cuando lo agregué al paquete, pero al parecer no es un JPanel (¿es necesario que cree uno?):

public class MyMain extends javax.swing.JFrame

¿Cómo puedo agregar un JLabel en tiempo de ejecución?

Es decir, en el momento de que "suceda algo" quiero que aparezca una imagen en una posición determinada.
Quisiera que el JLabel se cree en ese instante y se muestre en una posición que yo elija basándome en datos que se han obtenido en tiempo de ejecución.
No quisiera respuestas como "créalo oculto y luego muéstralo" porque de seguro es posible crearlo al instante, sólo que no tengo idea de cómo 

Gracias de antemano ...

Puedes leerlo en lenguaje humano como: "mientras sea diferente de... y diferente de... y diferente de..."
Es decir, si es diferente de cualquiera de esas palabras van a continuar las iteraciones.

Si usas el operador lógico OR jamás acabaría porque... ser diferente de X o de Y siempre se cumplirá.
Sea cual fuere la entrada, dicha condición siempre será verdadera... porque para ser falsa tendría que ingresarse algo que sea igual a X y Y simultáneamente y eso es imposible porque X y Y son distintos y una expresión (o una variable) no puede tener 2 valores a la vez.

Muchas gracias por responder.
Pero la verdad es que no entiendo mucho a qué se refiere con "dirección en memoria del objeto". Es decir, he revisado los temas de clases y objetos, pero cuando se refiere a un array como objeto, ¿qué debería imaginarme exactamente? ¿Una instancia de una clase que contiene un array?

Agradecería mucho que nos explique un poco más acerca de:

char (*)[12]

O tal vez pueda decirme con qué nombre más o menos buscar este tema.

En este código:

#include <iostream>
using namespace std;
 
int main()
{
    char v[]="Probando";
    cout<<v<<endl;
    cout<<&v[0]<<endl;
    cout<<(char*)v<<endl;
    cout<<&v<<endl;
    return 0;
}

Los primeros tres argumentos que se le envían a cout son exactamente lo mismo, ¿verdad?
Es decir, se le envía la dirección en memoria de v[0] y muestra la cadena.
Lo último muestra una dirección de memoria, ¿es la de v[0]?
Antes preguntaba si era la única forma de mostrar por pantalla dicha dirección de memoria.

Me estaba refiriendo a lo que decía el autor del tema.

Entonces he escrito lo siguiente:

#include <iostream>
using namespace std;
 
void something(char *text)
{
    cout << *text;
}
 
int main()
{
    char v[]="Probando";
    cout<<&v<<endl;
    cout<<v<<endl;
    something(v);
    return 0;
}

Y pues, yo creí que pasar como argumento v es lo mismo que pasar &v (pero no es exactamente lo mismo).
Lo primero muestra la dirección de memoria del primer elemento.
Lo segundo imprime toda la cadena como dices.
Pero yo me refería a lo tercero, que sólo muestra el primer caracter (es por el operador de indirección).

Si escribo lo siguiente, sigue mostrando solo la letra 'P':

    char* p = v;
    cout<<*p;
 

Eso quiere decir que cuando a cout le paso v o &v[0] es lo mismo... o incluso si le paso p, pero escribir *p ya le quita la gracia porque muestra el valor del elemento correspondiente a la dirección de memoria (es decir, sólo v[0]).

Entonces podemos decir que v es como un puntero constante a char.
Cuando cout recibe un puntero a char (sea constante o no), muestra el valor apuntado por ese puntero y los valores ubicados en las direcciones de memoria que le siguen, hasta encontrar la marca de fin de cadena.
Pero al escribir &v es como querer obtener la dirección de memoria de algo que ya propiamente es una dirección de memoria y se muestra entonces la dirección de memoria de v[0]. ¿Sería la única forma de mostrar la dirección de memoria de v usando cout?
Si muestro por pantalla &p (donde p es una variable puntero que almacena la dirección de memoria de v[0]) debería pasar lo mismo (pues estoy tratando de obtener la dirección de memoria de una dirección de memoria). Pero al probar esto, la dirección que se muestra es la dirección de la variable puntero, y no se está desreferenciando una dirección de memoria, que es lo que aproximadamente sucede al hacer &v (creo que me estoy haciendo mucho lío en vano ).

No se me permite hacer algo como:

    p = &v;

Pero sí esto:

    p = &v[0];
    cout<<*p;
 

Y el resultado nuevamente es 'P'.

En realidad cout es un objeto de la clase ostream (o eso es lo que me dice esta referencia).


Y respecto a:
Es porque las transformaciones se hacen previamente y el resultado de dicha expresión es lo que se envía como argumento a cout (ya resuelto), pero eso no implica que yo deba ignorar dichas transformaciones.
Es decir, en este caso se referencia y desreferencia una cantidad igual de veces y luego de hacer todo ello recién muestra lo correspondiente. No es que deba ignorar las transformaciones y fijarme sólo en el tipo de dato que le envío... es decir, si escribiera un & o un * menos, el resultado no sería el mismo (aún cuando las conversiones se estén haciendo sobre un tipo de dato char*).

#include <stdio.h>
 
int funcion2()
{
    return 5;
}
 
int funcion1()
{
   return funcion2(); 
}
 
int main(void)
{
    printf("%d \n",funcion1() );
 
   getchar();
   return 0;
}
 

- Al inicio se encuentra la declaración y definición de ambas funciones (ello no implica que se ejecuten antes de main(), sólo si son llamadas por esta función principal).
- Desde main() muestras el valor devuelto por funcion1().
- funcion1() devuelve el valor devuelto por funcion2().
- funcion2() devuelve 5.
- Se muestra 5 por pantalla.

Extra.
Por lo general se recomienda escribir antes de main() los prototipos de las funciones. Algo como:

int funcion1();
int funcion2();

Y luego, usualmente después de main(), definir el cuerpo de las funciones, para que no haya conflictos en programas donde usas muchas.

Por ejemplo, en tu programa, si el orden hubiese sido el siguiente:

#include <stdio.h>
 
int funcion1()
{
   return funcion2(); 
}
 
int funcion2()
{
    return 5;
}
 
int main(void)
{
    printf("%d \n",funcion1() );
 
   getchar();
   return 0;
}

... hubiese errores, ya que al momento en que se define el cuerpo de funcion1() aún no existe funcion2(). Entonces cuando muchas funciones se llamen entre sí, para no estar pendientes del orden, es mejor escribir sus declaraciones (prototipos  ).

Cuando se invoca la función y se le pasa como argumento el nombre de un vector de caracteres, realmente se le está pasando la dirección de memoria del primer elemento y por ello sólo muestra el primero, ¿verdad?

Esto es un puntero a otro puntero a char.
Cuando se invoque la función y se le pase como argumento la dirección del primer elemento de un vector de caracteres, dicha dirección de memoria es almacenada en text (variable puntero a puntero). Si escribo *text es como mostrar el valor apuntado por text, que viene a ser un puntero a char. ¿Entonces no debería mostrar la dirección de memoria del vector?

Tal vez puedan explicarme un poco que no lo veo tan simple :S

Tal vez no sea muy adecuado preguntar por acá, pero es una pregunta corta:
¿Cómo puedo encontrar más acerca de estos temas?
Es decir, ¿con qué nombre lo busco?

Con ello podría determinar las acciones de usar '+=' en clases que yo mismo vaya creando, ¿verdad?

En este otro enlace hay un tutorial para C++ y funciones recursivas...
https://www.youtube.com/watch?v=Dt3GUEd3wVs

Coincido completamente con el comentario de OmarHack acerca de "no ver resultados a corto plazo".
A mí me gusta aprender cada vez más acerca de la programación. También estoy llevando un estudio de C++ y ya voy entrando a los temas de nivel intermedio. Muchas veces puedo estar concentrado por varias horas, practicando mucho... pero comienzo a estresarme cuando surgen algunos problemas que no puedo resolver, por donde sea que los mire.
En ese instante pierdo temporalmente mi gusto por continuar programando y me dedico a otras actividades.
Luego, cuando nuevamente tengo ganas de programar, por ver las grandes cosas que podría hacer, continuo y llego a resolver los problemas que había dejado pendientes (es decir, mientras pueda hacer pausas, muy largas a veces, porque llevo otros cursos, creo que podré mantener esa afición por programar).
Lo que me impulsa a seguir en esto es pensar en los grandes proyectos logrados por grandes programadores. Aunque me falte muchísimo... el saber que estoy perdiendo el tiempo reflexionando hace que automáticamente me centre en continuar estudiando