Exacto. Algo así haré. Muchas gracias. 

Hola.


 

Gracias igualmente por la ayuda, el problema es que necesito que devuelva un tipo genérico. En ocasiones necesitaré que sea un tipo que no tiene nada que ver con las clases Integer, Double, etc.

Creo que simplemente renunciaré a las versiones estáticas y lo haré todo a partir de métodos no estáticos, que con eso me funciona bien.

Gracias. Un saludo.

Hola.

Para demostrar que un grafo no es plano, es decir, que no se puede evitar que dos aristas se corten, se suele utilizar el https://es.wikipedia.org/wiki/Teorema_de_Kuratowski.

En tu caso se puede evitar, aunque dependiendo de lo que haya a la derecha del nodo del que sale la flecha roja es posible que el resultado sea menos claro. Debes pasar la flecha que sale del nodo rosa y va al granate por debajo del nodo del que sale la flecha roja y de lo que salga a su derecha.

Un saludo.

Hola.

Quisiera saber si es posible obligar a una clase a tener un método estático que encaje en un cierto patrón. Me explico. Por ejemplo, imaginemos que tenemos una clase "Entero" que pretende implementar las operaciones con números enteros y que tiene un método estático llamado "suma", que básicamente devuelve la suma de dos números enteros pasados por parámetro y cuya declaración es del tipo:

public static Entero suma (Entero entero1, Entero entero2){/*...*/}
 

También podríamos tener una clase "Real" que pretenda implementar las operaciones que se pueden hacer con números reales y que podría tener declarado un método "suma" tipo:

public static Real suma (Real real1, Real real2){/*...*/}
 

Pues bien, me gustaría poder trabajar con una clase que trabaje con elementos de una clase genérica que obligatoriamente tenga declarado un método de este tipo sin importar que sean enteros, reales o lo que sea... Por ejemplo, imaginemos que queremos declarar una clase "Vector", que contendrá elementos de una clase genérica (que pueden ser enteros o reales) y queremos definir la suma de vectores a partir de la suma de sus elementos. Algo así:

public class Vector <Elemento /*Aqui es donde me gustaria indicar que Elemento debe implementar una interfaz, o extender una clase o algo asi*/>
{
    ...
 
    public static Vector <Elemento> suma (Vector <Elemento> vector1, Vector<Elemento> vector2){
        Vector <Elemento> nuevo=new Vector<Elemento> (vector1. getTamanyo());
        for (int i=0; i<nuevo.getTamanyo(); i++){
             nuevo.setElemento(i, Elemento.suma(vector1.getElemento(i),vector2.getElemento(i));
    }
 
}
 

Mi intento ha sido el de declarar una interfaz "Grupo" de la siguiente manera:

public interface Grupo<TipoGrupo extends Grupo> 
{
    public static TipoGrupo suma (TipoGrupo e1, TipoGrupo e2);
}
 

Y luego la clase "Entero" declararla así:

public class Entero implements Grupo <Entero> {
 
    ...
 
    public static Entero suma(Entero entero1, Entero entero2){...}
 
 

Pero no funciona... En la interfaz Grupo, en la línea del método "suma", me sale un error que dice que "un tipo de variable no estático como "TipoGrupo" no se puede referenciar desde un entorno estático" lo cual tiene su lógica, y otro error que dice que "falta el cuerpo del método o declararlo abstracto". Si lo declaro abstracto el primer error se mantiene y aparece otro que dice que es ilegal combinar los modificadores static y abstract.

¿Realmente se puede obligar a que una clase tenga un método estático que encaje en una cierta declaración?

Gracias de antemano por la ayuda. Un saludo.

Hola.

Antes de nada muchas gracias por responder, rub'n.


Mmmm... No sé si te he entendido bien. Resulta que el problema desapareció precisamente cuando metí la línea setLayout(null) al principio del constructor de la clase que extiende el JFrame, ¿dices que mejor haber hecho algo con un GroupLayout?

Un saludo y gracias.

Hola.

Hace unos días solucioné el problema. Se trataba de incluir la línea setLayout(null); en el constructor del JFrame.

No entiendo muy bien por qué esa línea soluciona el problema. ¿A alguien se le ocurre por qué?

Me llama la atención especialmente que el error sólo ocurría en máquinas con Windows, lo he comprobado en dos diferentes. Sin embargo en máquinas con Mac el problema, según parece, no tenía lugar. Pero, ¿no se suponía que con el JPanel y el JFrame no dependían del sistema y que eso era una ventaja sobre el Canvas y el Frame?

Si alguien sabe algo sobre lo que pasa aquí me encantaría que me iluminase un poco. Supongo que ya se ve que estoy un poco verde en el tema y quizás no sea fácil explicármelo, pero estaría muy interesado en aprender algo al respecto.

Gracias de antemano. Un saludo.

Hola.

He tenido una pequeña sorpresa programando interfaces gráficas con Java. He simplificado el código manteniendo el problema para que se haga más sencilla su comprensión. Tenemos una clase Prueba2 que extiende un JFrame:

package prueba2;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
import javax.swing.JFrame;
public class Prueba2 extends JFrame   {
    private PanelPrueba Juego;
    public Prueba2() throws IOException{
        Juego=new PanelPrueba();
        getContentPane().add(Juego);
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                System.exit(0);
            }
        });
       Juego.setVisible(true);
}
    public static void main(String[] args) throws IOException {
        Prueba2 J=new Prueba2();
        J.setBounds(0, 0, 400, 400);
        J.setVisible(true);
    }
}
 

