Lösung

Achtung: Diese Aufgabe ist besonders relevant für die Klausur!!!

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.Vector;
import unibwm.Grafik;

public class Aufgabe27
{
	public static void main(String[] args)
	{
		// Variablen Deklaration
		String sQuellDateiName;
		Grafik gfkAusgabe;
		File fleDatei;
		Scanner scnEingabe;
		Vector<String> sData;
		Vector<Integer> iPosX;
		Vector<Integer> iPosY;

		// Variablen Initialisierung
		sQuellDateiName = "daten.txt";
		gfkAusgabe = new Grafik();
		fleDatei = new File(sQuellDateiName);
		sData = new Vector<String>();
		iPosX = new Vector<Integer>();
		iPosY = new Vector<Integer>();

		try
		{
			scnEingabe = new Scanner(fleDatei);

			while (scnEingabe.hasNext())
				sData.add(scnEingabe.next());

			for (int i = 0; i < sData.size(); ++ i)
			{
				iPosX.add(Integer.parseInt(sData.elementAt(i).split(",")[0]));
				iPosY.add(Integer.parseInt(sData.elementAt(i).split(",")[1]));
			} // end for

			for (int i = 0; i < iPosX.size(); ++ i)
			{
				Haus NeuesHaus = new Haus(iPosX.elementAt(i), iPosY.elementAt(i));
				NeuesHaus.Zeichnen(gfkAusgabe);
			} // end for
			gfkAusgabe.show("Ausgabe der Häuser");	

		} // end try
		catch (FileNotFoundException e)
		{
			System.out.println("Datei konnte nicht gelesen werden!");
		} // end catch
	} // end main
} // end Aufgabe27

Und die geforderte Klasse für das Haus:

import unibwm.Grafik;

public class Haus
{
	int iStartX, iStartY, iBreite, iHoehe, iDachHoehe;

	public Haus(int iStartX, int iStartY, int iBreite,
			int iHoehe, int iDachHoehe)
	{
		this.iStartX = iStartX;
		this.iStartY = iStartY;
		this.iBreite = iBreite;
		this.iHoehe = iHoehe;
		this.iDachHoehe = iDachHoehe;
	} // end Haus (ausführlicher Konstruktor)

	public Haus(int iStartX, int iStartY)
	{
		this.iStartX = iStartX;
		this.iStartY = iStartY;
		this.iBreite = 20;
		this.iHoehe = 30;
		this.iDachHoehe = 10;
	} // end Haus (nur Position Konstruktor)

	public void Zeichnen(Grafik gfkAusgabe)
	{
		int x1 = iStartX, y1 = iStartY;
		int x2 = iStartX, y2 = iStartY + iHoehe;
		int x3 = iStartX + iBreite, y3 = iStartY + iHoehe;
		int x4 = iStartX + iBreite, y4 = iStartY;
		int x5 = iStartX + iBreite / 2, y5 = iStartY + iHoehe + iDachHoehe;

		gfkAusgabe.addLine(x1, y1, x2, y2);
		gfkAusgabe.addLine(x2, y2, x3, y3);
		gfkAusgabe.addLine(x3, y3, x4, y4);
		gfkAusgabe.addLine(x4, y4, x2, y2);
		gfkAusgabe.addLine(x2, y2, x5, y5);
		gfkAusgabe.addLine(x5, y5, x3, y3);
		gfkAusgabe.addLine(x3, y3, x1, y1);
		gfkAusgabe.addLine(x1, y1, x4, y4);
	} // end Zeichnen
} // end Haus

Lösung

import java.io.*;
import java.util.Scanner;
import java.util.Vector;

public class Aufgabe26
{
	public static void main(String[] args)
	{
		// Variablen Deklaration
		String sQuellDateiName, sZielDateiName;
		File fleDatei;
		Scanner scnEingabe;
		PrintStream pstAusgabe;
		Vector<Integer> iZahlen;
		Vector<Integer> iDoppelt;

		// Variablen Initialisierung
		sQuellDateiName = "daten.txt";
		sZielDateiName = "doppelt.txt";
		fleDatei = new File(sQuellDateiName);
		iZahlen = new Vector<Integer>();
		iDoppelt = new Vector<Integer>();

		try
		{
			scnEingabe = new Scanner(fleDatei);

			while (scnEingabe.hasNextInt())
				iZahlen.add(scnEingabe.nextInt());

			for (int i = 0; i < iZahlen.size(); ++ i)
				for (int j = 0; j < i; ++ j)
					if (iZahlen.elementAt(j) == iZahlen.elementAt(i))
					{
						boolean bNeu = true;
						for (int k = 0; k < iDoppelt.size(); ++ k)
							if (iZahlen.elementAt(j) == iDoppelt.elementAt(k))
								bNeu = false;
						if (bNeu)
							iDoppelt.add(iZahlen.elementAt(i));
					} // end if

		} // end try
		catch (FileNotFoundException e)
		{
			System.out.println("Datei konnte nicht gelesen werden!");
		} // end catch

		fleDatei = new File(sZielDateiName);

		try
		{
			pstAusgabe = new PrintStream(fleDatei);
			for (int i = 0; i < iDoppelt.size(); ++ i)
				pstAusgabe.println(iDoppelt.elementAt(i));
		} // end try
		catch (FileNotFoundException e)
		{
			System.out.println("Datei nicht gefunden");
		} // end catch
	}
}

• Division aller Elemente einer Matrix durch das betragsmäßig größte Element
• Zerlegung einer Matrix A in jeweils 3×3 große Teilmatrizen
• Länge eines Vektors (als 1-zeilige Matrix):
  

Lösung

public class Aufgabe25 extends Aufgabe24
{
	public static double[][] MaxQuotient (double[][] dMatrix)
	{
		for (int i = 0; i < dMatrix.length; ++ i)
			for (int j = 0; j < dMatrix[0].length; ++ j)
				dMatrix[i][j] /= MaximalerWert(dMatrix);

		return dMatrix;
	} // end ProduktSkalar

