Ein Grund für die zögerliche Paketierung könnte sein, dass Eclipse bereits eine interne Paketverwaltung mitbringt, über die Plugins mittels Paketquellen installiert werden können. Eventuell haben wenige Leute Interesse daran Eclipse zu paketieren. Deshalb bin ich dazu übergegangen mir selbst ein eigenes Eclipse Paket zu bauen, und dieses über APT zu installieren. Wie das ganze funktioniert, beschreibe ich hier.

Vorbereiten und Erstellen des Arbeitsverzeichnisses

Bevor wir mit der Paketierung starten können, benötigen wir noch einige Pakete und ein Arbeitsverzeichnis, in dem wir später unser Eclipse Paket bauen werden.

$ sudo apt-get install fakeroot dpkg-dev debhelper unp

Hiermit werden einige Tools installiert, die wir benötigen um die entsprechenden Rechte des Pakets zu setzen und dieses schlussendlich zu bauen.

$ mkdir eclipse-sdk

Innerhalb dieses Arbeitsverzeichnisses müssen nun die Ordner so angelegt werden, wie sie später auf dem Dateisystem abgebildet werden sollen. Legt man also innerhalb dieses Ordners eclipse-sdk den Ordner bin an und speichert dort Dateien, so werden diese Dateien später nach /bin installiert. Userprogramme werden unter Linux üblicherweise unter /usr installiert. Ich lasse den Inhalt des Archivs nach /usr/lib/eclipse installieren.

Eclipse herunterladen und Paket vorbereiten

Ich installiere mir das Eclipse SDK, also mit bereits installierten JAVA Development Tools und in der 64-Bit Variante. Wer eine andere Version braucht, sollte dies anpassen.

$ wget http://download.eclipse.org/eclipse/downloads/drops/R-3.7.1-201109091335/download.php?dropFile=eclipse-SDK-3.7.1-linux-gtk-x86_64.tar.gz
$ unp eclipse-platform-3.6.2-linux-gtk-x86_64.tar.gz
$ mkdir -p eclipse-sdk/usr/lib
$ mv eclipse eclipse-sdk/usr/lib/eclipse

Anschließen erstellen wir ein Skript, mit dem wir Eclipse starten können. Startskripte werden in /usr/bin abgespeichert.

$ mkdir -p eclipse-sdk/usr/bin
$ touch eclipse-sdk/usr/bin/eclipse
$ chmod +x eclipse-sdk/usr/bin/eclipse

Mit dem zweiten Befehl erstellen wir eine leere Datei und geben dieser mit dem dritten Befehl Ausführrechte. Nun sollten wir dem Startskript natürlich auch einen Inhalt geben. Dies kann entweder mit einem Konsolen-Editor geschehen (wie vi oder nano) oder auch mit einem grafischen Editor (z.B. gedit, …). Folgenden Inhalt bekommt unser Startskript:

#!/bin/sh
exec /usr/lib/eclipse/eclipse "$@"

“$@” bewirkt, dass dem Skript mitgegebene Parameter an Eclipse weitergereicht werden. Nun müssen wir noch einen Menüeintrag erstellen, so dass sich Eclipse auch bequem aus dem Anwendungsmenü heraus starten lässt.

$ mkdir -p eclipse-sdk/usr/share/applications
$ nano eclipse-sdk/usr/share/applications/eclipse.desktop

[Desktop Entry]
Encoding=UTF-8
Type=Application
Name=Eclipse
Exec=eclipse
Terminal=false
Icon=/usr/lib/eclipse/icon.xpm
Comment=Eclipse Integrated Development Environment
Categories=Development;IDE;

Nun haben wir also ein Startskript, einen Anwendungsstarter sowie einen Programmordner. Fehlen nur noch Informationen, die das Paket näher beschreiben, damit auch APT was damit anfangen kann.

Paketinformationen und paketieren

Wir brauchen für die Paketierung eine Debain Control Datei. Die das Paket näher beschreibt und Abhängigkeiten auflistet.

mkdir eclipse-sdk/DEBIAN
nano eclipse-sdk/DEBIAN/control

In die Control Datei kommt folgender Inhalt:

Package: eclipse-sdk
Version: 3.7.1
Architecture: amd64
Maintainer: InsertYourNameHere
Depends: openjdk-6-jre | sun-java6-jre
Section: devel
Priority: optional
Description: Eclipse IDE, static-linked, minimal plugins.

Als Maintainer sollte euer Name stehen. Die Abhängigkeiten die Eclipse benötigt sind Java. Egal ob dies OpenJDK oder doch Sun Java ist. Alles andere ist bei Eclipse dabei.

Nun verpacken wir das Paket und können dies dann ganz bequem installieren.

