Über ein Interface methoden ansprechen

[derMiche]

Hallo,

also ich verzweifel hier schon beihnahe - suche schon seit ca 1 1/2h bei google und find einfach nicht das was ich suche,
hier mal kurz was ich "theoretisch" suche:

public interface MyInterface
{
     ....
     public void sayHello ();
     ....
}

public class Hello1 implements MyInterface
{
     ....
     public void sayHello ()
     {
          System.out.println ("Hi, hier Hello1");
     }
     ....
}

public class Hello2 implements MyInterface
{
     ....
     public void sayHello ()
     {
          System.out.println ("Hi, hier Hello2");
     }
     ....
}

public class TestMyInterface
{
     public static void main (String args[])
     {
          ...
          MyInterface.sayHello(); // Hier soll jetzt jede klasse reagieren die MyInterface inplementiert hat
          ...
     }
}

am ende möchte ich halt eine zahl in den "raum werfen", ohne zu wissen was da alles an klassen da sind, und irgendeine
klasse wird sich angesprochen fühlen.

Ziel:
erweiterbares programm durch einfaches implementieren, ohne jede klasse einzeln eintragen zu müssen.

ansonsten müsste man ja so arbeiten:

public class TestMyInterface
{
     public static void main (String args[])
     {
          ...
          Hello1 h1 = new Hello1 ();
          Hello2 h2 = new Hello2 ();
          ...
          h1.sayHello();          // genau dieses "kleingefutzel" würde ich mir gerne sparen
          h2.sayHello();
          ...
     }
}

 

[KrokoDiehl]

Ich bin mir nicht sicher, ob ich dich richtig verstanden habe, aber was du willst, klingt bisher nach dem Factory-Muster (unter dem Begriff lässt sich sicher einiges ergooglen). Kurzum heißt das, dass du einer Factory deine Zahl in den Rachen wirfst und irgendeine Instanz von MyInterface raus bekommst. Welche, darum kümmert sich nur die Factory selbst, nicht der Aufrufer.
Minimalst könnte das etwa so aussehen:

public class HelloFactory
{
    public static MyInterface newHelloInstance( int number )
    {
        switch (number)
        {
            case 1: return new Hello1();
            case 2: return new Hello2();
            ...
            default: return null; // bzw. Fehlerbehandlung, sonstwas
    }    
}

// Benutzung:

MyInterface hello = HelloFactory.newHelloInstance( no );
hello.sayHello();

 

[U2nt]

Könntest das ganze "kleingestückelte" in eine Liste packen und dann mit einer for-each Schleife "ausgeben" lassen.

List<MyInterface> myList = new ArrayList<MyInterface>();
myList.add(h1);
myList.add(h2);

for(MyInterface mi : myList) {
  mi.sayHello();
}

 

[KrokoDiehl]

Hm, jetzt wo ich U2nts Antwort lese, macht die viel mehr Sinn, bezogen auf die Frage 🙂

 

[derMiche]

naja,
dann müsst ich ja trotzdem an meiner klasse was ändern, bzw jede weiter klasse eintragen...
ich kann mir des grad au nemme ganz vorstellen wie das gehen soll, zuviel wirres zeug gelesen XD

ich möchte sozusagen den "kern" des Programms nicht anrühren aber jederzeit klassen hinzufügen können, mit denen es aber trotzdem arbeiten kann, ohne sie zu kennen.
ob des über schnittstellen machbar ist bzw sinn mach weis ich net,

 

[Antoras]

Wenn du den Quelltext nicht ändern möchtest, dann bleibt dir nur die Möglichkeit die Klassen dynamisch zu laden. D.h. du definierst z.B. eine Datei in der die Namen der Klassen drinstehen und diese werden dann über Reflection geladen. Wenn du gar nichts ändern willst, also auch keine externe Datei, dann kannst du deinem Programm auch sagen, dass es ein Verzeichnis durchsuchen soll und alle darin liegenden Klassen mit einem Eintrittspunkt laden soll.

interface I {
  void entryPoint();
}
class X implements I {
  @Override void entryPoint() {/*mach was*/}
}

Der Eintrittspunkt ist pracktsich nur eine Kennzeichnung, an der dein Programm erkennt, dass die Klasse geladen werden soll. Das kann anstatt einer Methode z.B. auch eine Annotation sein oder schlichtweg nur ein bestimmter Zusatz beim Namen (wie MyClassMyInterfaceImpl -> MyInterfaceImpl).
Du musst dir dann halt nur noch überlegen wie du auf die geladenen Klassen zugreifen kannst. Das würde z.B. über eine Map gehen:

Map<String, I> classes;
// im Classloader
classes.put(className, classReference)

Wobei der Key der Map etwas ist mit dem du die Klasse identifizieren und verwenden kannst.

 

[timbeau]

Du kannst nicht über ein Interface einen Berg von Klassen ansprechen. Das ist sicherlich auch nicht gewollt.

Was du aber machen kannst ist z.B. in deinem Hauptprogramm eine Methode die einen Parameter vom Typ Interface erwartet konstruieren. Dieser kannst du dann alle Klassen übergeben die dieses Interface implementieren.

/**
* fun = Interface
* ifaceTest(Zwei) implementiert fun
**/

public static void main(String[] args) {
ifaceTests i = new ifaceTests();		
ifaceTestsZwei izwei = new ifaceTestsZwei();
		pri(i);
pri(izwei);
	}
	
	private static void pri(fun fun){
		fun.sayHello();
	}

 

[derMiche]

danke das ihr mir so schnell geholfen habt! 🙂
ich werde mir darüber jetzt erstmal den kopf zerbrechen - welcher weg am besten für mein problem ist...

 

[freez]

Also irgendwie kommen mir eure Antworten zu kompliziert vor. Oder ich habe die Frage noch nicht richtig verstanden. Als Lösung würde ich folgendes vorschlagen:
Klasse TestMyInterface.main(...):

public static void main (String args[])
     {
          ...
          MyInterface iHello = new Hello1();
          iHello.sayHello(); // Ausgabe von Hello1
          iHello = new Hello2();
          iHello.sayHello(); // Ausgabe von Hello2
          ...
     }

Ist es das, was du suchtest, oder habe ich was falsch verstanden?

 

[Antoras]

Das wurde bereits in den ersten Antworten vorgeschlagen. Der TO will diese Lösung aber nicht, da er dabei wissen muss wie viele Implementierungen vorhanden sind und wie diese konkret heißen. Außerdem muss er dabei bei jeder Änderung immer wieder die Sourcen anpassen.
Der TO hat aber auch nicht genauer spezifiziert was er genau erreichen möchte - eine hilfreichere Antwort als die bereits vorhandenen kann man so nur schwer geben.