	public static void DreierZerlegung (double[][] dMatrix)
	{
		for (int i = 0; i < dMatrix.length / 3; ++ i)
			for (int j = 0; j < dMatrix[0].length / 3; ++j)
			{
				System.out.println(dMatrix[3 * i][j * 3]
				           + " " + dMatrix[3 * i][j * 3 + 1]
				           + " " + dMatrix[3 * i][j * 3 + 2]);
				System.out.println(dMatrix[3 * i + 1][j * 3]
				       	   + " " + dMatrix[3 * i + 1][j * 3 + 1]
				       	   + " " + dMatrix[3 * i + 1][j * 3 + 2]);
				System.out.println(dMatrix[3 * i + 2][j * 3]
				       	   + " " + dMatrix[3 * i + 2][j * 3 + 1]
				       	   + " " + dMatrix[3 * i + 2][j * 3 + 2]);

				System.out.println("-----");
			}

	}

	public static double Betrag (double[] dVektor)
	{
		double dQuadSumme = 0;
		for (int i = 0; i < dVektor.length; ++ i)
			dQuadSumme += dVektor[i] * dVektor[i];
		return Math.sqrt(dQuadSumme);
	}

	public static void main(String[] args)
	{
		double[] dTest1 = {1, 2, 3};
		double[][] dTest3 = {{1, 2, 3}, {2, 3, 4}, {4, 5, 6}};

		double[][] dTest4 = {{1, 2, 3, 4, 5, 6},
							 {2, 3, 4, 3, 2, 1},
							 {4, 6, 8, 6, 4, 2},
							 {3, 5, 9, 7 ,4, 1},
							 {2, 4, 8, 7, 6, 1},
							 {2, 3 ,1, 5, 4, 5}};

		System.out.println("-----");
		DreierZerlegung(dTest4);

		System.out.println(MaxQuotient(dTest3)[1][1]);

		System.out.println(Betrag(dTest1));

	}
}

Und die extended Aufgabe24:

public class Aufgabe24
{
	public static double[][] Summe (double[][] dMatrixA, double[][] dMatrixB)
	{
		double[][] dErgebnis = new double[dMatrixA.length][dMatrixA[0].length];

		for (int i = 0; i < dMatrixA.length; ++ i)
			for (int j = 0; j < dMatrixA[0].length; ++ j)
				dErgebnis[i][j] = dMatrixA[i][j] + dMatrixB[i][j];

		return dErgebnis;
	} // end Summe

	public static double[][] ProduktSkalar (double[][] dMatrix, double dSkalar)
	{
		for (int i = 0; i < dMatrix.length; ++ i)
			for (int j = 0; j < dMatrix[0].length; ++ j)
				dMatrix[i][j] *= dSkalar;

		return dMatrix;
	} // end ProduktSkalar

	public static double MaximalerWert (double[][] dMatrix)
	{
		double dMax = 0;
		for (int i = 0; i < dMatrix.length; ++ i)
			for (int j = 0; j < dMatrix[0].length; ++ j)
				if (dMatrix[i][j] > dMax)
					dMax = dMatrix[i][j];
		return dMax;
	} // end MaximalerWert

	public static double[][] Transponierte (double[][] dMatrix)
	{
		double[][] dErgebnis = new double[dMatrix.length][dMatrix[0].length];
		for (int i = 0; i < dMatrix.length; ++ i)
			for (int j = 0; j < dMatrix[0].length; ++ j)
				dErgebnis[i][j] = dMatrix[j][i];
		return dErgebnis;
	} // end Transponierte

	public static double[][] TeilMatrix (double[][] dMatrix, int[] iBereich)
	{
		double[][] dErgebnis
			= new double[iBereich[2] - iBereich[0] + 1]
			            [iBereich[3] - iBereich[1] + 1];
		for (int i = iBereich[0]; i <= iBereich[2]; ++ i)
			for (int j = iBereich[1]; j <= iBereich[3]; ++ j)
				dErgebnis[i - iBereich[0]][j - iBereich[1]] = dMatrix[i][j];
		return dErgebnis;
	} // end TeilMatrix

	public static void main (String[] args)
	{
		double[][] dTest1 = {{1, 2, 3}, {4, 5, 6}};
		double[][] dTest2 = {{2, 3, 4}, {5, 7, 6}};
		double[][] dTest3 = {{1, 2, 3}, {2, 3, 4}, {4, 5, 6}};
		int[] iBereich = {1, 1, 2, 2};

		System.out.println(Summe(dTest1, dTest2)[1][0]);
		System.out.println(ProduktSkalar(dTest1, 5)[1][0]);
		System.out.println(MaximalerWert(dTest2));
		System.out.println(Transponierte(dTest3)[2][0]);
		System.out.println(TeilMatrix(dTest3, iBereich)[1][0]);
	} // end main
} // end Aufgabe 24

• Addition zweier Matrizen
• Multiplikation mit einem Skalar
• Ermittlung des betragsmäßig größten Elements einer Matrix
• Transponieren einer Matrix
• Ermittlung der Teilmatrix von A. Die Teilmatrix besteht aus den Zeilen z1-z2 und den Spalten s1-s2 von A

Lösung

public class Aufgabe24
{
	public static double[][] Summe (double[][] dMatrixA, double[][] dMatrixB)
	{
		double[][] dErgebnis = new double[dMatrixA.length][dMatrixA[0].length];

		for (int i = 0; i < dMatrixA.length; ++ i)
			for (int j = 0; j < dMatrixA[0].length; ++ j)
				dErgebnis[i][j] = dMatrixA[i][j] + dMatrixB[i][j];

		return dErgebnis;
	} // end Summe

	public static double[][] ProduktSkalar (double[][] dMatrix, double dSkalar)
	{
		for (int i = 0; i < dMatrix.length; ++ i)
			for (int j = 0; j < dMatrix[0].length; ++ j)
				dMatrix[i][j] *= dSkalar;

		return dMatrix;
	} // end ProduktSkalar

	public static double MaximalerWert (double[][] dMatrix)
	{
		double dMax = 0;
		for (int i = 0; i < dMatrix.length; ++ i)
			for (int j = 0; j < dMatrix[0].length; ++ j)
				if (dMatrix[i][j] > dMax)
					dMax = dMatrix[i][j];
		return dMax;
	} // end MaximalerWert