Y otra clase PanelPrueba, que extiende un JPanel e implementa un KeyListener:

package prueba2;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import static javax.swing.JOptionPane.PLAIN_MESSAGE;
import static javax.swing.JOptionPane.YES_NO_OPTION;
import static javax.swing.JOptionPane.YES_OPTION;
import static javax.swing.JOptionPane.showConfirmDialog;
import javax.swing.JPanel;
 
public class PanelPrueba extends JPanel implements KeyListener {
    public PanelPrueba(){
        setBounds(0,0,200,500);
        addKeyListener(this);
        setFocusable(true);
        requestFocus();
}
    public void paint(Graphics g){
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, 200, 500);
    }
    public void reiniciar() {
        repaint();
    }
    @Override
    public void keyTyped(KeyEvent que) {}
 
    @Override
    public void keyPressed(KeyEvent que)  {
        if(showConfirmDialog(this,"Has ganado,deseas empezar otra partida?","Fin de Partida",YES_NO_OPTION,PLAIN_MESSAGE)==YES_OPTION){
            reiniciar();
        }  
        else{
           System.exit(0);
        }
    }
 
    @Override
    public void keyReleased(KeyEvent que) {}
}

Básicamente lo que pasa cuando aprietas una tecla es que te sale un cuadro de diálogo con dos botones. Si se pulsa "No" la aplicación finaliza y si se pulsa "Sí" vuelve a la situación inicial. La sorpresa está en que si se pulsa "Sí" aparece un molesto texto detrás del JPanel. ¿Alguien sabría explicarme por qué pasa eso, y cómo se puede solucionar el problema?

He estado probando cosas, y si el cuadro de diálogo haces que aparezca con un showMessageDialog en lugar de con un showConfirmDialog el problema desaparece.

Por otro lado, si hago que la clase PanelPrueba extienda un Canvas en lugar de un JPanel el problema desaparece. No obstante, quisiera solucionar el problema con un JPanel, ya que éste es el "peso pesado" de los contenedores, y aporta muchas ventajas, ¿verdad? 

También me gustaría comentar que me han pasado cosas parecidas cuando he añadido objetos de clases JPanel y JButton a un mismo JFrame, y que estos problemas han desaparecido igualmente utilizando Canvas.

