Methode übergeben

[Kerberus]

Ist es möglich eine Methode zu übergeben?
Habe eine Klasse geschrieben, die einen ActionListener beinhaltet. Nun sollt ich nach dem erstellen eines Objektes dieser Klasse festlegen können, was gemacht werden soll, wenn der Button xy gedrückt wird.
Habe mir vorgestellt, dass ich eine Methode implementiere mit welcher man eine Methode übergeben kann. Allerdings weiss ich nicht, ob dies möglich ist und wenn ja, wie.

 

[Isaac]

Ich versteh kein Wort 8)

Wenn du eine Klasse hast die einen ActionListener enthällt und du dann per new ein Objekt dieser klasse erzeugt weiss das Objekt doch wie es reagieren soll. Dafür ist der Listener ja im Objekt.

 

[Kerberus]

Ich versuch es noch einmal: 😀

Also ich habe zwei Klassen geschrieben und die im Package vu.ch.sirmackerberus.Card abgelegt. Card enthält die Klassen
1) CardManager
2) Card

Der CardManager verwaltet die einzelnen Karten. Auf dem Bild siehst du die erste Karte eines Dialoges.

Wenn ich nun auf NEXT drücke, dann wird beim CardManager die nächste Card angefordert und geladen.

Beispielscode:

import vu.ch.sirmackerberus.Card.*;

...

CardManager manager = new CardManager();

Card eins = new Card("EINS", manager); //neue Karte erstellen
manager.add(eins); //Karte beim Manager anmelden

.... //weitere Karten erstellen und adden

//Die Karten können mit beliebigem Inhalt gefüllt werden.

manager.load();

Von nun an verwaltet der CardManager und ich muss mich um nichts mehr kümmern.

So. Nun drücke ich solange auf NEXT bis ich bei der letzten Karte angekommen bin. Dann ermöglicht mir der CardManager auch die Option OK. Nun möchte ich, dass eine Methode aufgerufen wird, wenn auf OK gedrückt wird, allerdings sollte diese vom Programmierer selbst festgelegt werden können.
Die Methoden NEXT, PREVIOUS kann ich ja vordefinieren, weil sie immer gleich bleiben. OK allerdings ist von Anwendung zu Anwendug verschieden.

Das ganze sollte in etwa so funktionieren:

public void test()
{
 System.out.println("test");
}

....


manager.setOKMethod(test());

//wenn nun auf OK gedrückt wird, sollte test() aufgerufen werden.

Ist nun alles klar? ;-)

 

[Beni]

Da machst du am einfachsten ein kleines Interface:

public interface OkListener{
  /**
    * Wird aufgerufen, sollte jemand auf den "OK"-Button drücken.
    * @return true, wenn der Dialog geschlossen werden soll, false wenn der Dialog offen bleiben soll.
    */
  public boolean okPressed();
}

Dann kannst du den CardManager etwa so implementieren:

public class CardManager extends [...]{
  private OkListener listener;

  public CardManager(){
    [...]
    JButton okButton = ...
    okButton.addActionListener( new ActionListener(){
      public void actionPerformed( ActionEvent e ){
        if( listener != null ){
          boolean ok = listener.okPressed();
          if( ok ){
             // [ ... Dialog schliessen ... ]
          }
        }
      }
    });
  }

  public void setOkListener( OkListener listener ){
    this.listener = listener;
  }
}

Und dann kann man das Interface überall implementieren, wo man es halt gerade so braucht.

public class Test implements OkListener{
  public void doSomething(){
    CardManager card = new ...
    card.setOkListener( this );
    [ ... und so weiter ... ]
  }
 
  public boolean okPressed(){
    return [... Eingabe ist gut... ]
  }
}

 

[Isaac]

Das hört sich nach Komponenten Entwicklung an.

Mach die Klasse CardManager abstract. Der Anwender - der Programmierer - muss dann von Cardmanager ableiten und die Methode manager.setOK() selber implementieren.

 

[Kerberus]

Danke für eure Hilfe. Funktioniert nun alles, so wie es sollte 🙂

 

[Kerberus]

Hm. Irgend etwas geht immer nocht nicht. Schaut euch mal die Methode showCard() an.

Wie kann ich das JPanel CardWindow löschen, d.h. die Card welche vorher drin war, überschreiben?

package vu.ch.sirmackerberus.card;

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

import vu.ch.sirmackerberus.card.*;

/**
 * Ermoeglicht das Verwalten verschiedenenr Cards.
 * 
 * @author Sir MacKerberus
 * @version 11.07.2004
 */

public abstract class CardManager extends JFrame implements ActionListener
{
    public Vector interneVerwaltung = new Vector(); //interne Verwaltung der Cards
    
    private JButton previous; //Die drei Buttons zur Steuerung des Stapels
    private JButton next;
    private JButton ok;
    
    private JPanel CardWindow; //JPanel, das mit der jeweiligen Card gefüllt wird
    
    private JPanel control; //Repräsentiert die drei Buttons zur Steuerung des Stapels
    
    private int index = 0; //Beschreibt die Position der aktuellen Card im Stapel
    
    private int card_size_x; //Enthält die Breite einer Karte
    private int card_size_y; //Enthält die Höhe einer Karkte
    
    /**
     * Constructor for objects of class CardManager
     */
    
    public CardManager(String title, int card_size_x, int card_size_y)
    {
        super(title);
        this.getContentPane().setLayout(null);
        this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        this.setSize(card_size_x + 20, card_size_y + 100);
        
        CardWindow = new JPanel();
        CardWindow.setSize(card_size_x, card_size_y);
        CardWindow.setLayout(null);
        
        control = new JPanel();
        control.setBorder(new TitledBorder("Control"));
        control.setLayout(null);
        
        previous = new JButton("Previous");
        previous.addActionListener(this);
        previous.setBounds(20, 20, 100, 20);
        control.add(previous);
        
        next = new JButton("Next");
        next.addActionListener(this);
        next.setBounds((card_size_x / 2) - 50, 20, 100, 20);
        control.add(next);
        
        ok = new JButton("Ok");
        ok.addActionListener(this);
        ok.setBounds(card_size_x - 120, 20, 100, 20);
        control.add(ok);
        
        CardWindow.setBounds(10, 10, card_size_x, card_size_y);
        this.getContentPane().add(CardWindow);
        
        control.setBounds(10, card_size_y + 20, card_size_x, 50);
        this.getContentPane().add(control);
        
        this.card_size_x = card_size_x;
        this.card_size_y = card_size_y;
        
        this.setVisible(true);
    }

    public void actionPerformed(ActionEvent e)
    {
        Object source = e.getSource();
        
        if(source == previous)
        {
            previousCard();
        }
        
        if(source == next)
        {
            nextCard();
        }
        
        if(source == ok)
        {
            CardManagerEvent();
        }       
    }
    
    public void addCard(Card param_card)
    {
        interneVerwaltung.add(param_card);
    }
    
    private void showCard(int pointer)
    {
        Card card_pointer = (Card) interneVerwaltung.get(pointer);
        
        previous.setEnabled(true);
        next.setEnabled(true);
        ok.setEnabled(true);
        
        if(card_pointer == (Card) interneVerwaltung.firstElement())
        {
            previous.setEnabled(false);
        }
        
        if(card_pointer == (Card)interneVerwaltung.lastElement())
        {
            next.setEnabled(false);
        }
        
        if(card_pointer != (Card) interneVerwaltung.lastElement())
        {
            ok.setEnabled(false);
        }
        
        card_pointer.setBounds(0, 0, card_size_x, card_size_y);
        CardWindow.add(card_pointer);
        
        this.CardWindow.repaint();
    }
    
    public void load()
    {
        showCard(index);
    }
    
    private void previousCard()
    {
        index = index - 1;
        this.load();
    }
    
    private void nextCard()
    {
        index = index + 1;
        this.load();
    }
  
    public abstract void CardManagerEvent();
}

 

[Beni]

Einfach alles entfernen, was auf dem Panel ist:

CardWindow.removeAll();
CardWindow.add(card_pointer);

P.S. schreib doch Variablennamen klein, dann wird es leserlicher 8)

 

[Kerberus]

Werd ich mir merken. Aber spielt ja keine Rolle. Der Programmierer hat ja nichts mit den Variablennamen zu tun. Er muss ja nur von CardManager ableiten und Cards hinzufügen.

Nun funktioniert die von mir entwickelte Komponente perfekt.