	public static double[][] Transponierte (double[][] dMatrix)
	{
		double[][] dErgebnis = new double[dMatrix.length][dMatrix[0].length];
		for (int i = 0; i < dMatrix.length; ++ i)
			for (int j = 0; j < dMatrix[0].length; ++ j)
				dErgebnis[i][j] = dMatrix[j][i];
		return dErgebnis;
	} // end Transponierte

	public static double[][] TeilMatrix (double[][] dMatrix, int[] iBereich)
	{
		double[][] dErgebnis
			= new double[iBereich[2] - iBereich[0] + 1]
			            [iBereich[3] - iBereich[1] + 1];
		for (int i = iBereich[0]; i <= iBereich[2]; ++ i)
			for (int j = iBereich[1]; j <= iBereich[3]; ++ j)
				dErgebnis[i - iBereich[0]][j - iBereich[1]] = dMatrix[i][j];
		return dErgebnis;
	} // end TeilMatrix

	public static void main (String[] args)
	{
		double[][] dTest1 = {{1, 2, 3}, {4, 5, 6}};
		double[][] dTest2 = {{2, 3, 4}, {5, 7, 6}};
		double[][] dTest3 = {{1, 2, 3}, {2, 3, 4}, {4, 5, 6}};
		int[] iBereich = {1, 1, 2, 2};

		System.out.println(Summe(dTest1, dTest2)[1][0]);
		System.out.println(ProduktSkalar(dTest1, 5)[1][0]);
		System.out.println(MaximalerWert(dTest2));
		System.out.println(Transponierte(dTest3)[2][0]);
		System.out.println(TeilMatrix(dTest3, iBereich)[1][0]);
	} // end main
} // end Aufgabe 24

Lösung

Zur Lösung dieser Aufgabe wird die Datei unibwm.jar benötigt. Sie kann in der Eclipse Umgebung in den Projektoptionen unter “add external jar” hinzugefügt werden.

import unibwm.*;			// Grafik für die Ausgabe der Diagramme
import java.util.Scanner; 	// Scanner für die Eingabe von n

public class Aufgabe23
{
	static final int iFaktorX = 5;
	static final int iFaktorY = 20;
	static final int iIntervall = 100;

	public static void main(String[] args)
	{
		Scanner scnEingabe = new Scanner(System.in);
		System.out.print("n eingeben: ");
		int iAnzahlGesamt = scnEingabe.nextInt();
		int iMax = 0;
		int[] iZufall = new int[iAnzahlGesamt];
		int[] iAnzahl = new int[iIntervall + 1];
		Grafik gfkAusgabe = new Grafik();

		for(int i = 0; i < iAnzahlGesamt; ++ i)
		{
			iZufall[i] = (int) (Math.random() * iIntervall + 1);
			//System.out.println(iZufall[i]);
			++ iAnzahl[iZufall[i]];
		}

		for(int i = 1; i <= iIntervall; ++ i)
			if (iAnzahl[i] > iMax)
				iMax = iAnzahl[i];

		ZeichneDiagramm(iAnzahl, gfkAusgabe, 10, 10, iMax, "original");

		iAnzahl = GemittelterVektor(iAnzahl);
		ZeichneDiagramm(iAnzahl, gfkAusgabe,
				10 , 20 + iMax * iFaktorY, iMax, " 1 x gemittelt");

		iAnzahl = GemittelterVektor(iAnzahl);
		ZeichneDiagramm(iAnzahl, gfkAusgabe,
			10 + 110 * iFaktorX, 20 + iMax * iFaktorY, iMax, "2 x gemittelt");

		iAnzahl = GemittelterVektor(iAnzahl);
		iAnzahl = GemittelterVektor(iAnzahl);
		ZeichneDiagramm(iAnzahl, gfkAusgabe,
			10 + 110 * iFaktorX, 10 , iMax, "4 x gemittelt");

		gfkAusgabe.show("Ausgabe der Diagramme");
	}

	public static void ZeichneDiagramm(int[] iAnz, Grafik gfkAusg,
			int iStartX, int iStartY, int iMaximum, String sText)
	{

		// Koordinatenachsen:
		gfkAusg.addLine(iStartX, iStartY, iStartX + 100 * iFaktorX, iStartY);
		gfkAusg.addLine(iStartX, iStartY, iStartX,
				iStartY + iMaximum * iFaktorY);

		// Beschriftung:
		gfkAusg.addText(iStartX + 5, iStartY + 5, sText);

		for(int i = 1; i < iIntervall; ++ i)
			gfkAusg.addLine(i * iFaktorX + iStartX,
					iAnz[i] * iFaktorY + iStartY,
					(i + 1) * iFaktorX + iStartX,
					iAnz[i+1] * iFaktorY + iStartY);
	} // end ZeichneDiagramm

	public static int[] GemittelterVektor(int[] iVektor)
	{
		int[] iErgebnis = new int[iVektor.length];
		iErgebnis[0] = iVektor[0];
		iErgebnis[iVektor.length - 1] = iVektor[iVektor.length - 1];

		for(int i = 1; i < iVektor.length - 1; ++ i)
			iErgebnis[i] = (int) (.5 * (iVektor[i - 1] + iVektor[i + 1]));
		return iErgebnis;
	} // end GemittelterVektor
}

Teil b:

import unibwm.*;			// Grafik für die Ausgabe der Diagramme

public class Aufgabe23b
{
	static final int iFaktorX = 5;
	static final int iFaktorY = 20;
	static final int iIntervall = 100;
	static final int iDiagramme = 4;
	static final int[] iRadius = {1, 3, 6};

	public static void ZeichneDiagramm(int[] iAnzahl, Grafik gfkAusg,
			int iStartX, int iStartY, int iMaximum, String sText)
	{

		// Koordinatenachsen:
		gfkAusg.addLine(iStartX, iStartY, iStartX + 100 * iFaktorX, iStartY);
		gfkAusg.addLine(iStartX, iStartY, iStartX,
				iStartY + iMaximum * iFaktorY);

		// Beschriftung:
		gfkAusg.addText(iStartX + 5, iStartY + 5, sText);

		for(int i = 0; i < iIntervall - 1; ++ i)
			gfkAusg.addLine(i * iFaktorX + iStartX,
					iAnzahl[i] * iFaktorY + iStartY,
					(i + 1) * iFaktorX + iStartX,
					iAnzahl[i+1] * iFaktorY + iStartY);
	} // end ZeichneDiagramm

