# Jtree aus CSV DateiEN mit Beziehungen



## SX15 (24. Aug 2009)

Hallo ich soll ein Java Programm schreiben, welches eine Baumstruktur (Jtree) wiedergibt. Ich habe mich erst seid einer woche in Java eingearbeitet oder wie man das nennen mag  

Als Quelle habe ich 6 CSV Dateinen 

1 Datei: Enthält Benutzerrichtlinien :
Auszug aus Datei:
1;Filiale
2;PS

2. Datei: Enthält Beziehung BR- PG : Stellt die Beziehungen von den Benutzerrichtlinien zu den Prozessgruppen dar .
Auszug aus Datei:
1;141
1;6
1;5
1;4
1;3
1;2
2;80
2;78
2;131
2;127
2;129

3. CSV Datei stellt die Prozessgruppen da:
1;Administration 
2;Rollen / Pflege
3;ertrag anlegen / aktivieren
4;Kvertrag zur Löschung vormerk
5;vertrag (logisch) löschen
7;Sachbearbeiterzuordu

4. CSV Datei stellt Beziheungen von Prozessgruppen zu anderen prozessgruppen dar. Diese könne auf gleicher Ebene eingeblendet werden und sind quasi eine erweiterung.
PG_ID;PG_ID
111;125
106;111
102;125
101;125
98;125

5. Stellet die Beziehung von den Prozessgruppen zu den Funktionen dar .
Auszug:
PG_ID;FKT_ID
141;345
140;1362
131;556
131;683
130;801

6. Stellt die Funktionen zu den pozessgruppen da die auf 3. Ebene liegen)
Auszug:
268;Ermitteln;
26;FunktionenExportierenFuerProzessgruppe;
455;AuftragGuiAnlegen;
229;TimeAndDate;


Daraus soll eine Jtree entstehhen 
Ich habe erst seit eienr Woche mich mit der Java Eclipse beschäftigt. Und da ruckelt das alles noch nicht so gut . Kann mir hier jemand eventuell weiterhelfen mit einem ausführliochen Quellcode, da mir die einzelenen Stücke aus dem Internet nie sehr hilfreich sind , da ich überhaupt nicht verstehe was dazugehört. Wenn ich einena suführlchen Code habe kann ich mich da viel besser rienlesen.

Ich danke euch schon mal. Ich bin euch jetzt schon zu großes dank verpflichtet


----------



## ARadauer (24. Aug 2009)

hat nix mit RCP/Plattform Programmierung zu tun...

ist das mehr ein Jobangebot oder sollen wir dir Hilfestellungen geben? Ich denke nicht, dass dir jemand deine komplette Aufgabe ohne Gegenleistung schreibt...

Also... kannst du deine Datei einlesen?
Die einzelnen Felder der Zeilen trennen..
daraus dein Objektmodell das einen Baum wiederspiegelt aufbauen...
in Swing darstellen...

Soll ich es dir machen oder soll ich dir dabei helfen?


----------



## SX15 (24. Aug 2009)

Ja CSV Datei einleen und mit dem hash nach ; trennen



```
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

import com.sun.org.apache.xml.internal.resolver.readers.CatalogReader;


public class oeffnen {
	

		public static void main(String[] argv) throws FileNotFoundException, IOException {
		
			
			java.util.HashMap<java.lang.Integer, java.lang.String> gruppen = new java.util.HashMap<java.lang.Integer, java.lang.String>();
			
			FileReader f = null; 
			String s = new String("");
			Integer key = null;
			String value = null;
			
			try {
				BufferedReader in = new BufferedReader(new FileReader("C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/Benutzergruppen.csv"));
				String zeile = null;
				while ((zeile = in.readLine()) != null) {
					
					int semiPos = zeile.indexOf(";");
					key = Integer.parseInt(zeile.substring(0, semiPos));
					value = zeile.substring(semiPos+1);
					gruppen.put(key, value);
					
					System.out.println("Schlüssel: " + key + " Wert: " + value);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}.edit();
```


