Javakurs/Übungsaufgaben/Canvas/Musterloesung

Hinweis: Die Musterlösung kann von eurer Lösung abweichen, da es immer mehrere Varianten gibt ein Problem zu lösen. Im Zweifelsfall Fragt einen Tutor.

Lösung: Point3D.java

public class Point3D {

	private double x, y, z;

	public Point3D(double x, double y, double z) {
		this.x = x;
		this.y = y;
		this.z = z;
	}

	@Override
	public String toString() {
		return "(" + x + ", " + y + ", " + z + ")";
	}

	public void changeCoordinates(double newX, double newY, double newZ) {
		this.x = newX;
		this.y = newY;
		this.z = newZ;
	}

	public double calcDistance(Point3D other) {
		return Math.sqrt(Math.pow(other.x - this.x, 2) + Math.pow(other.y - this.y, 2) + Math.pow(other.z - this.z, 2));
	}
}

Lösung: Sphere.java

public class Sphere {

	private Point3D orign;

	private double radius;

	public Sphere(Point3D orign, double radius) {
		super();
		this.orign = orign;
		this.radius = radius;
	}

	public void changeOrign(Point3D newOrign) {
		this.orign = newOrign;
	}

	public void changeRadius(double newRadius) {
		this.radius = newRadius;
	}

	@Override
	public String toString() {
		return "Sphere(orign: " + orign.toString() + ", radius: " + radius
				+ ")";
	}

	public double calcVolume() {
		return (4.0 / 3.0) * Math.PI * Math.pow(radius, 3);
	}

	public double calcSurfaceArea() {
		return 4.0 * Math.PI * Math.pow(radius, 2);
	}
}

Lösung: Canvas.java

import java.util.Arrays;

/**
 * Klasse für die Zeichenoberfläche inklusive Einstiegspunkt in das Programm.
 * @author Jonas
 *
 */
public class Canvas {

	private Point3D[] points;
	private Sphere[] spheres;

	private int sphereCount;
	private int pointCount;

	public Canvas() {
		points = new Point3D[3];
		spheres = new Sphere[3];
		sphereCount = 0;
		pointCount = 0;
	}

	/**
	 * Fügt einen neuen Punkt zu dieser Zeichenoberfläche hinzu. Erweitert wenn
	 * nötig das Array.
	 */
	public void addPoint3D(Point3D point) {
		points[pointCount] = point;
		pointCount++;

		if (pointCount >= points.length) {
			// Das Array ist voll.
			// Da in Java die Länge eines Arrays nicht mehr nachträglich
			// geändert werden kann, wird pohier eine Hilfsfunktion aus der Java
			// API benutzt, um eine größere Kopie dieses Arrays zu erzeugen.

			// In addSphere eine alternative Implementierung.
			points = Arrays.copyOf(points, points.length + 3);
		}
	}

	/**
	 * Fügt eine neue Kugel zu dieser Zeichenoberfläche hinzu. Erweitert wenn
	 * nötig das Array.
	 */
	public void addSphere(Sphere sphere) {
		spheres[sphereCount] = sphere;
		sphereCount++;

		if (sphereCount >= spheres.length) {
			// Das Array ist voll.
			Sphere[] newSpheres = new Sphere[spheres.length + 3];
			for (int i = 0; i < spheres.length; i++) {
				newSpheres[i] = spheres[i];
			}

			spheres = newSpheres;
		}
	}

	/**
	 * Berechnet das Gesamtvolumen aller Kugeln dieser Zeichenoberfläche.
	 */
	public double calcTotalVolume() {
		double result = 0;
		for (int i = 0; i < spheres.length; i++) {
			if (spheres[i] != null) {
				result += spheres[i].calcVolume();
			}
		}
		return result;
	}

	/**
	 * Berechnet die Gesamtoberfläche aller Kugeln dieser Zeichenoberfläche.
	 * 
	 * @return
	 */
	public double calcTotalSurfaceArea() {
		double result = 0;
		for (int i = 0; i < spheres.length; i++) {
			if (spheres[i] != null) {
				result += spheres[i].calcSurfaceArea();
			}
		}
		return result;
	}

	@Override
	public String toString() {
		String result = "";
		for (int i = 0; i < points.length; i++) {
			// Wenn ein Array initialisiert wird, werden alle Felder mit null
			// belegt. Deswegen an dieser Stelle die Überprüfung, ob im Array an
			// der Stelle i ein Element abgelegt ist.
			if (points[i] != null) {
				result += points[i].toString() + "\n";
			}
		}
		// Eine andere Form von for-Schleife zur Iteration über ein Array
		// Wird wie folgt gelesen:
		// Für jede Sphere s aus dem Array spheres...
		for (Sphere s : spheres) {
			if (s != null) {
				// füge sie der String-Repräsentation hinzu.
				result += s.toString() + "\n";
			}
		}
		return result;
	}

	/**
	 * Einstiegspunkt in das Programm
	 */
	public static void main(String[] args) {
		System.out.println("Erzeuge einen neuen Punkt...");
		Point3D p1 = new Point3D(3, 7, 3);
		System.out.println("Neuer Punkt p1: " + p1.toString());
		System.out.println("Die Koordinaten werden nun geändert");
		p1.changeCoordinates(2, 1, 2);
		System.out.println("Geänderter Punkt p1: " + p1.toString());
		System.out.println("Erzeue einen zweiten Punkt...");
		Point3D p2 = new Point3D(2, 2, 3);
		System.out.println("Neuer Punkt p2: " + p2.toString());
		System.out
				.println("Distanz zwischen p1 und p2: " + p1.calcDistance(p2));
		System.out.println("Erzeuge eine neue Kugel...");
		Sphere s1 = new Sphere(p1, 2);
		System.out.println("Neue Kugel s1: " + s1.toString());
		System.out.println("Oberfläche der Kugel: " + s1.calcSurfaceArea());
		System.out.println("Volumen der Kugel: " + s1.calcVolume());

		System.out.println("Erzeuge eine neue Zeichenoberfläche...");
		Canvas c = new Canvas();
		System.out.println("Füge 4 Punkte der Zeichenoberfläche hinzu...");
		c.addPoint3D(p1);
		c.addPoint3D(p2);
		c.addPoint3D(new Point3D(1, 2, 3));
		c.addPoint3D(new Point3D(4, 9, -2));
		System.out.println("Aktueller Inhalt der Zeichenoberfläche:");
		System.out.println(c.toString());

		System.out.println("Füge s1 viermal zur Zeichenoberfläche hinzu...");
		c.addSphere(s1);
		c.addSphere(s1);
		c.addSphere(s1);
		c.addSphere(s1);
		System.out.println("Gesamtoberfläche der Zeichenoberfläche: "
				+ c.calcTotalSurfaceArea());
		System.out.println("Gesamtvolumen der Zeichenoberfläche: "
				+ c.calcTotalVolume());
	}
}

Kommentare

Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)