	public static int[] GemittelteWerte(int[] iVektor, int iRadius)
	{
		int[] iErgebnis = new int[iVektor.length];

		for (int i = 0; i < iVektor.length; ++ i)
		{
			int iSumme = 0, iSummanden = 0;
			for (int j = i - iRadius; j <= i + iRadius; ++ j)
			{
				if (j >= 0 && j < iVektor.length)
				{
					iSumme += iVektor[j];
					++ iSummanden;
				} // end if
			} // end for
			iErgebnis[i] = iSumme / iSummanden;
		} // end for
		return iErgebnis;
	} // end GemittelteWerte

	public static void main (String args[])
	{
		// Variablen Deklaration
		int iAnzahlZahlen;
		int iWert[], iAnzahl[];
		int[][] iGemittelterWert;
		int iMax;
		Grafik gfkAusgabe = new Grafik();

		// Variablen Initialisierung
		iAnzahlZahlen = 1000;
		iWert = new int[iAnzahlZahlen];
		iAnzahl = new int[iIntervall];
		iGemittelterWert = new int[iDiagramme-1][iIntervall];
		iMax = 0;

		// Erstellen der Zufallszahlen
		for (int i = 0; i < iAnzahlZahlen; ++ i)
			iWert[i] = (int) (Math.random() * iIntervall);;

		// Initialisieren des Zählvektors
		for (int i = 0; i < iIntervall; ++ i)
			iAnzahl[i] = 0;

		// Zählen der Werte
		for (int i = 0; i < iAnzahlZahlen; ++ i)
			++ iAnzahl[iWert[i]]; 

		// Maximum finden
		for(int i = 0; i < iIntervall; ++ i)
			if (iAnzahl[i] > iMax)
				iMax = iAnzahl[i];

		// original zeichnen
		ZeichneDiagramm(iAnzahl, gfkAusgabe, 10, 10, iMax, "original");

		// werte mitteln
		iGemittelterWert[0] = GemittelteWerte(iAnzahl, iRadius[0]);

		// neu zeichnen
		ZeichneDiagramm(iGemittelterWert[0], gfkAusgabe,
				10 , 20 + iMax * iFaktorY, iMax,
				" mit Radius " + iRadius[0] + " gemittelt");

		// werte mitteln
		iGemittelterWert[1] = GemittelteWerte(iAnzahl, iRadius[1]);

		// neu zeichnen
		ZeichneDiagramm(iGemittelterWert[1], gfkAusgabe,
				10 + 110 * iFaktorX, 20 + iMax * iFaktorY, iMax,
				" mit Radius " + iRadius[1] + " gemittelt");

		// werte mitteln
		iGemittelterWert[2] = GemittelteWerte(iAnzahl, iRadius[2]);

		// neu zeichnen
		ZeichneDiagramm(iGemittelterWert[2], gfkAusgabe,
				10 + 110 * iFaktorX, 10, iMax,
				" mit Radius " + iRadius[2] + " gemittelt");

		gfkAusgabe.show("Ausgabe der Diagramme");
	} // end main
} // end Aufgabe23b

Lösung

Zur Lösung dieser Aufgabe wird die Datei unibwm.jar benötigt. Sie kann in der Eclipse Umgebung in den Projektoptionen unter “add external jar” hinzugefügt werden.

import java.util.Scanner; 	// Scanner für die Eingabe von Werten
import unibwm.*;			// Grafik für die Ausgabe der Grafik

public class Aufgabe22
{
	// statische Variable, damit auch die ZeicheFigur-Funktion Zugriff hat:
	static Grafik gfkZeichnung;

	public static void main(String[] args)
	{
		// Variablen Deklaration
		gfkZeichnung = new Grafik();
		Scanner scnEingabe = new Scanner(System.in);
		int iAnzahlHorizontal, iAnzahlVertikal;
			// Abmessungen des Grundobjektes
		double dStartBreite, dStartHoehe;
			// Skalierte Abmessungen des Grundobjektes und aufsummierte Höhe
		double dAktuelleHoehe, dAktuelleBreite, dGesamtHoehe;

		// Variablen Initialisierung
		dGesamtHoehe = 0;
		System.out.print("Bitte horizontale Anzahl eingeben: ");
		iAnzahlHorizontal = scnEingabe.nextInt();
		System.out.print("Bitte Startbreite eingeben: ");
		dStartBreite = scnEingabe.nextDouble();
		System.out.print("Bitte vertikale Anzahl eingeben: ");
		iAnzahlVertikal = scnEingabe.nextInt();
		System.out.print("Bitte Starthöhe eingeben: ");
		dStartHoehe = scnEingabe.nextDouble();

		dAktuelleHoehe = dStartHoehe;
		dAktuelleBreite = dStartBreite;

		for (int i = 0; i < iAnzahlVertikal; ++ i)
		{ // Äußere Schleife für vertikalen Durchlauf
			if (i > 0) // ab dem zweiten Schritt Änderung der Höhe und Breite
			{
				dGesamtHoehe += dStartHoehe / Math.pow(2, i - 1);
				dAktuelleHoehe /= 2.;
				dAktuelleBreite /= 2.;
			} // end if

			for (int j = 0; j < iAnzahlHorizontal * Math.pow(2, i); ++ j)
			{ // innere Schleife für horizontalen Durchlauf
				double x1, y1, x2, y2;
				x1 = dAktuelleBreite * j;
				x2 = dAktuelleBreite * (j + 1);
				y1 = dGesamtHoehe;
				y2 = dGesamtHoehe + dAktuelleHoehe;

				ZeichneFigur(x1, y1, x2, y2);
			} // end for j
		} // end for i

		gfkZeichnung.show("Ausgabe zu Aufgabe 11");
	} // end main