----------



## ARadauer (24. Aug 2009)

ok.. ist schon mal ein guter Ansatz.

1. Klassen schreibt man groß
2. mit der Methode Split von String, kannst du den String einfach in ein Array teilen
3. Ich würde die Gruppen genauso wie du erstmal in einer HashMap ablegen, aber ich würde mir keinen String rein legen, sondern eine Klasse Gruppe, diese kann den Namen, id und zb eine Liste mit den Funktionen enthalten

Ich würd also drei HashMaps machen darin die Richtlinien, Gruppen und Funktonen in eigene Objekte speichern.
Im nächsten Schritt würde ich  die Datein mit den Beziehungen einlesen und die Objekte zusammen hängen...

Um das Ganze als Baum anzugeigen würd ich mir zuerst das durchlesen... Understanding the TreeModel


----------



## SX15 (24. Aug 2009)

Also... Die Dateien sind nun alle angelegt ich habe die Daten auch in Arrays eingelsen. Das einzigste wa sich nun bräuchte , ist die Beziehung.
Kann mir da jemand helfen? Ich brauche jetzt nur noch eine Code zu der Berechnung der Beziehung damit ich diese Daten dann am Jtree ausgeben kann.
Gruss


----------



## ARadauer (24. Aug 2009)

deine BenutzerRichtlinie enthält ja Prozessgruppen, oder?

Ich würde nun sowas in die BenutzerRichtlinie einbauen....


```
import java.util.ArrayList;

public class BenutzerRichtlinie {
	
	ArrayList<ProzessGruppe> prozessGruppen = new ArrayList<ProzessGruppe>();
	
	public void addProzessGruppe(ProzessGruppe prozessGruppe){
		prozessGruppen.add(prozessGruppe);
	}

}
```

wenn du nun dein  BR- PG  Tabelle ließt und du schon deine Hasmaps hast kannst du ja sowas machen..


```
HashMap<Integer, ProzessGruppe> prozessGruppen = null;
		
		HashMap<Integer, BenutzerRichtlinie> benutzerRichtlinen = null;
		
		//hier die Richtlinenen und Gruppen lesen
		
	über deine zeilen iterieren{
		int benutzerRichtline =0; //aus BR -PG ermitteln...
		int prozessGruppe = 0;
		
		//hier kann man noch einwenig auf null überprüfen
		benutzerRichtlinen.get(benutzerRichtline).addProzessGruppe(prozessGruppen.get(prozessGruppe)); 
}
```


----------



## SX15 (24. Aug 2009)

Hier mal mei nCode:

Die erste Klasse zum einlesen


```
package fieloperations;
import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;







public class DateiLesen {
	
	
	public java.util.HashMap<java.lang.Integer, java.lang.String> StammdatenEinlesen(java.lang.String dateiName) {
		
		java.util.HashMap<java.lang.Integer, java.lang.String> gruppen_BG = new java.util.HashMap<java.lang.Integer, java.lang.String>();
		 
		
		Integer key_BG = null;
		String value_BG = null;
	
		try {
			BufferedReader in = new BufferedReader(new FileReader(dateiName));
			String zeile = null;
			while ((zeile = in.readLine()) != null) {
				
				int semiPos = zeile.indexOf(";");
				key_BG = Integer.parseInt(zeile.substring(0, semiPos));
				value_BG = zeile.substring(semiPos+1);
				gruppen_BG.put(key_BG, value_BG);
				
				//System.out.println("Schlüssel: " + key_BG + " Wert: " + value_BG);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return gruppen_BG;
	}
	
	
	public java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> BeziehungEinlesen(java.lang.String dateiName) {
		
		Integer key_Bez = null;
		Integer key_Bez_alt =1;
		Integer value_Bez = null;
		java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> gruppen_Bez = new java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>>();
		java.util.ArrayList<java.lang.Integer> values = new java.util.ArrayList<java.lang.Integer>();
	
		try {
			BufferedReader in = new BufferedReader(new FileReader(dateiName));
			String zeile = null;
			while ((zeile = in.readLine()) != null) {
				int semiPos = zeile.indexOf(";");
				
				// Key und Value lesen 
				key_Bez = Integer.parseInt(zeile.substring(0, semiPos));
				value_Bez = Integer.parseInt(zeile.substring(semiPos+1));
				
				// Wenn key sich nicht geändert hat: in Value-Liste für den Key neuen Value aufnehmen
				if(key_Bez == key_Bez_alt){
					values.add(value_Bez);
				// Wenn key sich geändert hat:
				} else {	
					gruppen_Bez.put(key_Bez_alt, values);
					values = new java.util.ArrayList<Integer>();
					values.add(value_Bez);
				}
				key_Bez_alt = key_Bez;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return gruppen_Bez;
	}
	
}.edit();
```


