Rekursiv Methode ausführen bei Kindern

Diskutiere Rekursiv Methode ausführen bei Kindern im Java Basics - Anfänger-Themen Bereich.
H

hasocuk

Hallo zusammen,

ich habe zwar im Forum gesucht bin auf Binärbäume und weiteren Themen gestoßen, aber ich fand auf meine Fragestellung keine Antwort, daher habe ich ein kleines Beispiel erstellt. Ich möchte aus irgendeiner Stelle des Models eine Funktion aufrufen, wobei ich hierbei die angelegten Instanzen ermitteln und entweder in der ersten Ebene bei den gefundenen Instanzen die Ausgeben Methode aufrufen oder auch Alternativ, durch die komplette Struktur durchgeben. Könnt ihr mir bitte hierzu Hilfestellung geben. Vielen Dank im Voraus.

Gruß
Hasan

Java:
public class Start {
 public static void main(String[] args) {
Komponenten myKomps = new Komponenten();
//1. Einlesen der Kinder von den Klassenkopien von Module die unterhalb der Klasse Komponenten direkt agelegt wurden (1.Ebene) und
// bei diesen Klassen die Ausgeben Methode aufrufen. Der Aufruf kann auch von einer anderen Programmstelle erfolgen, also nicht
// unbedingt aus der Startklasse
// 2. Wie kann ich wie oben die Kinder und dessen Kinder und Kindeskinder den Baum entlang durchlaufen und
// die Ausgeben Methode aufrufen

 }
}
public class Komponenten {
String name;
Module myMod;
Module myModErgaenzer;
Module myModHelfer;
public void init() {
this.myMod = new Mod1("Modul1");
this.myModErgaenzer = new ModErgaenzer("Ergaenzer");
this.myModHelfer = new ModHelfer("Helfer");

}
}
public class Module {
String name;

public Module(String name) {
this.name = name;
}
public void ausgeben() {
System.out.println(this.name);
}
}
public class Mod1 extends Module{
Modulteile myTeil;
Modulteile myTeil2;
public Mod1(String name) {
super(name);
// TODO Auto-generated constructor stub
myTeil = new Modulteil_2("ModTeil2");
myTeil2 = new Modulteil_3("ModTeil3");
}
}
public class ModErgaenzer extends Module {
 public ModErgaenzer(String name) {
super(name);
}
}
public class ModHelfer extends Module {
Modulteile myTeil;
Modulteile myTeil2;
public ModHelfer(String name) {
super(name);
myTeil = new Modulteil_1("ModTeil1");
myTeil2 = new Modulteil_1("ModTeil2");
}
}
public class Modulteile {
String name;
public Modulteile(String name) {
this.name = name;
}
public void ausgeben() {
System.out.println(this.name);
}
}
public class Modulteil_1 extends Modulteile{
 public Modulteil_1(String name) {
super(name);
}
}
public class Modulteil_2 extends Modulteile{
 public Modulteil_2(String name) {
super(name);
}
}
public class Modulteil_3 extends Modulteile{
 public Modulteil_3(String name) {
super(name);
}
}
 
Zuletzt bearbeitet von einem Moderator:
Kirby_Sike

Kirby_Sike

Packe dein Code bitte in Code Brackets, klick auf die drei Punkte
 
H

hasocuk

Code:
public class Start {

    public static void main(String[] args) {
        Komponenten myKomps = new Komponenten();
        //1.  Einlesen der Kinder von den Klassenkopien von Module die unterhalb der Klasse Komponenten direkt agelegt wurden (1.Ebene) und
        // bei diesen Klassen die Ausgeben Methode aufrufen. Der Aufruf kann auch von einer anderen Programmstelle erfolgen, also nicht
        // unbedingt aus der Startklasse
        // 2. Wie kann ich wie oben die Kinder und dessen Kinder und Kindeskinder den Baum entlang durchlaufen und
        // die Ausgeben Methode aufrufen
        
    }

}

public class Komponenten {
    String name;
    Module myMod;
    Module myModErgaenzer;
    Module myModHelfer;
        public void init() {
            this.myMod = new Mod1("Modul1");
            this.myModErgaenzer = new ModErgaenzer("Ergaenzer");
            this.myModHelfer = new ModHelfer("Helfer");
            
        }
}