	public static void ZeichneFigur(double dStartX, double dStartY,
			double dEndX, double dEndY)
	{
		gfkZeichnung.addLine(dStartX, dStartY, dStartX, dEndY);
		gfkZeichnung.addLine(dStartX, dEndY, dEndX, dEndY);
		gfkZeichnung.addLine(dEndX, dEndY, dEndX, dStartY);
		gfkZeichnung.addLine(dStartX, dStartY,
				.5 * (dEndX - dStartX) + dStartX, dEndY);
		gfkZeichnung.addLine(.5 * (dEndX - dStartX) + dStartX,
				dEndY, dEndX, dStartY);
	} // end ZeichneFigur
} // end class

Bisher können unsere Programme zwar Dinge tun, zum Beispiel aus übergebenen Parametern ein Ergebnis berechnen, aber das Ergebnis wird dem Nutzer des Programmes nicht mitgeteilt.
Wir wollen nun eine Funktion einführen, mit der Text in der Konsole ausgegeben werden kann.
Die Funktion ist:

print([String]);

Natürlich könnte man die print-Funktion selber programmieren, aber es gibt sie auch schon fertig in der Standardbibliothek von Java.
Sie ist eine Funktion des Objektes out, welches wiederum zu der Klasse System gehört.

Um einen Text auszugeben, schreibt man daher in Java:

System.out.print("hallo ");
System.out.print("welt");

Es erscheint “hallo welt” in der Konsole. Hier wird schon ein Problem der print Methode deutlich: Alles wird in die gleiche Zeile geschrieben. Möchte man eine neue Zeile anfangen, muss man daher ein “\n” in den String einfügen:

System.out.print("hallo \n welt");

führt zu der Ausgabe
hallo
welt

Wenn man sich das \n sparen möchte, kann man statt print() die Methode println benutzen. Die beiden folgenden Befehle führen zu der gleichen Ausgabe:

print("asd \n");

println("asd ");

Mit print und println können auch Inhalte von Variablen ausgegeben werden:

int i1 = 5;
String s1 = "asd";
System.out.print(i1);
System.out.print(s1):

Ausgabe: “5asd”

Die Kombination von verschiedenen Teilen in der Methode print erfolgt mit +.

int i1 = 5;
String s1 = "asd";
System.out.print(i1+" "+s1);

Ausgabe: “5 asd”

Dies ist nicht zu verwechseln mit mathematischen Operationen, denn auch diese können innerhalb der print-Methode durchgeführt werden:

System.out.print(17+23);

führt nicht zur Ausgabe “17+23″ oder “1723″, sondern zu “40″.

Beispiel:
Ausgabe der Zahlen von 0 bis 9 in je einer eigenen Zeile

for (int i = 0; i < 10; ++ i)
	System.out.println(i);

Eingabe von Text in der Konsole

Es gibt kaum ein Programm, das mit festen Werten rechnet. Normalerweise werden Werte vom Benutzer entgegengenommen.
In Java kann dies wie folgt umgesetzt werden:

System.out.println("Texteingabe mit Hilfe von System.in");
String s;
try
{
	BufferedReader brdEingabe
		= new BufferedReader(new InputStreamReader(System.in));
	System.out.print("Text eingeben: ");
	s = brdEingabe.readLine();
	System.out.println("Sie haben eingegeben: "+s);
}
catch (IOException e)
{
	System.out.println("Fehler bei der Ein- oder Ausgabe: "+e);
}

Eine andere Möglichkeit ist es, einen sogenannten Scanner zu benutzen, der Tastatureingaben abscannt:

import java.util.Scanner; 	// Scanner für die Eingabe von Werten

public class ScannerTest
{
	public static void main(String[] args)
	{
		// Variablen Deklaration
		double x1, y1, x2, y2;
		Scanner scnEingabe = new Scanner(System.in);

		// Variablen Initialisierung
		System.out.println("Bitte Koordinaten von P1(x1, y1) und P2 eingeben");
		System.out.print("x1 = ");
		x1 = scnEingabe.nextDouble();
		// Weitere Eingaben und Verarbeitung
	}
}

Ausgabe von Text in eine Textdatei

Um eine Textdatei zu schreiben, gibt es verschiedene Möglichkeiten. Die gebräuchlichste ist es, einen PrintWriter zu benutzen. Im Konstruktor initialisiert man diesen als FileWriter und übergibt ihm dann die zu speichernden Textzeilen. Bei der close() Anweisung wird die Textdatei gespeichert und geschlossen:

System.out.println("Text in Textdatei schreiben");
try
{
	PrintWriter pwtAusgabe = new PrintWriter(new FileWriter ("text.txt"), true);
	pwtAusgabe.println("Erste Zeile");
	pwtAusgabe.println("Zweite Zeile und \n Dritte Zeile");
	pwtAusgabe.close();
}
catch (IOException e)
{
	System.out.println("Fehler bei der Ein- oder Ausgabe: "+e);
}

Die andere Möglichkeit ist es, einen PrintStream zu nutzen:

try
{
	File fleDatei;
	String sDateiname = "data.txt";
	fleDatei = new File(sDateiname);
	PrintStream pstAusgabe = new PrintStream(fleDatei);
	pstAusgabe.println("asd");
	pstAusgabe.println("qwe");
}
catch (FileNotFoundException e)
{
	System.out.println("Datei konnte nich geschrieben werden");
}

Einlesen von Textdateien

Auch hier seien wieder zwei Alternativen genannt. Die erste Möglichkeit ist ein BufferedReader:

System.out.println("Text aus Textdatei lesen");
String sZeile;
try
{
	BufferedReader brdEingabe = new BufferedReader(new FileReader("text.txt"));
	while ((sZeile = brdEingabe.readLine()) != null)
	{
		// sZeile benutzen
		System.out.println(sZeile);
	}
	brdEingabe.close();
}
catch (IOException e)
{
	System.out.println("Fehler bei der Ein- oder Ausgabe: "+e);
}

Die zweite Möglichkeit ein Scanner Objekt (wie schon bei der Eingabe per Tastatur):