Agradezco de antemano cualquier tipo de ayuda o comentario y el tiempo que os haya tomado atenderme.

Un saludo a todos.

Hola rub'n.

Antes de nada muchas gracias por tu respuesta, me ha sido muy útil. He hecho los cambios que me has indicado y ya funciona todo perfectamente. No obstante, me gustaría hacer un par de preguntas y observaciones si no te importa.


¿Te importaría indicarme, aunque sea por encima, qué ventajas tiene la clase JPanel sobre la Canvas? Según tengo entendido la clase JPanel es más nueva y todo eso. Además, es cierto que con la Canvas sigue sin funcionar el asunto. Lo que sucede es que la clase JPanel creo que no la controlo demasiado. Tampoco sé lo que es un dog 

En otro ejercicio que me planteé parecido a este, si utilizaba la clase JPanel me empezaban a salir componentes como botones y cuadros de texto sobre el panel si hacía algo con ellos, cuando en un principio debían estar fuera. ¿Qué te parece?¿Sabrías decirme por qué me podía estar pasando eso? Con la Canvas no me pasaba y por eso renegué de la clase JPanel. Leeré algo más sobre la JPanel a ver si me familiarizo un poco más con ella.


Sí, tienes toda la razón, se me olvidó lo del addKeyListener cuando escribí el mensaje, aunque sí que lo tenía en mi código, dentro del constructor de la clase Panel.

Supongo que la clave para solucionar el problema está en lo del requestFocus(). No conocía ese método. Si lo quito los métodos de la KeyListener no se activan, por muchos 'clicks' que haga. Sin embargo, si utilizo una Canvas, es indiferente ponerlo o no ponerlo. Para que se ejecuten los métodos del KeyListener hay que hacer 'click'. ¿Sabes por qué? ¿O sabes dónde puedo encontrar información sobre todo esto? Me temo que el material que tengo es bastante corto para responderme a todas las preguntas que me surgen cuando pongo las cosas en práctica.

Por otro lado, dentro del detener:
.

¿Qué hace ese removeKeyListener? ¿Es necesario? No lo había visto nunca, en mi corta experiencia en estos asuntos.

Y para finalizar, añadir que me has dado una buena idea con la modificación del windowClosing para que el programa confirme que realmente se quiere salir. Empiezo ahora también con los cuadros de diálogo. A ver si poco a poco me voy aclarando.

Y eso, que muchísimas gracias por todo, en serio. Un saludo.

Hola.

Soy algo novato en todo esto de las interfaces gráficas y animaciones y tengo algunas dudas con un código en Java que estoy confeccionando. Necesito crear una animación controlada por cuatro teclas del teclado que empiece o se detenga cuando se aprieta un botón con el ratón.

Para eso defino utilizo una clase a la que he llamado Panel:

public class Panel extends Canvas implements Runnable, KeyListener{
 
    //Atributos:
    private int ancho, alto; //el alto y el ancho del panel
    private boolean play=false;//Variable que nos indica si la animación ha comenzado o no.
    //... Más atributos. En general, objetos que deben ser pintados. Y variables que indican lo que 
    //tienen que hacer esos objetos durante la animación 
 
    //Constructor:
    public Panel(int anch, int alt)
    {
         ancho=anch;
         alto=alt;
         play=false;
         //Se construyen los demás atributos
    }
 
    public void paint (Graphics G)
    {
         //Aquí se pintan algunos de los atributos del objeto utilizando técnicas de doble bouffering
    }
 
    public void update (Graphics G)
    {
        paint (G);
    }
 
    public void actualizar()
    {
        //Nada.. Aquí se actualiza la posición de los objetos (atributos de Panel) que deben ser 
        //pintados durante la animación
    }
 