public class Module {
    String name;
    
    public Module(String name) {
        this.name = name;
    }
    public void ausgeben() {
         System.out.println(this.name);
    }
}

public class Mod1 extends Module{
    Modulteile myTeil;
    Modulteile myTeil2;
    public Mod1(String name) {
        super(name);
        // TODO Auto-generated constructor stub
        myTeil = new Modulteil_2("ModTeil2");
        myTeil2 = new Modulteil_3("ModTeil3");
    }
}

public class ModErgaenzer extends Module {

    public ModErgaenzer(String name) {
        super(name);
    }
}

public class ModHelfer extends Module {
Modulteile myTeil;
Modulteile myTeil2;
    public ModHelfer(String name) {
        super(name);
        myTeil = new Modulteil_1("ModTeil1");
        myTeil2 = new Modulteil_1("ModTeil2");
    }
}

public class Modulteile {
    String name;
    public Modulteile(String name) {
        this.name = name;
    }
    public void ausgeben() {
         System.out.println(this.name);
    }
}

public class Modulteil_1 extends Modulteile{

    public Modulteil_1(String name) {
        super(name);
        }
}
public class Modulteil_2 extends Modulteile{

    public Modulteil_2(String name) {
        super(name);
        }
}
public class Modulteil_3 extends Modulteile{

    public Modulteil_3(String name) {
        super(name);
        }
}
 
mihe7

mihe7

Ich möchte aus irgendeiner Stelle des Models eine Funktion aufrufen, wobei ich hierbei die angelegten Instanzen ermitteln und entweder in der ersten Ebene bei den gefundenen Instanzen die Ausgeben Methode aufrufen oder auch Alternativ, durch die komplette Struktur durchgeben.
?!?
 
Kirby_Sike

Kirby_Sike

Ich muss ehrlich gestehen, dass ich nicht wirklich verstehe wo jetzt dein Problem liegt
 
T

temi

Einlesen der Kinder von den Klassenkopien von Module die unterhalb der Klasse Komponenten direkt agelegt wurden
Sollst du direkt auf die Attribute der Klasse "Komponenten" zugreifen oder eine Methode in "Komponenten" implementieren?
Der Aufruf kann auch von einer anderen Programmstelle erfolgen, also nicht unbedingt aus der Startklasse
Also doch eine Methode oder wie ist das zu verstehen?
 
H

hasocuk

Hallo zusammen
ich möchte z.B. ein Button wählen, wo dieser button untergebracht ist, soll keine Rolle spielen. Dieser soll prüfen, welche exemplare von der Klasse Module vorliegen und z.b. in einer for schleife zu jedem objekt die methode xy aufrufen, daher zugreifen. Es existieren bereits z.b. von der Klasse Module die Kinder Mod1, ModErgaenzer, ModHelfer die Objekte, das wäre die 1. Ebene (wie kann das realisiert werden). Weiterhin möchte ich mit einem 2. Button wie oben, aber einen tiefergehend durchlaufen können, womit als erstes die ausgeben methode wie im Beispiel Mod1 aufrufe und dann die ausgeben methode der Instanzen der Modulteile ( Modulteil-1, Modulteil-2). Hoffe das verständlich ist.
Gruß
 
T

temi

ich möchte z.B. ein Button wählen, wo dieser button untergebracht ist, soll keine Rolle spielen.
Richtig wäre: GUI sollte keine Rolle spielen, es sei denn es ist ein GUI-Problem, das du lösen möchtest. Deine ursprüngliche Frage sieht aber eher aus, als ginge es um ein Domänenproblem.

Die Aufgabe 1 lässt sich (vorausgesetzt, der Code befindet sich im selben Package wie Komponenten) so lösen:
Java:
Komponenten myKomps = new Komponenten();
myKomps.myMod.ausgeben();
myKomps.myModErgaenzer.ausgeben();
myKomps.myModHelfer.ausgeben();
Aber vermutlich ist das nicht so, wie du es dir wünscht.