try
{
	Vector<Integer> iZahlen;
	File fleDatei = new File("data.txt");
	Scanner scnEingabe = new Scanner(fleDatei);
	while (scnEingabe.hasNextInt())
		iZahlen.add(scnEingabe.nextInt());
}
catch (IOException e)
{
	System.out.println("Fehler bei der Ein- oder Ausgabe: "+e);
}

Es wird zwischen zwei Fehlertypen unterschieden:

• Exception: Ausnahme, behebbarer Fehler
• Error: fataler Fehler

Beispiel:

import java.io.*;

class Fehlerbehandlung
{
	public static void main (String[] args)
	{
		int iZahl = Integer.parseInt(args[0]);
		System.out.println("Übergebene Zahl: "+iZahl);
	}
}

Es können zwei verschiedene Fehler auftreten:

• Das Programm wurde ohne Parameter aufgerufen, das Array args ist daher leer. Der Zugriff auf das erste (fehlende) Element verursacht einen Speicherfehler, nämlich eine “ArrayIndexOutOfBoundsException”
• Der erste übergebene Parameter war keine ganze Zahl sondern eine andere Zeichenkette, z.B. “asd581723″, daher konnte der Parameter nicht in einen Integer umgewandelt werden und es wird eine “NumberFormatException” ausgeworfen

Es gibt nun Fehler, um die sich der Programmierer kümmern sollte und solche, bei denen eine Fehlerbehandlung wenig Sinn macht. Beispiele für letztere:

• “OutOfMemoryError” oder “StackOverflowError”-Wenn kein Speicher mehr zur Verfügung steht, kann der Programmierer da auch nichts dran ändern
• “InternalError” oder “UnknownError”-solche Fehler sind zu allgemein und können daher zur Laufzeit nicht sinnvoll behandelt werden

Beispiele für Fehler, bei denen der Aufwand der Fehlerbehandlung den praktischen Nutzen häufig übersteigt:

• ArithmeticException, NullPointerException
• ArrayIndexOutOfBoundsException, NumberFormatException-Manchmal sollte man auch zu Gunsten der Übersichtlichkeit des Programmtextes darauf vertrauen, dass der Benutzer weiß, wie er mit dem Programm umzugehen hat. Fehler seitens des Users können auch durch eine ausführliche Programmdokumentation verhindert werden.

Die Standard-Ausnahmebehandlung von Java

Wenn sich der Programmierer nicht um Fehler kümmert, tut Java das automatisch. Die Fehlerbehandlung beschränkt sich dabei allerdings darauf, dass der Typ des Fehlers und die Stelle im Programmtext, an dem er aufgetreten ist, ausgegeben wird. Nicht abgefangene Fehler werden also mit einem Programmabbruch bestraft.

Fehlerbehandlung für das obige Beispiel:

class Fehlerbehandlung
{
	public static void main (String[] args)
	{
		try
		{
			int iZahl = Integer.parseInt(args[0]);
			System.out.println("Übergebene Zahl: "+iZahl);
		}
		catch(NumberFormatException e)
		{
			System.out.println("Der Parameter hatte ein ungültiges Format");
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println("Es muss ein Parameter übergeben werden");
		}
	}
}

Um manuell einen Fehler abzufangen, schreibt man alle kritische Befehle in einen try-Block
Wenn es in diesem Block dann zu einem Fehler kommt, wird der catch-Block ausgeführt. Try-Blöcke können auch ineinander verschachtelt sein. Wenn auf verschiedene Ausnahmen unterschiedlich reagiert werden soll, können hinter einem try-Block mehrere catch-Blöcke stehen. Wird in dem try-Block dann kein Fehler ausgeworfen, werden alle catch-Blöcke übersprungen. Kommt es zu einem Fehler, wird der erste passende catch-Block aufgerufen, die nachfolgenden werden übersprungen. Wird kein passender Exception-Handler (catch-Block) gefunden, wird geprüft, ob es einen äußeren try-Block gibt, an den der Fehler weitergeleitet werden kann. Gibt es keinen äußeren mehr, wird die Standardfehlerbehandlung von Java verwendet.
Das obige Beispiel könnte wie folgt geschachtelt programmiert werden:

