Rekursiv Methode ausführen bei Kindern

H

hasocuk

Mitglied
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:
H

hasocuk

Mitglied
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);
        }
}
 
Kirby.exe

Kirby.exe

Top Contributor
Ich muss ehrlich gestehen, dass ich nicht wirklich verstehe wo jetzt dein Problem liegt
 
temi

temi

Top Contributor
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

Mitglied
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ß
 
temi

temi

Top Contributor
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

Mitglied
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

Top Contributor
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

Mitglied
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

Top Contributor
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

Mitglied
Danke für die Erklärungen, ich werde mich ans Zeug legen und versuchen es zum laufen zu bringen.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
G Methode Rekursiv umschreiben Java Basics - Anfänger-Themen 8
A Frage Methode ggt Rekursiv Java Basics - Anfänger-Themen 5
H Binominalkoeffizient tail-rekursiv in java darstellen Java Basics - Anfänger-Themen 0
GAZ Tribonacci Folge Rekursiv Java Basics - Anfänger-Themen 11
G Primzahlen von Rekursiv nach Iterativ Java Basics - Anfänger-Themen 6
A Ackermmanfunktion rekursiv Java Basics - Anfänger-Themen 4
A Binärbaum rekursiv durchsuchen und Referenz zurückgeben Java Basics - Anfänger-Themen 4
L Jede zweite Ziffer entfernen (rekursiv) Java Basics - Anfänger-Themen 6
J Dateien in Verzeichnissen rekursiv auflisten wirft Exception Java Basics - Anfänger-Themen 4
D Pentagonale Nummern in Rekursiv Java Basics - Anfänger-Themen 14
O Enum Array Rekursiv abarbeiten Java Basics - Anfänger-Themen 44
E Weg-Suche-Problem rekursiv Java Basics - Anfänger-Themen 12
O Primzahl rekursiv mit einem Wert ohne i, wie? Java Basics - Anfänger-Themen 6
E Erste Schritte Potenz Negativ (rekursiv) Java Basics - Anfänger-Themen 2
O Rekursiv aufrufen Java Basics - Anfänger-Themen 2
F In List Rekursiv suchen Java Basics - Anfänger-Themen 12
F Iterativ in Rekursiv Java Basics - Anfänger-Themen 2
S Fibonacci Zahlen rekursiv Java Basics - Anfänger-Themen 1
L Rekursiv zwei Strings vergleichen Java Basics - Anfänger-Themen 3
B Fakultätsfunktion Rekursiv Berechnen aber mit Array Java Basics - Anfänger-Themen 10
J Fibonacci -Folge rekursiv berechnen Java Basics - Anfänger-Themen 18
B Wie kann ich Linien rekursiv zeichnen? Java Basics - Anfänger-Themen 4
kilopack15 Sin(x) rekursiv lösen Java Basics - Anfänger-Themen 17
T Rekursiv Tiefe eines binären Suchbaums ermitteln Java Basics - Anfänger-Themen 22
P Methoden Arrays.AsList kleinste Zahl ausgeben Rekursiv Java Basics - Anfänger-Themen 9
W A hoch N Rekursiv Java Basics - Anfänger-Themen 3
K Rechtecke rekursiv zeichnen Java Basics - Anfänger-Themen 20
V Quadrate rekursiv zeichnen Java Basics - Anfänger-Themen 7
M Fibonacci rekursiv mittels Cache Java Basics - Anfänger-Themen 17
E Binärbaum - von rekursiv zu iterativ Java Basics - Anfänger-Themen 10
Y Rekursiv Palindrom herausfinden Java Basics - Anfänger-Themen 5
B Fibonacci Zahlen rekursiv Array Java Basics - Anfänger-Themen 12
M String rekursiv Spiegeln mit Originalwort davor Java Basics - Anfänger-Themen 3
K Türme von Hanoi - Rekursiv. Java Basics - Anfänger-Themen 1
T MergeSort rekursiv programmieren Java Basics - Anfänger-Themen 8
M Zahlenpyramide rekursiv programmieren Java Basics - Anfänger-Themen 7
hello_autumn Potenz selber berechnen, Rekursiv. Java Basics - Anfänger-Themen 6
V Text wüerfeln-Rekursiv Java Basics - Anfänger-Themen 4
J Baum rekursiv durchlaufen Java Basics - Anfänger-Themen 2
D Münzverteilung Möglichkeiten | Rekursiv Java Basics - Anfänger-Themen 3
R Hanoi rekursiv lösen Problem Java Basics - Anfänger-Themen 1
D Rekursiv Kombinationen ausgeben klappt nur bei einer Wiederholung Java Basics - Anfänger-Themen 4
shiroX OOP String rekursiv zurückgeben Java Basics - Anfänger-Themen 6
Z Fibonacci rekursiv meine Erklärung stimmt so? Java Basics - Anfänger-Themen 2
S java rekursiv iterativ hilfee :s Java Basics - Anfänger-Themen 5
E Erste Schritte Pi, rekursiv Java Basics - Anfänger-Themen 6
E Hanoi-Varianten rekursiv Java Basics - Anfänger-Themen 2
P Hanoi rekursiv zu iterativ umbauen Java Basics - Anfänger-Themen 20
P Mittelwert rekursiv Java Basics - Anfänger-Themen 13
E Integral Rekursiv Java Basics - Anfänger-Themen 15
M MergeSort rekursiv Java Basics - Anfänger-Themen 2
D Ziffer in Zahl Rekursiv Java Basics - Anfänger-Themen 4
B Array rekursiv untersuchen Java Basics - Anfänger-Themen 21
I Rekursiv Java Basics - Anfänger-Themen 13
C Rekursiv Zahlenfolgen berechnen mit zwei Variablen Java Basics - Anfänger-Themen 5
K Rekursiv zu Literal Java Basics - Anfänger-Themen 12
R Verzeichnisse rekursiv nach Dateiduplikaten durchsuchen Java Basics - Anfänger-Themen 5
L File Tree rekursiv Java Basics - Anfänger-Themen 10
W Binomialkoeffizient iterativ/rekursiv Java Basics - Anfänger-Themen 2
X Addition rekursiv ohne Schleife Java Basics - Anfänger-Themen 10
M Sudoku Rekursiv lösen Java Basics - Anfänger-Themen 9
E Datentypen ein java problem rekursiv loesen Java Basics - Anfänger-Themen 2
K indexOf selbst rekursiv definieren Java Basics - Anfänger-Themen 4
M Fibonacci-Linear und Rekursiv Java Basics - Anfänger-Themen 14
J Java Rekursiv vs(zu) Iterativ Hilfe Java Basics - Anfänger-Themen 3
D preOrder, inOrder, postOrder rekursiv zusammensetzen aus String Java Basics - Anfänger-Themen 1
K Binomialkoeffizient rekursiv berechnen Java Basics - Anfänger-Themen 8
J eulersche rekursiv berechnen Java Basics - Anfänger-Themen 6
J Suchbaumeigenschaft rekursiv programmieren Java Basics - Anfänger-Themen 3
T Rekursiv Vokale zählen Java Basics - Anfänger-Themen 19
G Bestimmte Ebene eines Baumes rekursiv ausgeben Java Basics - Anfänger-Themen 49
F Sortieralgorithmus von rekursiv auf iterativ? Java Basics - Anfänger-Themen 21
G Sudoku rekursiv lösen Java Basics - Anfänger-Themen 10
S Stringlänge Rekursiv ermitteln Java Basics - Anfänger-Themen 2
dognose Verzeichnis rekursiv auslesen / beschränkte Apis. Java Basics - Anfänger-Themen 6
0 a hoch b rekursiv - wie stoppen? Java Basics - Anfänger-Themen 3
T Ordnerstrucktur rekursiv auslesen Java Basics - Anfänger-Themen 9
G Rekursiv die größte Zahl eines Arrays Java Basics - Anfänger-Themen 6
G Rekursiv Array Elemente quadrieren Java Basics - Anfänger-Themen 2
N Fibo Zahlen:iterativ,rekursiv Anzahl der Additionen zählen Java Basics - Anfänger-Themen 2
P Permutationen einer Tour rekursiv Java Basics - Anfänger-Themen 4
G Baumstruktur rekursiv durchlaufen Java Basics - Anfänger-Themen 2
B Kürzesten Weg zwischen mehreren Punkten finden (rekursiv) Java Basics - Anfänger-Themen 5
L Kombinationen einer Menge rekursiv berechnen Java Basics - Anfänger-Themen 11
J BinBaum rekursiv ausgeben Java Basics - Anfänger-Themen 9
W Rekursiv Zeichen einfügen Java Basics - Anfänger-Themen 6
M Verzeichnisse rekursiv durchlaufen und dann RegEx Java Basics - Anfänger-Themen 6
G Array rekursiv teilen und aufsummieren Java Basics - Anfänger-Themen 9
D Rekursiv 2 Strings vergleichen Java Basics - Anfänger-Themen 14
G tree rekursiv Java Basics - Anfänger-Themen 8
G Binominalkoeffizient rekursiv berechnen Java Basics - Anfänger-Themen 8
J Rekursiv muss dass laufen! Java Basics - Anfänger-Themen 11
K JTree aus DB rekursiv füllen Java Basics - Anfänger-Themen 12
J Verz rekursiv durchgehen Java Basics - Anfänger-Themen 2
I Iterativ <-> Rekursiv in Java Java Basics - Anfänger-Themen 11
F rekursiv kürzester Weg Java Basics - Anfänger-Themen 7
B von rekursiv zu iterativ Java Basics - Anfänger-Themen 6
0 Harmonische Reihe rekursiv berechnen? Java Basics - Anfänger-Themen 10
G rekursiv zahl umdrehen Java Basics - Anfänger-Themen 5
B Pseudocode: rekursiv/nicht-rekursiv Java Basics - Anfänger-Themen 1

Ähnliche Java Themen

Anzeige


Oben