und die 2. Klasse zum Bearbeiten:


```
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;

import fieloperations.DateiLesen;

public class Baum {
	
	static java.util.HashMap<java.lang.Integer, java.lang.String> benutzerGruppen_BG = null;
	static java.util.HashMap<java.lang.Integer, java.lang.String> benutzerGruppen_PG = null;
	static java.util.HashMap<java.lang.Integer, java.lang.String> benutzerGruppen_Funk = null;
	static java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> Beziehung_BG_PG = null;
	static java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> Beziehung_PG_PG = null;
	static java.util.TreeMap<java.lang.Integer, java.util.ArrayList<Integer>> Beziehung_PG_Funktionen = null;
	
	public static void main(String[] args) {
		JFrame frame = new JFrame();
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		DefaultMutableTreeNode root = new DefaultMutableTreeNode("Wurzel");

		java.lang.String datei_benutzergruppen_BG = "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/Benutzergruppen.csv";
		java.lang.String datei_benutzergruppen_PG = "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/Prozessgruppen.csv";
		java.lang.String datei_benutzergruppen_Funk = "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/Funktionen.csv";
		java.lang.String datei_Beziehung_BG_PG = "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/BG-PG.csv";
		java.lang.String datei_Beziehung_PG_PG = "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/PG-PG.csv";
		java.lang.String datei_Beziehung_PG_Funktionen = "C:/Dokumente und Einstellungen/shabicht/Desktop/baumstruktur/csv/PG-FK.csv";
		
		System.out.println();
		DateiLesen reader = new DateiLesen();
//		benutzerGruppen_BG = reader.StammdatenEinlesen(datei_benutzergruppen_BG);
//		benutzerGruppen_PG = reader.StammdatenEinlesen(datei_benutzergruppen_PG);
//		benutzerGruppen_Funk = reader.StammdatenEinlesen(datei_benutzergruppen_Funk);
//		Beziehung_BG_PG = reader.BeziehungEinlesen(datei_Beziehung_BG_PG);
		Beziehung_PG_PG = reader.BeziehungEinlesen(datei_Beziehung_PG_PG);
//		Beziehung_PG_Funktionen = reader.BeziehungEinlesen(datei_Beziehung_PG_Funktionen);
		
//		System.out.println(Beziehung_BG_PG);
	
		for (java.util.Map.Entry<java.lang.Integer, java.util.ArrayList<Integer>> entry : Beziehung_PG_PG
				.entrySet()) {

			System.out.println("Key: " + entry.getKey() + " Value: "+ entry.getValue());.edit();
```


----------



## SX15 (24. Aug 2009)

Er gibt mir nun alle Beziehungen aus :

Beziehung_BG_PG:
Key: 1 Value: [133, 132, 131, 130, 129, 128, 127, 126, 120, 118, 119, 116, 110, 82, 67, 124, 109, 108, 102, 101, 100, 99, 98, 97, 94, 93, 90, 89, 88, 87, 86, 85, 84, 83, 80, 79, 78, 77, 73, 72, 71, 69, 66, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 33, 32, 31, 30, 29, 28, 27, 26, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 136, 137, 140, 139, 138, 141, 6, 5, 4, 3, 2]
Key: 2 Value: [80, 78, 131, 127, 129, 130, 128, 110, 84, 83, 59, 60, 121, 109, 107, 102, 101, 100, 99, 98, 82, 76, 75, 73, 72, 71, 69, 66, 64, 63, 62, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 41, 40, 39, 38, 37, 28, 27, 136]
Key: 3 Value: [131, 127, 130, 129, 101, 100, 99, 98, 92, 91, 81, 72, 66, 64, 55, 102]
Key: 4 Value: [128, 131, 127, 129, 130, 116, 115, 109, 102, 101, 99, 98, 73, 66, 64, 63, 55, 35, 24, 100]
Key: 5 Value: [129, 130, 128, 131, 127, 109, 102, 101, 100, 99, 98, 92, 91, 81, 72, 66, 64, 55, 63]
Key: 6 Value: [130, 129, 128, 131, 110, 109, 102, 101, 100, 99, 98, 64, 63, 62, 127]
Key: 99 Value: [99, 66, 1]
Key: 100 Value: [66, 104, 99]
Key: 101 Value: [105, 99]
Key: 102 Value: [106, 99]

und die anderen beziheungen aus PG-PG und PG - Funktion

Das einzigste ist jetzt noch der BAum


----------



## SX15 (24. Aug 2009)

ICh weiss das bei diesem Code der Fehler entstehen kann das er unsortierte CSV Tabellen nicht korregt wiedergibt aber das ist mir vorerst egal. Ich will erstmal das der BAum jetzt reinkommt ^^ Das ganze soll später sowieso über das Netzwerk laufen über ein Server und dann ist das mit den CSV Dateien eh hinfällig. Aber es soll halt nun mal funktionieren vorerst (fürs Ego)


----------



## ARadauer (25. Aug 2009)

wie schauts aus? hast du noch ein Problem dabei? Konkrete Fragen?


----------



## SX15 (25. Aug 2009)

Ok ich versuch es so konkret wie möglich zu beschreiben, obwohl ich erst seit 2 Wochen Java lerne. Nun gut.

Also was mir an meinem Programm noch fehlt ist das Implementieren des Baumdiagrammes. 

Ich habe folgende Variablen ( zur Verfügung dafür:

*Berechtigungsgruppen BG (HashMap) Beispiel:  1;Empfang
Prozessgruppen PG  (HashMap)         Beispiel:  1;Einloggen
Funktionen FK  (HashMap)                Beispiel:  1;Schreiben*

Folglich sollte daraus ein Baumdiagramm entstehen mit der _(Wurze)l Empfang-->Einloggen (2.Stufe) --> Schreiben (als drtte Stufe)_

Ausserdem habe ich Beziehung zwischen Berechtigungsgruppen BG und Prozessgruppen
diese Variable heißt: (TreeMap)


```
Beziehung_BG_PG .edit();
```

Beziehungsn zwischen Prozessgruppen und Prozessgruppen (Falls eien prozessgruppe eine andere Prozessgruppe hat soll diese einfach unter der 1. Prozessgruppe am Baumdiagramm ausgegebene werden als auch auf der 2. Stufe. ´
Diese ist auch ein (TreeMap)


```
Beziehung_PG_PG.edit();
```

Und als letztes habe ich die Beziehung zwischen den Prozessgruppen und den Funktionen Auch (TreeMap).


```
Beziehung_PG_Funktionen.edit();
```

Die Funktionenw erden dann auf der letzten Stuffe angezeigt.



Was ich bereits habe:

Ich habe die erste Stufe des BAumdiagrammes ausgegeben:


```
int x = 0;
		java.lang.String berechtigungsNamen[] = new java.lang.String[Beziehung_BG_PG.size()];
		for (java.util.Map.Entry<java.lang.Integer, java.util.ArrayList<Integer>> entry : Beziehung_BG_PG
				.entrySet()) {
			//System.out.println(benutzerGruppen_BG.get(entry.getKey()));
			berechtigungsNamen[x++] = benutzerGruppen_BG.get(entry.getKey());
			
		}
		
		DefaultMutableTreeNode rootx = new DefaultMutableTreeNode();
		JTree tree = new JTree(berechtigungsNamen);
		frame.add(new JScrollPane(tree));
		frame.pack();
		frame.setVisible(true);.edit();
```



Als Ergebnis kommthalt die Wurzeln:

Filiale
PS
BIL
KRED
BIL_PFLEGE
ZENTRALE
Administration 
Administrator 
Technischer Administrator
Administration 
Hotline


----------



## SX15 (25. Aug 2009)

Die Frage halt nun: Wie bekomm ich den rest vom Baum hin hab schon alles ausprobiert mit den Sachen ausem net aber ich reil das net Scheiss baum^^


----------



## ARadauer (25. Aug 2009)

java.lang.String berechtigungsNamen.. das ist schwer zu lesen nimm nur String und importier java.lang... auch bei Hashmap usw...


Beziehung_BG_PG sieht für mich aus wie eine Konstate. Variablen schreibt man klein und CamelCase beziehungBgPg...

hast du dir das bereits durchgelesen Understanding the TreeModel ?

Ich würde keine Strings verwalten, ich würde wirklich Berechtigungsgruppen verwalten. Mach dir 3 Klassen für deine Objekte und versuch sie zu verknüpfen... so ähnlich wie ich gestern um 12:35 geschrieben habe...

Versuch dann nicht aus deinen Strings mit Array irgendwie einen Baum zu bauen.. das is eher schlecht.
Du hast zum Schluss nur eine Liste mit Berechtigungsrichtlinien, die wiederum Prozessgruppen beinhalten... usw.. das stellt deinen Baum dar... 

man kann dann her gehen und kann die einzelnen Objekte TreeNode implementieren lassen oder man steuert das verhalten von aussen und macht sich ein TreeModel... 

ich versuch das mal in einem kleinen Beispiel darzustellen....


```
package tree;

import java.util.ArrayList;
import java.util.HashMap;

import javax.swing.JFrame;
import javax.swing.JTree;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;



public class MyTreeModel extends Node implements TreeModel  {




	HashMap<Integer,BenutzerRichtlinie > richtlinien = new HashMap<Integer, BenutzerRichtlinie>();
	HashMap<Integer,ProzessGruppe > gruppen = new HashMap<Integer, ProzessGruppe>();
	HashMap<Integer,Funktion> funktionen = new HashMap<Integer, Funktion>();

	public MyTreeModel(int id, String name) {
		super(id, name);
		children= new ArrayList<Node>();

		//zum Testen
		//hier liest du ein und baust dein Zeug zusammen... das machst du alles dynamisch anhand deiner csv files..

		children.add(new BenutzerRichtlinie(1, "Recht 1"));
		children.add(new BenutzerRichtlinie(2, "Recht 2"));
		children.add(new BenutzerRichtlinie(3, "Recht 3"));
		richtlinien.put(1, (BenutzerRichtlinie) children.get(0));
		richtlinien.put(2, (BenutzerRichtlinie) children.get(1));
		richtlinien.put(3, (BenutzerRichtlinie) children.get(2));



		gruppen.put(1, new ProzessGruppe(1, "Gruppe 1a"));
		gruppen.put(2, new ProzessGruppe(2, "Gruppe 1b"));
		gruppen.put(3, new ProzessGruppe(3, "Gruppe 2a"));
		gruppen.put(4, new ProzessGruppe(4, "Gruppe 3a"));
		gruppen.put(5, new ProzessGruppe(5, "Gruppe 3b"));

		funktionen.put(1, new Funktion(1, "Funktioon 1a i"));
		funktionen.put(2, new Funktion(2, "Funktioon 1a ii"));
		funktionen.put(3, new Funktion(3, "Funktioon 1b i"));
		funktionen.put(4, new Funktion(4, "Funktioon 2a i"));
		funktionen.put(5, new Funktion(5, "Funktioon 3a i"));
		funktionen.put(6, new Funktion(6, "Funktioon 3b i"));
		funktionen.put(7, new Funktion(7, "Funktioon 3b ii"));

		//jetzt zusammen hängen

		richtlinien.get(1).addNode(gruppen.get(1));
		richtlinien.get(1).addNode(gruppen.get(2));

		richtlinien.get(2).addNode(gruppen.get(3));

		richtlinien.get(3).addNode(gruppen.get(4));
		richtlinien.get(3).addNode(gruppen.get(5));

		gruppen.get(1).addNode(funktionen.get(1));
		gruppen.get(1).addNode(funktionen.get(2));
		gruppen.get(2).addNode(funktionen.get(3));
		gruppen.get(3).addNode(funktionen.get(4));
		gruppen.get(4).addNode(funktionen.get(5));
		gruppen.get(5).addNode(funktionen.get(6));
		gruppen.get(5).addNode(funktionen.get(7));	


	}

	//hier beginnt der spaß



	@Override
	public Object getChild(Object parent, int index) {
		if (parent instanceof Node) {
			Node p = (Node) parent;
			if(p.getChildren()!=null)
				return p.getChildren().get(index);			
		}
		return null;
	}

	@Override
	public int getChildCount(Object parent) {
		if (parent instanceof Node) {
			Node p = (Node) parent;
			if(p.getChildren()!=null)
				return p.getChildren().size();	
		}
		return 0;
	}

	@Override
	public int getIndexOfChild(Object parent, Object child) {
		if (parent instanceof Node && child instanceof Node) {
			Node p = (Node) parent;
			Node c = (Node) child;
			if(p.getChildren()!=null){
				for(int i = 0; i< p.getChildren().size(); i++){
					if(c.getId()==p.getChildren().get(i).getId())
						return i;
				}				
			}				
		}
		return 0;
	}

	@Override
	public Object getRoot() {
		return this;
	}

	@Override
	public boolean isLeaf(Object node) {
		return node instanceof Funktion;
	}

	@Override
	public void removeTreeModelListener(TreeModelListener l) {
		// TODO Auto-generated method stub

	}

	@Override
	public void valueForPathChanged(TreePath path, Object newValue) {
		// TODO Auto-generated method stub

	}

	@Override
	public void addTreeModelListener(TreeModelListener l) {
		//interssiert mich jetz nicht...

	}

	public static void main(String[] args) {
		JFrame frame = new JFrame("Tree Test");
		frame.add(new JTree(new MyTreeModel(0, "root")));
		frame.pack();
		frame.setVisible(true);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}



}
package tree;

import java.util.ArrayList;

public class Node  {
	
	protected int id;
	protected String name;
	
	protected ArrayList<Node> children;
	protected Node parent;
	
	
	public Node(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}


	public void addNode(Node node){
		if(children!=null){
			node.setParent(this);
			children.add(node);
		}
	}
	
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void setParent(Node parent) {
		this.parent = parent;
	}
	

	public Node getParent() {
		return parent;
	}


	public String toString(){
		return name;
	}


	public ArrayList<Node> getChildren() {
		return children;
	}


	public void setChildren(ArrayList<Node> children) {
		this.children = children;
	}
	
	
	
	
	

}

package tree;

import java.util.ArrayList;


public class BenutzerRichtlinie extends Node{

	public BenutzerRichtlinie(int id, String name) {
		super(id, name);
		children = new ArrayList<Node>();
	}

	

}

package tree;

import java.util.ArrayList;



public class ProzessGruppe extends Node {

	public ProzessGruppe(int id, String name) {
		super(id, name);
		children = new ArrayList<Node>();
	}


}
package tree;

public class Funktion extends Node{

	public Funktion(int id, String name) {
		super(id, name);
	}

	
	
}
```
doch nicht so klein das Beispiel ;-)


----------