class Fehlerbehandlung
{
	public static void main (String[] args)
	{
		try
		{
			try
			{
				int iZahl = Integer.parseInt(args[0]);
				System.out.println("Übergebene Zahl: "+iZahl);
			{
			catch(NumberFormatException e)
			{
				System.out.println("Der Parameter hatte ein ungültiges Format");
			}
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println("Es muss ein Parameter übergeben werden");
		}
	}
}

Statt einem catch-Block oder hinter dem letzten catch-Block kann noch ein “finally-Block” stehen, der auf jeden Fall ausgeführt wird, unabhängig davon ob

• keine Ausnahme ausgeworfen wird
• der try-Block durch ein return verlassen wird
• eine Ausnahme ausgeworfen wird, die durch ein catch abgefangen wird
• eine Ausnahme ausgeworfen wird, die nicht durch ein catch abgefangen wird

Die throws-Klausel

Wenn in einer Methode oder Funktion ein Fehler auftreten kann, der nicht durch einen try-catch-Algorithmus abgefangen wird, kann der Fehler auch an die Stelle weitergereicht werden, die die Methode oder Funktion aufgerufen hat. Dazu muss in der Deklaration der Methode hinter der Liste der Parameter noch ein “throws …” stehen, wobei das … eine Liste von Typen ist, die alle Subtypen von “throwable” sind. Beispiel:

public int Eingabe(String s) throws IOException
{...}

Im Programm können wir die Eigenschaften der Klasse einfach ändern, indem wir einen neuen Wert zuweisen.
Die Syntax hierfür ist:

[Objekt].[Eigenschaft] = [neuer Wert]

Beispiel:

Auto Auto1 = new Auto(1993, 95000, "CE-FR-395", "blau", "Tante Hilde");

// [...] Bank ausrauben [...]

// Farbe ändern:
Auto1.sFarbe = "rot";

In einer Klasse können nicht nur Eigenschaften und der Konstruktor, sondern auch weitere Funktionen und Methoden definiert werden.
Wir wollen nun, um Tante Hilde zu helfen, eine “AendereAussehen” Methode definieren, die sowohl das Nummernschild ändert als auch das Auto neu lackiert.

In Java ist das wie folgt möglich:

public class Auto
{
	int iBaujahr;
	int iKilometerstand;
	String sKennzeichen;
	String sFarbe;
	String sBesitzer;
	// weitere Eigenschaften

	// alter Konstruktor:
	public Auto(int iBJ, int iKM, String sKZ, String sFB, String sBes)
	{
		iBaujahr = iBJ;
		iKilometerstand = iKM;
		sKennzeichen = sKZ;
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// neuer, vereinfachter Konstruktor:
	public Auto(String sFB, String sBes)
	{
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// Hilfsmethode zum Ändern des Aussehens des Autos:
	public void AendereAussehen(String "sNeuesKennzeichen", String "sNeueFarbe)
	{
		sKennzeichen = sNeuesKennzeichen;
		sFarbe = sNeueFarbe;
	}
}

Das Programm können wir nun wie folgt schreiben:

Auto Auto1 = new Auto(1993, 95000, "CE-FR-395", "blau", "Tante Hilde");

// [...] Bank ausrauben [...]

// Aussehen ändern:
Auto1.AendereAussehen("HH-FA-231", "grün");

Funktionen in Klassen, public und private

Wir wollen unsere Klasse “Auto” nun an einen anderen Programmierer weitergeben.
Wenn dieser die Klasse einfach benutzt, ohne sie sich vorher genau anzuschauen, kann es sein, dass er Variablen falsche Werte zuweist und so verhindert, dass die Klasse richtig funktioniert.

Zum Beispiel könnte der andere Programmierer denken, man müsse der Variable iBaujahr nicht das Baujahr, sondern das Alter in Jahren zuweisen. Er würde dann schreiben:

Auto Auto1 = new Auto(1993, 95000, "CE-FR-395", "blau", "Tante Hilde");
Auto1.iBaujahr = 12;

Die Klasse kann diesen Irrtum bisher nicht verhindern, da sie keine Kontrolle darüber hat, was für Werte den Variablen zugewiesen werden.
Um dieses Problem zu lösen, verhindern wir einfach, dass den Klassenvariablen direkt Werte zugewiesen werden können. Wir verändern dazu die Deklaration der Variablen wie folgt:

public class Auto
{
	private int iBaujahr;
	private int iKilometerstand;
	private String sKennzeichen;
	private String sFarbe;
	private String sBesitzer;
	// weitere Eigenschaften

	// alter Konstruktor:
	public Auto(int iBJ, int iKM, String sKZ, String sFB, String sBes)
	{
		iBaujahr = iBJ;
		iKilometerstand = iKM;
		sKennzeichen = sKZ;
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// neuer, vereinfachter Konstruktor:
	public Auto(String sFB, String sBes)
	{
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// Hilfsmethode zum Ändern des Aussehens des Autos:
	public void AendereAussehen(String "sNeuesKennzeichen", String "sNeueFarbe)
	{
		sKennzeichen = sNeuesKennzeichen;
		sFarbe = sNeueFarbe;
	}
}

Die Variablen sind nun privat, der Befehl

Auto1.iBaujahr = 12;

führt also zu einem Fehler. Das Problem ist nur, dass nun von außen zwar kein falscher, aber auch kein richtiger Wert mehr zugewiesen werden kann.
Um die Zuweisung eines “richtigen” Wertes wieder zu ermöglichen, brauchen wir nun sogenannte “setter”-Methoden.

Die Klasse ändert sich mit diesen Methoden wie folgt:

public class Auto
{
	private int iBaujahr;
	private int iKilometerstand;
	private String sKennzeichen;
	private String sFarbe;
	private String sBesitzer;
	// weitere Eigenschaften

	// alter Konstruktor:
	public Auto(int iBJ, int iKM, String sKZ, String sFB, String sBes)
	{
		iBaujahr = iBJ;
		iKilometerstand = iKM;
		sKennzeichen = sKZ;
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// neuer, vereinfachter Konstruktor:
	public Auto(String sFB, String sBes)
	{
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// Hilfsmethode zum Ändern des Aussehens des Autos:
	public void AendereAussehen(String "sNeuesKennzeichen", String "sNeueFarbe)
	{
		sKennzeichen = sNeuesKennzeichen;
		sFarbe = sNeueFarbe;
	}

	public void SetBaujahr(int iBJ)
	{
		iBaujahr = iBJ;
	}

	public void SetKilometerstand(int iKM)
	{
		iKilometerstand = iKM;
	}
	// [...] weitere setter-Methoden [...]
}

Um nun das Baujahr des Autos zu ändern, kann man im Programm wie folgt verfahren:

Auto1.SetBaujahr(1993);

Es stellt sich natürlich die Frage, ob man nicht nun einfach dieser Methode “SetBaujahr” genauso den Falschen Wert übergeben könnte wie bei der direkten Zuweisung, denn dann hätte die Methode ja keinen Vorteil.
Dies ist zwar richtig, aber im Gegensatz zu der Wertzuweisung hat die Klasse bei der Zuweisung über die setter-Funktion eine Möglichkeit zur Kontrolle des übergebenen Wertes. Wir können die Methode “SetBaujahr” wie folgt anpassen:

	public void SetBaujahr(int iBJ)
	{
		if(iBJ > 1800)
			iBaujahr = iBJ;
		else
			iBaujahr = 2009-iBJ;
	}

Es ist unwahrscheinlich, dass das Auto vor 1800 gebaut wurde. Wenn also ein Wert übergeben wird, der kleiner ist als 1800, dann wird automatisch der Wert 2009 (aktuelles Jahr)-iBJ zugewiesen. Der andere Programmierer merkt also nicht einmal etwas von seinem Fehler, weil das Programm ihn automatisch berichtigt.

Nun können wir den Variablen des Objektes Auto1 Werte zuweisen. Da die Variablen aber privat sind, können wir danach nicht mehr auf die Variablen zugreifen, wir wissen also nicht mehr, was in den Variablen gespeichert ist.
Zu diesem Zweck brauchen wir “getter”-Funktionen. Dies sind Funktionen ohne übergebene Parameter, die den aktuellen Wert der Variable zurückgeben.

In die Klasse eingebaut:

public class Auto
{
	private int iBaujahr;
	private int iKilometerstand;
	private String sKennzeichen;
	private String sFarbe;
	private String sBesitzer;
	// weitere Eigenschaften

	// alter Konstruktor:
	public Auto(int iBJ, int iKM, String sKZ, String sFB, String sBes)
	{
		iBaujahr = iBJ;
		iKilometerstand = iKM;
		sKennzeichen = sKZ;
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// neuer, vereinfachter Konstruktor:
	public Auto(String sFB, String sBes)
	{
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// Hilfsmethode zum Ändern des Aussehens des Autos:
	public void AendereAussehen(String "sNeuesKennzeichen", String "sNeueFarbe)
	{
		sKennzeichen = sNeuesKennzeichen;
		sFarbe = sNeueFarbe;
	}

	public void SetBaujahr(int iBJ)
	{
		if(iBJ > 1800)
			iBaujahr = iBJ;
		else
			iBaujahr = 2009-iBJ;
	}

	public void SetKilometerstand(int iKM)
	{
		iKilometerstand = iKM;
	}
	// [...] weitere setter-Methoden [...]

	public int GetBaujahr()
	{
		return iBaujahr;
	}

	public int GetKilometerstand()
	{
		return iKilometerstand;
	}
	//
}

Alle Autos haben Gemeinsamkeiten, wie etwa die Fähigkeit zu Fahren.
Andere Eigenschaften sind zwar auch bei allen Autos vorhanden, allerdings in unterschiedlichen Ausprägungen, zum Beispiel das Kennzeichen, das Baujahr oder den Kilometerstand.

In Java können Klassen wie folgt definiert werden:

public class Auto
{
	int iBaujahr;
	int iKilometerstand;
	String Kennzeichen;
	String Farbe;
	String Besitzer;
	// Weitere Eigenschaften
}

Eine Klasse wie “Auto” hat natürlich sehr sehr viele Eigenschaften. Daher muss man sich für ein Programm überlegen, welche Eigenschaften wichtig (relevant) sind. Nur diese sollten in der Klassendefinition aufgeführt werden.

Wir wollen nun eine spezielle Ausprägung der Klasse “Auto” betrachten, nämlich den alten blauen Opel Agila von Tante Hilde. Wir wollen dieses spezielle Auto “Auto1″ nennen.
In Java deklarieren wir das Auto1 wie folgt:

Auto Auto1;

Dies geschieht ganz analog zu der Deklaration einer normalen Variable. Für den Datentyp schreiben wir hier “Auto”, für den Namen “Auto1″.
Genau wie eine Variable eines Grunddatentypes muss auch das Auto vor der Nutzung noch initialisiert werden.
Bei einer ganzzahligen Variable geschah das mit einer einfachen Wertzuweisung:

// Deklaration:
int i1;

// Definition:
i1 = 5;

Beim Auto ist das nicht so einfach. Wir können einem Auto nicht einfach den Wert 5 zuweisen. Wofür sollte dieser auch stehen?
Um dieses Problem zu lösen, braucht die Klasse Auto eine spezielle Methode, nämlich den Konstruktor.
Diese Methode “konstruiert” das Auto mit den als Argumenten übergebenen Angaben.

Die Klasse muss wie folgt erweitert werden:

public class Auto
{
	int iBaujahr;
	int iKilometerstand;
	String sKennzeichen;
	String sFarbe;
	String sBesitzer;
	// weitere Eigenschaften

	// Konstruktor:
	public Auto(int iBJ, int iKM, String sKZ, String sFB, String sBes)
	{
		iBaujahr = iBJ;
		iKilometerstand = iKM;
		sKennzeichen = sKZ;
		sFarbe = sFB;
		sBesitzer = sBes;
	}
}

Das Auto von Tante Hilde hat festgelegte Eigenschaften. Diese möchten wir gleich bei der Initialisierung des Objektes “Auto1″ übergeben werden.

Der Konstruktor wird mit “new” aufgerufen. Wir schreiben also:

// Deklaration
Auto Auto1;

// Initialisierung
Auto1 = new Auto(1993, 95000, "CE-FR-395", "blau", "Tante Hilde");

Analog zu den Variablen können auch Objekte einer Klasse in einem Schritt deklariert und initialisiert werden:

Auto Auto1 = new Auto(1993, 95000, "CE-FR-395", "blau", "Tante Hilde");

Wenn wir von Tante Hildes Auto1 sprechen, wissen wir aber vielleicht gar nicht, wie viele Kilometer es schon gefahren ist oder wie genau das Kennzeichen lautet.
Wir möchten dann bei der Initialisierung zum Beispiel nur den Besitzer und die Farbe zuweisen.
Unser Konstruktor unterstützt dieses Vorhaben nicht, denn einer Funktion oder Methode kann man nicht einfach weniger Parameter übergeben, als in der Methodendefinition gefordert werden.

Die Lösung ist ein zweiter Konstruktor. Wir erweitern die Klasse Auto wie folgt:

public class Auto
{
	int iBaujahr;
	int iKilometerstand;
	String sKennzeichen;
	String sFarbe;
	String sBesitzer;
	// weitere Eigenschaften

	// alter Konstruktor:
	public Auto(int iBJ, int iKM, String sKZ, String sFB, String sBes)
	{
		iBaujahr = iBJ;
		iKilometerstand = iKM;
		sKennzeichen = sKZ;
		sFarbe = sFB;
		sBesitzer = sBes;
	}

	// neuer, vereinfachter Konstruktor:
	public Auto(String sFB, String sBes)
	{
		sFarbe = sFB;
		sBesitzer = sBes;
	}
}

Nun können wir ein “einfachereres” Auto definieren:

Auto Auto1 = new Auto("blau", "Tante Hilde");

Anhand der Anzahl der Argumente und deren Typ wählt die Klasse automatisch den richtigen Konstruktor aus. Es können beliebig viele verschiedene Konstruktoren in der Klasse definiert werden.