methoden Überladen

elise

jo..

thanks, damit kann ich leben

blauton.com

gomberl schrieb:

bevor ich jetzt zu dem problem deinerseits komme fällt mir gleich eines ins auge
buttons.add ( new JList() );
[/java]

Klar, war ein copy-paste Fehler.

Es funktioniert aber leider immer noch nicht. Mit super.add() kann man das Problem des rekursiven aufrufs lösen. Dafür schon mal Danke!

Allerding besteht immer noch der Fehler: reference to add is ambiguous.

gomberl schrieb:

aber jetzt zu deinem fehler:

//damit ermoeglichst du die ueberladung in einer klasse
//jetzt kann zur laufzeit die richtige methode benutzt werden
//diese methode leitet nun nur den aufruf direkt an die super klass weiter
public void add(JComponent choice){
        super.add(choice);
}

dann gibts kein problem mehr damit

Leider doch. da ich die Funktion add(Object ob) per interface implementieren muss und nicht add(JComponent comp).

gomberl

bitte poste doch deinen code - ich muss mir das nochmal ansehen
bei mir funkts ohne probleme

interfaces sind sogenannte contracts - das heisst jetzt nichts anderes als das sich deine klasse verpflichtet diese methoden bereitzustellen
also darf das keinen einfluss haben (IMO)

wenn du mir den code herstellst debug ich ihn nochmal durch

gomberl

blauton.com

@all: Da ich auch die Schnittstelle implemtiere stelle ich jetzt hier doch noch mal die Frage in die Runde ob mein Design so überhaupt gut ist.

Situation ist die folgende:

Wir haben hier eine Anuzahl von Klassen, ich nenne diese mal XYZPanel, die von javax.swing.JPanel erben. Alle diese Klassen sollen eine bestimmte add() Methode implementieren welche folgenden Zweck hat: Bei dem adden von einem JButton z.b zu so einer xyzPanel Klasse soll dieser Button nicht nur dem Panel hinzugefügt werden, so wie es die java.awt.Container.add() Methode tut, sondern es sollen weitere Aktionen ausgeführt werden.

So z.b:

add(Object component){
  if(component instanceof JButton){
    //Tue etwas spezielles
    super.add(component);
  }
  else super.add(component);
}

Jede der XYZPanel Klassen steht für einen Component Typ. In der einen Klasse sollen z.b. JButtons "abgefangen" werden, in einer anderen JLists. Also habe ihc mir gedacht alle diese Klassen müssen ein Interface implementieren welches die Klassen dazu zwingt eine solche add Methode zu implementieren.

Irgendwie ist es aber unschön. Das testen auf isinstanceof könnte man z.b. vermeiden wenn man die Methode derart gestaltet:

add(JButton but){
  //tue etwas spezielles
  super.add(but);
}

so würde von vornherein nur bei JButtons die obige methode aufgerufen werden. Allerdings müsste ich so die add(Object) Methode im Interface streichen da ja alle Klassen andere add Methoden implementieren müssen: add(JButton b), add(JList l) usw..

Könnt Ihr mir folgen :)? und wie würdet Ihr das machen?

blauton.com

blauton.com schrieb:

gomberl schrieb:

bitte poste doch deinen code - ich muss mir das nochmal ansehen

public interface OneOfManyChoice {

    public abstract void add (Object choice ) ;
}

public class  OneOfManyChoiceButtons extends JPanel implements OneOfManyChoice  {
  public OneOfManyChoiceButtons () {
    super ();
  }  

  add(Object component){
    if(component instanceof JButton){
      //Tue etwas spezielles
      super.add(component);
    }
    else super.add(component);
  } 

  public static void main(String args[]){
    OneOfManyChoiceButtons but = new OneOfManyChoiceButtons();
    but.add(new JButton());  //hier Fehler
  }
}

reference to add is ambiguous; both method add(java.awt.Component) in java.awt.Container and method add(java.lang.Object) in org.eml.adaptiveUI.CIO.OneOfManyChoiceButtons match at line 127 (127:16)

blauton.com

doppelpost.

gomberl

okay

hier nochmal von vorne
lies dir bitte noch einmal meine antwort durch
dann sieh dir dieses code stueck an -- bemerkung: test steht fuer oneofmanychoices und test2 fuer dein interface

/*
 * test.java
 *
 * Created on 03. März 2004, 22:31
 */
package org.gombsoft.MicroFuzz;

import javax.swing.*;

public class  test extends JPanel implements test2  { 
  public test () { 
    super (); 
  }

  public java.awt.Component add(java.awt.Component comp){
      return super.add(comp);
  }

  public void add(Object component){ 
    if(component instanceof JButton){ 
      //Tue etwas spezielles 
      super.add((JButton) component); 
    } 
    else 
    {
    }
  } 

  public static void main(String args[]){ 
    test but = new test(); 
    but.add(new JButton());  //hier Fehler 
  } 
}

jetzt lies dir nochmal meine letzte antwort durch

dann stell ich dir ein paar fragen:

was macht dein interface - ich habe den leisen verdacht das du dir noch nicht so ganz klar bist was ein interface ist und wie das funktioniert

2)was willst du mit der add methode machen
- du kannst auch nicht super.add() sagen wenn du ein object hast
das in Container add als add(java.awt.Component) deklariert ist kannst du kein object reinschmeissen

interface methoden brauchen nicht abstract zu sein - das sind sie automatisch
kann es nicht sein das du einfach nur add(Component) als methode deines interfaces haben willst ???