Sind die Klassen, so wie sie oben stehen, vorgegeben oder von dir programmiert?

Letztlich brauchst du ein sauberes Design, mit einer Datenstruktur, die es auf einfachem Weg ermöglicht dein Problem zu lösen.
 
H

hasocuk

Hallo,

die Struktur baue ich so auf. Die Klassen sind wie angegeben strukturiert, die Klasse Komponenten legt die spezifizierten Module an und die wiederum ihre Modulteile.
Ich möchte wie erkannt, nicht mit
myKomps.myModHelfer.ausgeben();
die Methode direkt ansprechen und mit jeder neuen Klasse nachpflegen, sondern in der Klasse Komponenten die Methode ausgeben() aufrufen. Ab hier soll die Methode rekursiv durchlaufen.
Gruß
 
mihe7

mihe7

Die Klassen sollten für den rekursiven Durchlauf eine einheitliche Schnittstelle haben, etwas wie

Java:
public interface Node<T> {
    T getValue();
    List<Node<T>> getChildren();
}
Ausgehend von einem x-beliebigen Knoten, kann man nun den Baum rekursiv durchlaufen:
Java:
public void visit(Node<T> root, Consumer<T> c) {
    if (root == null) { return; }
    c.accept(root.getValue());
    for (Node<T> child : root.getChildren()) {
        visit(child, c);
    }
}
 
H

hasocuk

Guten Abend,

vielen Dank. Ich glaube genau das ist die Lösung, aber ich kriege es aber nicht zum laufen. Ich habe eine Interface-Klasse angelegt mit
Java:
public interface Node<T> {
    T getValue();
    List<Node<T>> getChildren();
}
Klasse "Module" und Klasse "Modulteile z.B. wie folgt ergänzt --> public class Modulteile implements Node { und den 2. Codeteil jeweils in diese Rumpfklassen eingefügt.
Code:
public void visit(Node<T> root, Consumer<T> c) {
    if (root == null) { return; }
    c.accept(root.getValue());
    for (Node<T> child : root.getChildren()) {
        visit(child, c);
    }
}
Über die Klasse Komponenten habe ich es nun versucht aufzurufen, es gibt nur etwas aus, wenn ich die Variable myMod weitergebe, aber ich möchte eigentlich --> visit( Module , (Consumer<T>) getValue()); --- angeben, das damit die getvalue() von myMod (Klasse Mod1), myModErgaenzer (Klasse ModErgaenzer), myModHelfer (Klasse ModHelfer) durchgelaufen werden.

Code:
public class Komponenten {
    String name;
    Module myMod;
    Module myModErgaenzer;
    Module myModHelfer;
        public void init() {
            this.myMod = new Mod1("Modul1");
            this.myModErgaenzer = new ModErgaenzer("Ergaenzer");
            this.myModHelfer = new ModHelfer("Helfer");
            visit( this.myMod , (Consumer<T>) getValue());
        }
}
Falls ich es komplett falsch eingebaut habe, könnt ihr es mir bitte mit dem obigen Beispielcode aufzeigen wie es richtig eingebaut wird, soweit fortgeschritten bin ich doch nicht. Vielen Dank für eure mühen.
Gruß
 
mihe7

mihe7

Das war ein allgemeiner Ansatz für einen Baum, um die grundsätzliche Idee zu zeigen. Die gezeigte visit()-Methode für einen Durchlauf "von außerhalb" gedacht. Natürlich kann man die auch im Knoten implementieren, dann sieht die Methode ein klein wenig anders aus. Der Punkt ist, dass die Inhalte der Klassen einen gemeinsamen Typen T haben sollten. Wenn Du einmal Komponenten und einmal Module hast, dann kannst Du nur Object als gemeinsamen Typen verwenden, was beim "Besuch" Fallunterscheidungen notwendig macht.

Wenn Du nur ausgeben() rekursiv aufrufen willst, dann implementieren halt alle Klassen ein gemeinsames Interface, das diese Methode definiert.
 
H

hasocuk

Danke für die Erklärungen, ich werde mich ans Zeug legen und versuchen es zum laufen zu bringen.
 
Thema: 

Rekursiv Methode ausführen bei Kindern

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben