# Aufbau von größerem Programm



## jimb0p (21. August 2013)

Hallo Zusammen,

ich habe ein Programm das aus mehreren Teilprogrammen besteht. Zu Beginn hat es gereicht dass ich vom Hauptprogramm die Teilprogramme (jeweils einzelne .jars) aufrufe und entsprechend Pfade übergebe beim Aufruf. Aber mittlerweile ist das Programm so groß geworden und es soll ein komplettes Logging über die einzelnen Programme stattfinden sodass ich mich gefragt habe was der bessere Weg wäre. 

Ich habe mir überlegt dem Java-Projekt für jedes Teilprogramm ein Paket anzulegen und mir dann entsprechend Objekte im Hauptprogramm von den jeweiligen Klassen hole und so damit arbeite. Wäre das ein richtiger Ansatz? 

Des weiteren hätte ich dazu dann direkt eine Frage: Wenn ich in eclipse über "Configure Buildpath..." eine externe .jar eingepflegt habe, warum ist sie nicht in allen Paketen verfügbar? Oder verstehe ich die Pakete generell falsch?

Und vielleicht kann mir auch jemand den Unterschied zwischen einem Package und einem Source Ordner mit (default package) erklären. Denn wenn ich meine Klassen im default package 
habe wird meine Bibliothek gefunden. 

Freue mich über jede Hilfe.


----------



## Der Wolf (21. August 2013)

Hallo,

importierst du denn deine Klassen, die du verwenden möchtest? Also angenommen du hast folgende Klasse im Paket _de.test.main_


```
package de.test.main;

public class Test {
}
```

und eine weitere Klasse Test2 im Default Paket. Hast du dann ganz am Anfang der Test2.java ein 


```
import de.test.main.Test;
```

stehen? Das musst du für alle Klassen machen, die nicht im selben Paket enthalten sind, wie die Klasse in der du gerade arbeitest. 

Gruß,
Wolf


----------



## jimb0p (21. August 2013)

Hi Wolf,

ja das habe ich genau so. Und im default package habe ich auch Zugriff auf bspw. die View im views Package. Nur geht das auch anders herum? Dass ich Zugriff auf eine Klasse im default package habe oder ist das eher nicht der Fall?

Zudem habe ich in dem views Package kein Zugriff auf meine eingebundene Library aber im default package schon, woran kann das liegen?

Ist die Idee an sich denn korrekt dass ich statt mehrere .jar Dateien einfach Objekte der Klassen erstelle (die Klassen aus denen die jars erstellt wurden) und ich dann einfach die Funktionen aufrufe?

Gruß,
jimb0p


----------



## sheel (21. August 2013)

Hi



jimb0p hat gesagt.:


> Ist die Idee an sich denn korrekt dass ich statt mehrere .jar Dateien einfach Objekte der Klassen erstelle (die Klassen aus denen die jars erstellt wurden) und ich dann einfach die Funktionen aufrufe?


Ohne zu wissen, was die ganzen Sachen sind bzw. machen
kann man schwer irgendwelche Vorschläge machen.
Aber warum nicht einfach die bestehenden Programme aufrufen?
Wenn das Ganze so durcheinander ist, dass schon die Existenz von denen ein Problem ist,
würde das unveränderte Zusammenstecken in ein Programm auch nichts besser machen.

Zur Sache mit dem Defaultpackage:
Nicht umsonst bekommt man Warnungen, dass man das nicht verwenden soll.


----------



## jimb0p (21. August 2013)

Ja es geht mir darum dass die einzelnen .jar nacheinander aufgerufen werden und eine Kette bilden (1.jar -> 2. jar -> 3. jar usw.) Wenn jetzt ein Fehler in einer dieser .jars passiert kann ich mit dem Hauptprogramm keinen Einfluss darauf nehmen, wenn ich aber die Objekte habe kann ich das. Denke ich in die falsche Richtung?


----------



## Writtscher (21. August 2013)

Also wenn du jars chainen willst und auf verhalten reagieren willst würde mir jetzt nur System.exit(irgendein int); im Ausnahmefall einfallen. Auf diesen glaube ich kann man reagieren. Aber niemals wirklich ausprobiert. Also ich meine:


```
try {
   MACHE WAS();

} catch(NullPointerException npe) {
   LOGGE MICH (npe);
   System.exit(5);
}
```

Jetzt kannst du das jar ausführen und wirst wohl merken wenn was schief läuft (denke ich).
Was du aber willst, aber nicht ausdrücken kannst, ist, dass du eine eigene Bibliothek, also eigenständiges Projekt hast und dieses Projekt, also die Funktionalitäten (Objekte usw.) einem anderen Projekt zur Verfügung stellen möchtest. Dies nennt man externe Dependencies... Einfach dein jar bauen lassen und dieses jar dem anderen jar, dass deine geschriebene Bibliothek verwenden soll als dependency bekannt machen -  schon kannst du hacken.


----------



## jimb0p (21. August 2013)

Habe es gerade mit der Bibliothek hinbekommen. Danke! Problem war dass ich hier auch (default package) hatte. Also immer darauf achten dass man seinen Paketen Namen gibt ja?


----------



## Writtscher (21. August 2013)

Die java lang spec sagt:


```
It is a compile time error to import a type from the unnamed package.
```


----------



## sheel (21. August 2013)

@jimb0p: Ja, immer Namen geben
@Writtscher: System.exit funktioniert genau so, ja.


----------



## jimb0p (12. März 2014)

Hallo Zusammen,

bin aktuell an einem neuen Projekt und stehe wieder vor der Entscheidung: .jar's aufrufen oder Klassen einbinden. Jedes Programm für sich hat sehr viele Einstellungs- und Logdateien. Ich habe mich aktuell dafür entschieden jeweils die .jar's aufzurufen jedoch habe ich das Problem, dass es bei dem ausgeführten Programm zu einem Pfadproblem kommt, da ich dieses Programm von dem "Hauptprogramm" aus aufrufen. Somit landen sämtliche Einstellungen, Speicherungen etc. in dem Verzeichnis des Hauptprogramms. Der Code dazu sieht so aus:


```
ProcessBuilder pb = new ProcessBuilder("java", "-jar", "Module\\AutoImporter\\AutoImporter.jar");
Process p = pb.start();
```

Dann habe ich natürlich das workingdir wie folgt geändert:


```
ProcessBuilder pb = new ProcessBuilder("java", "-jar", "Module\\AutoImporter\\AutoImporter.jar");
pb.directory(new File("Module\\AutoImporter\\"));
Process p = pb.start();
```
Jedoch dann startet das Tool erst gar nicht. Wo liegt der Hund begraben? Freue mich wenn mir jemand einen Tipp geben kann.

Gruß!


----------