ich glaube das waere es

bin erst wieder am abend online
falls du noch fragen hast

gruesse

gomberl

Hallo gomberl, erst mal vielen Dank für Deine Mühen!!

gomberl schrieb:

dann stell ich dir ein paar fragen:

was macht dein interface - ich habe den leisen verdacht das du dir noch nicht so ganz klar bist was ein interface ist und wie das funktioniert

Es soll Methoden vorgeben welche von den Klassen die es "interfacen", implementiert werden müssen da es keine Mehrfachvererbung bei java gibt muss ich das über ein interface machen.

2)was willst du mit der add methode machen
- du kannst auch nicht super.add() sagen wenn du ein object hast
das in Container add als add(java.awt.Component) deklariert ist kannst du kein object reinschmeissen

die add Methode soll bestimmte Komponenten "abfangen". D.h. diese Bestimmten Komponenten die geadded werden, sollen vorher noch in eine andere Datenstruktur reingepackt werden bevor sie dem JPanel hinzugefügt werden.

interface methoden brauchen nicht abstract zu sein - das sind sie automatisch

da hast Du recht.

kann es nicht sein das du einfach nur add(Component) als methode deines interfaces haben willst ???

verstehe nicht was Du meinst, aber könnte stimmen
ich glaube das waere es

Habe ich Dich vielleicht so richtig verstanden: Das Problem bei mir ist das ich die Methode welche aus java.awt.COmponent stammt nicht überschreibe. Ich implementiere nur die Methode add(Object o) aus dem interface aber über schreibe die Methode die geerbt wird nicht.

Wenn ja verstehe ich nicht ganz was es bringt die einfach mit

public void add(java.awt.Component comp){
super.add(comp);
}

zu überschreiben.

Naja ich habs mal gemacht und nun kommt kein neuer Fehler mehr

wie gesagt versthen tue ichs nicht ganz warum das überschreiben der Methode die ambiguität auflöst..

gomberl

kein problem

das stimmt schon so ca - ein interface ist ein vertrag das eine klasse bestimmte methoden implementiert.
Das mit Mehrfachvererbung ist nur bedingt richtig. Aber lassen wir das. Die Feinheiten erklaer ich dir ein anderes mal. Im grossen und ganzen stimmt das.

- jetzt haben wir das Problem
Du willst nur Komponenten abfangen. Nicht aber objects.
da komme ich auch gleich zu punkt 4.
Ich glaube was du machen willst ist einfach die add(Component) methode der superklasse zu überladen.
Die Fragestellung ist soll dein Interface generell Objects bearbeiten oder immer nur sub klassen von Component. Wenn du sagst Objects dann mach es so wie es jetzt ist.
Wenn du sagst object dann lösche die add(Object) methode und mache alles in Component

Habe ich Dich vielleicht so richtig verstanden: Das Problem bei mir ist das ich die Methode welche aus java.awt.COmponent stammt nicht überschreibe. Ich implementiere nur die Methode add(Object o) aus dem interface aber über schreibe die Methode die geerbt wird nicht.

Wenn ja verstehe ich nicht ganz was es bringt die einfach mit

public void add(java.awt.Component comp){
super.add(comp);
}

zu überschreiben.

Naja ich habs mal gemacht und nun kommt kein neuer Fehler mehr

wie gesagt versthen tue ichs nicht ganz warum das überschreiben der Methode die ambiguität auflöst

Genau so ist es.
Überladen ist problematisch n diesem Fall. der Compiler weiss nicht ob er die super oder sub klasse aufrufen soll
Du kannst nur Methoden innerhalb einer klasse überladen - dh mit verschiedenen parametern aufrufbar machen
ueber klassengrenzen geht es nicht
aber du kannst ja einfach die methode implementieren und über das super object aufrufen

zu
public void add(comp)
{ super.add() }
usw

jetzt sind beide methoden innerhalb der aktuellen klasse definiert
das heisst zur laufzeit kann unterschieden werden welche methode von den 2 aufgerufen wird. das geht nicht ueber klassengrenzen hinaus.
da du bei add(Component) hier nur dasselbe machen willst wie die superklasse reicht ein super.add(component)

eins muss dir jetzt schon klar sein
alles was ein component ist - also alles was in awt oder swing enthalten ist wird NICHT von der add(object) methode abgearbeitet sondern von der add(Component methode) - das heisst

ein
if(component instanceof JButton){
in der add(object) bringt dir nichts
er wird dort nicht hinkommen
da JButton ein Component ist wird er immer
add(Component) aufrufen

ich hoffe ich habe nicht alle klarheiten beseitigt

blauton.com

gomberl schrieb:

Das mit Mehrfachvererbung ist nur bedingt richtig. Aber lassen wir das. Die Feinheiten erklaer ich dir ein anderes mal. Im grossen und ganzen stimmt das.

Das brauchst Du nicht. Ich glaube ich weis welchen Sinn und Zweck interfaces haben. Das Problem ist vielleicht das ich damit designtechnisch noch nicht so viele Erfahrungen gemacht habe, sodass ich nicht genau weiss ob ich in diesem Fall ein Interface verwenden soll.

eins muss dir jetzt schon klar sein
alles was ein component ist - also alles was in awt oder swing enthalten ist wird NICHT von der add(object) methode abgearbeitet sondern von der add(Component methode)

Yep das ist klar. ABer ich habe es trotzdem verstanden. Nun muss ich eben die add(Object o) Methode im Interface durch java.awt.Component ersetzen.