    public void run() 
    {
        while (play)
        {
            actualizar();
            repaint();
            try
            {
                Thread.sleep((int)espera);
            }
            catch (InterruptedException E)
            {}
            //Y más cosas que no creo que vengan a cuento.
        }
    }
    public void Iniciar()
    {
        play=true;
        Thread hilo=new Thread(this);
        hilo.start();
    }
    public void Detener()
    {
        play=false;
    }
    //Metodos de KeyListener
    public void keyTyped(KeyEvent e) {
    }
    public void keyPressed(KeyEvent e) 
    {
        if (e.getKeyChar()=='a')
        {
            //Se modifican los atributos necesarios para que la animación haga lo que tiene que 
            //hacer cuando se pulsa una 'a'
        }
        if (e.getKeyChar()=='s')
        {
            //Lo mismo para la 's'
        }
        if (e.getKeyChar()=='l')
        {
            //...
        }
        if (e.getKeyChar()=='ñ')
        {
            //...
        }
    }
 
    @Override
    public void keyReleased(KeyEvent e) 
    {
        if (e.getKeyChar()=='a')
        {
            //Se modifican los atributos necesarios para que la animación haga lo que tiene que 
            //hacer cuando se suelta la 'a'
        }
        if (e.getKeyChar()=='s')
        {
           //...
        }
        if (e.getKeyChar()=='l')
        {
           //...
        }
        if (e.getKeyChar()=='ñ')
        {
            //...
        }
    }
 
}
 

Y otra clase, la clase Juego2:

public class Juego2 extends JFrame implements ActionListener
{
    private Panel P;
    private JButton boton;
    private boolean play=false;
    private int anchoP=900, altoP=700;
 
    //El constructor. No creo que tenga mucho interés para lo de mi duda pero lo pongo por si 
    //acaso:
    public Juego2()
    {
        P=new Panel (anchoP,altoP);
        boton=new JButton("play");
        setBackground(new Color(240,240,240));
        setLayout(null);        
        boton.addActionListener(this);
 
        getContentPane().add(boton);
        boton.setBounds(20,330,250,30);
 
        getContentPane().add(P);
        P.setBounds(300, 30, anchoP, altoP);
        P.setVisible(true);
 
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                System.exit(0);
            }
        });
    }
 
    //el main
    public static void main(String[] args) {
        final Juego2 F = new Juego2(); 
        F.setBounds(0, 0, 1300, 800);
        F.setVisible(true);
    }
 
    //El actionPerformed de la clase ActionListener
    public void actionPerformed(ActionEvent e) {
        if (e.getSource()==boton)
        {
            if (play)
            {
                play=false;
                boton.setText("play");
                P.Detener();
            }
            else
            {
                play=true;
                boton.setText("pause");
                P.Iniciar();
            }
        }
    }
}
 

A continuación explicaré el fenómeno que me crea dudas.Cuando el código está listo hago lo siguiente:

1) Ejecuto el código. La cosa va bien, todo se construye y se visualiza correctamente.
2) Le doy al play. Y la animación comienza correctamente.
3) Le doy a una de las teclas controladoras y no ocurre nada. ¡Nada de nada!
4) Hago un 'click' de ratón sobre el panel y desde entonces ya sí funciona todo bien. El 'click' tiene que ser sobre el panel, si lo hago sobre otro punto de la ventana o fuera de ella las teclas controladoras siguen inactivas.

¿Alguien sabe por qué pasa esto y cómo puedo solucionarlo? Es decir, me gustaría que las teclas controladoras funcionasen desde que le doy al play, que no fuese necesario hacer ese 'click'.

Muchas gracias de antemano por vuestro tiempo. Un saludo.

Hola NEBIRE.

Vale sí, claro, claro, lo entiendo, lo entiendo. Muy interesante esto de empezar pensando si el acceso es síncrono o aleatorio para usar una lista enlazada o un array, sobre todo si la dimensión de la estructura puede hacerse muy grande. Aquí, en principio no quería utilizar el programilla este para simular una situación con un gran número de bolas, así que creo que lo voy a dejar así, de momento, pero gracias por el consejo. Lo tendré en cuenta para futuras batallas. 

Un saludo.