enum Type

[HazlNut]

Servus!

Habe folgendes Problem:
Habe die Aufgabe bekommen, eine Klasse Triangle zu schreiben, mit der man ein Dreieck erzeugen kann, welches sofort dessen Typ ausgibt. Unser Prof hat uns die nocht nicht implementierten Methoden zur Verfügung gestellt und wir sollen diese so bearbeiten wie es vorgeben ist.
Folgendermaßen habe ich bis jetzt angefangen:

public static void main(String[] args) {
		System.out.println(createTriangle(args));
	}

CreatTriangle sieht so aus:

public static Triangle createTriangle(String[] sides) throws IllegalArgumentException {
		return new Triangle(Integer.parseInt(sides[0]), 
				Integer.parseInt(sides[1]),
				Integer.parseInt(sides[2]));
	}

Konstruktor:

public Triangle(int a, int b, int c) {
		this.a = a;
		this.b = b;
		this.c = c;
		
		this.checkIntegrity();
		this.determineType();
	}

checkIntegrity:

private void checkIntegrity() throws IllegalArgumentException {
		if(a<=0 || b<=0 || c<=0){
			throw new IllegalArgumentException("Die Seiten eines Dreiecks dürfen nicht <= 0 sein!");
		}
		if(a+b<c || b+c<a || a+c<b){
			throw new IllegalArgumentException("Die Summe 2er Seiten darf nicht kleiner als die 3. Seite sein!");
		}
	}

Nun Liegt mein Problem bei "determineType". Vorm Konstruktor wurde folgendes gemacht:

public static enum TYPE {
		ISOSCELES /* gleichschenklig */, EQUILATERAL /* gleichseitig */, SCALENE /* ungleichseitig */
	};

	private final int a, b, c;
	private TYPE type;

Ich schätze mal in determineType wird dann wohl gefordert, dass wir das enum abarbeiten. Allerdings habe ich das noch nie wirklich benutzt und habe absolut keine Ahnung wie ich damit nun die Variable Typ auf Gleichschenklig, gleichseitig oder ungleichseitig stelle.

Würde mich sehr über kleine Denkanstöße und Hilfen freuen!

LG
HazlNut

 

[Phash]

type stellst du auf ISOSCELES indem du es zuweist:

type = TYPE.ISOCELES;

fertig.

Das machst du dort, wo du type setzen möchtest, wahrscheinlich in "createTriangle"

 

[stg]

Na, wenn alle drei Seiten gleich lang sind, dann setzt du den

type

auf

EQUILATERAL

, bei zwei gleichen Seiten dann auf ....

Die Zuweisung funktioniert wie bei normalen Variablen auch. z.B.

this.type = TYPE.EQUILATERAL;

[OT]
...und schon wieder war jemand anderes schneller
[/OT]

 

[HazlNut]

Alles klar vielen Dank!

Hab gedacht, man muss es mit einem Switch abarbeiten

 

[BonKeri]

könntest du mir die Lösung dieser Aufgabe zeigen HazlNut, das wäre super lieb von dir

MfG

 

[HazlNut]

Ja klar! Hier nochmal der ganze, bereits abgenommene Code:

package triangle;

public class Triangle {

	public static enum TYPE {
		ISOSCELES /* gleichschenklig */, EQUILATERAL /* gleichseitig */, SCALENE /* ungleichseitig */
	};

	private final int a, b, c;
	private TYPE type;

	/**
	 * @param a
	 *            length of side a of the triangle
	 * @param b
	 *            length of side b of the triangle
	 * @param c
	 *            length of side c of the triangle
	 */
	public Triangle(int a, int b, int c) {
		this.a = a;
		this.b = b;
		this.c = c;
		
		this.checkIntegrity();
		this.determineType();
	}

	/**
	 * Checks the integrity of the triangle
	 * 
	 * @throws {@link IllegalArgumentException} if the side lengths do not describe a triangle
	 */
	private void checkIntegrity() throws IllegalArgumentException {
		if(a<=0 || b<=0 || c<=0){
			throw new IllegalArgumentException("Die Seiten eines Dreiecks dürfen nicht <= 0 sein!");
		}
		
		if(((long)a+(long)b)<=c		|| ((long)b+(long)c)<=a || ((long)a+(long)c)<=b){
			throw new IllegalArgumentException("Die Summe 2er Seiten darf nicht kleiner als die 3. Seite sein!");
		}
	}

	/**
	 * Determines the type of a triangle, depending on its side lengths
	 * 
	 * @return EQUILATERAL => all sides are equal in length, ISOSCELES => two
	 *         sides are equal in length, SCALENE => all sides are unequal
	 */
	private void determineType() {
		if(a == b && a == c){
			this.type = TYPE.EQUILATERAL;
		}else if(a == b || b == c || a == c){
			this.type = TYPE.ISOSCELES;
		}else{
			this.type = TYPE.SCALENE;
		}
	}

	public TYPE getType() {
		return this.type;
	}

	/**
	 * Creates new triangle instance
	 * 
	 * @param sides
	 *            string array which contains the length of all three sides of
	 *            the triangle
	 * @return new triangle instance
	 * 
	 * @throws {@link IllegalArgumentException} if the sides array does not represent a triangle
	 */
	public static Triangle createTriangle(String[] sides) throws IllegalArgumentException {
		if(sides.length != 3){
			throw new IllegalArgumentException();
		}
		return new Triangle(Integer.parseInt(sides[0]), 
				Integer.parseInt(sides[1]),
				Integer.parseInt(sides[2]));
	}

	/**
	 * Returns the {@link TYPE} of the triangle in german
	 * 
	 * @return german string representation for the given {@link TYPE}:
	 *         EQUILATERAL => "gleichseitig", ISOSCELES => "gleichschenklig",
	 *         SCALENE => "ungleichseitig"
	 */
	@Override
	public String toString() {
		switch (this.getType()) {
		case EQUILATERAL:
			return "gleichseitig";
		case ISOSCELES:
			return "gleichschenklig";
		case SCALENE:
			return "ungleichseitig";
		default:
			return "ungültig";
		}

	}

	public static void main(String[] args) {
		System.out.println(createTriangle(args));
	}

}

 

[ceving]

public static enum TYPE {
		ISOSCELES /* gleichschenklig */, EQUILATERAL /* gleichseitig */, SCALENE /* ungleichseitig */
	};

	private final int a, b, c;
	private TYPE type;

Ich schätze mal in determineType wird dann wohl gefordert, dass wir das enum abarbeiten. Allerdings habe ich das noch nie wirklich benutzt und habe absolut keine Ahnung wie ich damit nun die Variable Typ auf Gleichschenklig, gleichseitig oder ungleichseitig stelle.

type = TYPE.ISOSCELES;