$ fakeroot dpkg -b eclipse-sdk eclipse-sdk_3.7.1_amd64.deb
$ sudo dpkg -i eclipse-sdk_3.7.1_amd64.deb

Wenn fakeroot nicht vergessen wurde (wird benötigt um die Rechte richtig zu setzen!) sollte Eclipse jetzt problemlos starten.

Getestet mit Ubuntu 11.10 und Ubuntu 11.04.

package aufg1;

public class Aufg1 {

	public static void main(String[] args) {

		int i = Integer.MAX_VALUE; // entspricht Wert 2147483647

		System.out.println("A:" + ((i+1) + i));

		float f = Float.MAX_VALUE; // entspricht Wert 3.4028235E38
		System.out.println("B:" + ( 2*f - f));

		i = 1;
		System.out.println("C:" + (i<<=2) + " " + i);

		i = 7;
		System.out.println("D:" + (i & 0xFF));
		System.out.println("E:" + (i | 0xFF));

		i = 4;
		System.out.print("F:");
		while (i-- > 0) {
			System.out.print("+");
		}
		System.out.println();

		String first = new String("Hallo");
		String second = new String("Hallo");
		System.out.println("G:" + (first==second));
		System.out.println("H:" + (first.equals(second)));
	}

}

A:-1
B:Infinity
C:4 4
D:7
E:255
F:++++
G:false
H:true

Es sei folgende rekursive Methode gegeben:

package aufg2;

public class Aufg2a {

	public static void main(String[] args) {
		printRec(5);
	}

	public static void printRec(int n) {
		if (n == 0)
			return;
		for (int j = 1; j <= n; j++)
			System.out.print(j);
		System.out.println();
		printRec(n - 1);
	}

}

a) Welches Muster erzeugt der Aufruf printRec(5) auf dem Bildschirm?

12345
1234
123
12
1

b) Was passiert, wenn Sie versuchen, einen Aufruf der Form printRec(3.14) zu tätigen?

1. Compiler wird einen Fehler ausgeben
2. Die rekursive Methode erwartet einen Integer Wert, es wird allerdings ein Double übergeben

c) Was erfolgt, wenn die Methode printRec() mit einer negativen ganzen Zahl als aktuellem Parameter aufgerufen wird? Wie würden Sie die Implementierung der Methode verändern, um diesen Effekt zu verhindern?

Die Methode bricht nicht mehr ab, dh sie wird unendlich lange laufen bis der minimale Integer Wert erreicht wird und dann weiter laufen bis sie endlich bei 0 ankommt.

package aufg2;

public class Aufg2c {

	public static void main(String[] args) {
		printRec(-1);
	}

	public static void printRec(int n) {
		if (n == 0 || n <= 0)
			return;
		for (int j = 1; j <= n; j++)
			System.out.print(j);
		System.out.println();
		printRec(n - 1);
	}

}

d) Wandeln Sie die rekursive Implementierung von printRec() unter dem nachfolgenden Methodenkopf in eine iterative Implementierung um.

package aufg2;

public class Aufg2d {

	public static void main(String[] args) {
		printIt(9);
	}

	public static void printIt(int n) {
		if (n == 0 || n <= 0)
			return;

		for (int i = 1-n; i <= n; i++) {

			for (int j = 1; j <= n; j++) {
				System.out.print(j);
			}
			n = n-1;
			System.out.println();
		}
	}

}

e) Modifizieren Sie die Implementierung von printRec() unter Benutzung des nachfolgenden Rahmens so, dass in dem erzeugten Muster nur noch Kleinbuchstaben statt Ziffern erscheinen, und zwar ein a an Stelle von 1, b an Stelle von 2, …. (Es kann dabei davon ausgegangen werden, dass die Methode nur für einstellig Zahlen 0, …, 9 als aktueller Parameter aufgerufen wird).

package aufg2;

public class Aufg2e {

	public static void main(String[] args) {
		printRec(9);
	}

	public static void printRec(int n) {
		if (n == 0 || n <= 0)
			return;

		char c = 'a';

		for (int j = 1; j <= n; j++) {
			System.out.print(((char)c));
			c++;
		}
		System.out.println();
		printRec(n - 1);
	}

}

Auf Pythagoras geht der Begriff der vollkommenen Zahl (perfect number) zurück. Eine vollkommene Zahl ist eine positive ganze Zahl, deren Wert gleich der Summe seiner Teiler ist. Die kleinste vollkommene Zahl ist 6 (6 = 1 + 2 + 3), die nächste ist 28 (28 = 1 + 2 + 4 + 7 +14).
Schreiben Sie eine Methode (Klassen- oder Objektmethode?), die als Parameter eine ganze Zahl übergeben bekommt und als Wahrheitswert zurückliefert, ob die übergebene Zahl eine vollkommene Zahl ist.

public static boolean perfectNumber(int n) {
	boolean perfNum = false;
	int sumSoFar = 0, sumOfDivisors, i;

	for (i = 1; i < n; i = i + 1) {
		if (n%i == 0) {
			sumSoFar = sumSoFar + i;
		}
	}
	sumOfDivisors = sumSoFar;

	if (n == sumOfDivisors) {
		System.out.println( "The value " + n + " is PERFECT" );
		perfNum = true;
	} else {
		System.out.println( "The value " + n + " is NOT PERFECT" );
	}
	return perfNum;
}

Es soll der Speiseplan eines Restaurants in Java-Code abgebildet werden. Das nachfolgende Klassendiagramm enthält fragmentarisch den zugehörigen Entwurf.

a) Definieren Sie die Java-Klasse Gericht. Es soll die Attribute erhalten, die in obigem Klassendiagramm angegeben sind. Das Attribut preis speichert den Preis des Gerichts in Cent. Sein Wert soll über eine get()-Methode abgefragt und über eine set()-Methode verändert werden können. Die Werte der restlichen Attribute sollen unveränderlich sein. Die Werte des Attributs typ sollen wie im Diagramm durch ein auch zu definierendes enum Essenstyp abgedeckt werden (oder, falls Sie damit nichts anfangen können, ersatzweise über symbolische Konstanten in einer eigenen Klasse Essenstyp).

Ergänzen Sie die Klasse Gericht durch einen entsprechenden Konstruktor und überschreiben Sie die toString()-Methode der Klasse Object geeignet, so dass dadurch alle Attributwerte wiedergegeben werden können.

package aufg4;

public class Gericht {

	public final String name;
	public final Essenstyp typ;
	public final boolean fleischlos;
	private int preis;

	public Gericht(String name, Essenstyp typ, boolean fleischlos, int preis) {
		this.name = name;
		this.typ = typ;
		this.fleischlos = fleischlos;
		this.preis = preis;
	}

	public void setPreis(int preis) {
		this.preis = preis;
	}

	public int getPreis() {
		return preis;
	}

	public String toString() {
		String s = "Name: " + name + "\nEssenstyp: " + typ.toString() +
				   "\nFleischlos: " + fleischlos + "\nPreis: " + preis + "cent";
		return s;
	}

}

package aufg4;

public enum Essenstyp {

	VORSPEISE, HAUPTGERICHT, NACHSPEISE;

}

b) Realisieren Sie nun die Klasse Speisekarte. Die Assoziation gerichte im Klassendiagramm soll über ein Array fester Länge abgedeckt werden (Die Länge wird im Konstruktor übergeben). Realisieren Sie diesen Konstruktor sowie die Methoden addGericht() (fügt ein Gericht zur Speisekarte hinzu) sowie getBilligstes() (sucht das billigste Gericht vom übergebenen Typ heraus).

package aufg4;

public class Speisekarte {

	private Gericht[] gerichte;
	private int z = 0;

	public Speisekarte(int n) {
		gerichte = new Gericht[n];
	}

	public void addGericht(Gericht gericht) {
		for (int i = 0; i < gerichte.length -1; i++) {
			if (gerichte[i] == null) {
				gerichte[i] = gericht;
			}

			if (z < gerichte.length) {
				gerichte[z++] = gericht;
			}

		}
	}

	public Gericht getBilligstes(Essenstyp typ) {
		Gericht bG = null, aG;

		for (int i = 0; i < z; i++) {
			if (gerichte[i].typ != typ)
				continue;

			aG = gerichte[i];

			if (bG == null) {
				bG = aG;
				continue;
			}

			if (aG.getPreis() < bG.getPreis()) {
				bG = aG;
			}
		}
		return bG;
	}

}

c) Definieren Sie eine Test-Methode, in der eine Speisekarte und zwei Gerichte von gleichem Typ aber unterschiedlichem Preis instanziert und die Gerichte zur Speisekarte hinzugefügt werden. Anschließend soll die Speisekarte auf das billigste Gericht dieses Typs abgefragt werden und dessen Daten auf die Konsole ausgegeben werden.

package aufg4;

public class Test {

	public static void main(String[] args) {

		Speisekarte sk = new Speisekarte(2);
		Gericht knoedel = new Gericht("Knödel", Essenstyp.HAUPTGERICHT, true, 50);
		Gericht wurst = new Gericht("Wurst", Essenstyp.HAUPTGERICHT, false, 40);

		sk.addGericht(knoedel);
		sk.addGericht(wurst);

		System.out.println(sk.getBilligstes(knoedel.typ).toString());
	}

}