Fragen zu einer Javaprogrammierübung

[RECKLESS]

Hallo, ich bin ein blutiger Anfänger im Bereich programmieren mit Java.
und hab ne übungsaufgabe bekommen die ich absolut nicht zu lösen weiß

(a) Erstellen Sie eine Klassenmethode, die zu einer übergebenen positiven oberen Schranke MAX alle
Zahlentripel (a, b, c), die die folgenden Eigenschaften erfüllen, zurückgibt:
3 3 2 a + b = c , mit 0 < a £ b, c < MAX natürliche Zahlen
Die ersten solchen Tripel sind z. B. (1, 2, 3); (2, 2, 4); (4, 8, 24); ...

würde mich über hilfe riesig freuen!

gruß RECKLESS

 

[RECKLESS]

So sieht mein Ansatz aus. nun wollte ich ma hören was davon richtig ist und was man verbessern koennte

public class Tripel
{   
    // RuntimeException Texte
    private static final String RTE_FALSCHER_PARAMETER = "Falscher Uebergabeparameter: Typ ";
    private static final String RTE_ERWARTET = " erwartet.";
    private static final String RTE_FALSCHER_TYP = "Falscher Aufruf: das Element des Tripels hat den Typ ";
    
    public enum TripelElementTyp
    {
        LONG,
        DOUBLE;
    }
    
    // Instanzattribute
    long lA, lB, lC;
    double dA, dB, dC;
    TripelElementTyp typ1, typ2, typ3;
    
    /**
     * Standard-Konstruktor für Objekte der Klasse Tripel; zum Speichern von drei Double-Werten
     */
    public Tripel()
    {
        this.typ1 = TripelElementTyp.DOUBLE;
        this.typ2 = TripelElementTyp.DOUBLE;
        this.typ3 = TripelElementTyp.DOUBLE;
    }

    /**
     * Konstruktor für Objekte der Klasse Tripel; zum Speichern von drei Werten beliebigen Typs
     */
    public Tripel(TripelElementTyp typ1, TripelElementTyp typ2, TripelElementTyp typ3)
    {
        this.typ1 = typ1;
        this.typ2 = typ2;
        this.typ3 = typ3;
    }

    /**
     * Konstruktor für Objekte der Klasse Tripel; zum Speichern von drei Long Werten mit direkter Angabe der Werte
     */
    public Tripel(long a, long b, long c)
    {
        this.typ1 = TripelElementTyp.LONG;
        this.typ2 = TripelElementTyp.LONG;
        this.typ3 = TripelElementTyp.LONG;
        this.lA = a;
        this.lB = b;
        this.lC = c;
    }

    /**
     * Konstruktor für Objekte der Klasse Tripel; zum Speichern von drei Double Werten mit direkter Angabe der Werte
     */
    public Tripel(double a, double b, double c)
    {
        this.typ1 = TripelElementTyp.DOUBLE;
        this.typ2 = TripelElementTyp.DOUBLE;
        this.typ3 = TripelElementTyp.DOUBLE;
        this.dA = a;
        this.dB = b;
        this.dC = c;
    }

    /**
     * Setzt das erste Element des Tripels vom Typ Long
     */
    public void setErstesElement(long a)
    {
        if (this.typ1 != TripelElementTyp.LONG)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_PARAMETER).append(this.typ1).append(RTE_ERWARTET).toString());
        this.lA = a;
    }
    
    /**
     * Setzt das erste Element des Tripels vom Typ Double
     */
    public void setErstesElement(double a)
    {
        if (this.typ1 != TripelElementTyp.DOUBLE)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_PARAMETER).append(this.typ1).append(RTE_ERWARTET).toString());
        this.dA = a;
    }
    
    /**
     * Setzt das zweite Element des Tripels vom Typ Long
     */
    public void setZweitesElement(long b)
    {
        if (this.typ2 != TripelElementTyp.LONG)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_PARAMETER).append(this.typ2).append(RTE_ERWARTET).toString());
        this.lB = b;
    }
    
    /**
     * Setzt das zweite Element des Tripels vom Typ Double
     */
    public void setZweitesElement(double b)
    {
        if (this.typ2 != TripelElementTyp.DOUBLE)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_PARAMETER).append(this.typ2).append(RTE_ERWARTET).toString());
        this.dB = b;
    }
    
    /**
     * Setzt das dritte Element des Tripels vom Typ Long
     */
    public void setDrittesElement(long c)
    {
        if (this.typ3 != TripelElementTyp.LONG)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_PARAMETER).append(this.typ3).append(RTE_ERWARTET).toString());
        this.lC = c;
    }
    
    /**
     * Setzt das dritte Element des Tripels vom Typ Double
     */
    public void setDrittesElement(double c)
    {
        if (this.typ3 != TripelElementTyp.DOUBLE)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_PARAMETER).append(this.typ3).append(RTE_ERWARTET).toString());
        this.dC = c;
    }
    
    /**
     * Gibt das erste Element zurueck
     */
    public long getErstesElementLong()
    {
        if (this.typ1 != TripelElementTyp.LONG)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_TYP).append(this.typ1).toString());
        return lA;
    }
    
    /**
     * Gibt das erste Element zurueck
     */
    public double getErstesElementDouble()
    {
        if (this.typ1 != TripelElementTyp.DOUBLE)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_TYP).append(this.typ1).toString());
        return dA;
    }

    /**
     * Gibt das zweite Element zurueck
     */
    public long getZweitesElementLong()
    {
        if (this.typ2 != TripelElementTyp.LONG)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_TYP).append(this.typ2).toString());
        return lB;
    }
    
    /**
     * Gibt das zweite Element zurueck
     */
    public double getZweitesElementDouble()
    {
        if (this.typ2 != TripelElementTyp.DOUBLE)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_TYP).append(this.typ2).toString());
        return dB;
    }

    /**
     * Gibt das dritte Element zurueck
     */
    public long getDrittesElementLong()
    {
        if (this.typ3 != TripelElementTyp.LONG)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_TYP).append(this.typ3).toString());
        return lC;
    }
    
    /**
     * Gibt das dritte Element zurueck
     */
    public double getDrittesElementDouble()
    {
        if (this.typ3 != TripelElementTyp.DOUBLE)
            throw new RuntimeException(new StringBuffer().append(RTE_FALSCHER_TYP).append(this.typ3).toString());
        return dC;
    }
}

Noctarius: Bitte Java-Tags nutzen!

 

[Marco13]

Wozu dieser Aufwand mit den unterschiedlichen Typen und Exceptions und so?

Und dass man Strings auch mit "x" + "y" verknüpfen kann, weißt du vermutlich...

Wenn es zur Aufgabenstellung an sich Fragen gibt, solltest du diese "Bedingungen" nochmal ... richtig und verständlich aufschreiben....

 

[Noctarius]

Falls du schon auf Generics gestoßen bist, schau sie dir mal genauer an, falls du davon noch nichts gehört hast solltest du dir diese mal genauer anschauen ;-)

 

[Andreas29]

Hi,

wenn ich die Aufgabe so lese, hat das in meinen Augen wenig mit Generics zu tun. Der Datentyp sollte hier meiner Meinung nach einfach int sein und dann kann man beliebig und sehr bequem damit rechnen.
Ich denke, dass sich das über eine geschickte Schleife regeln lassen sollte. Was du brauchst, sind eigentlich zwei oder drei Variablen, von denen einen Rückwärts vom aktuellen max bis eins zählt und eine vorwärts von 1 bis aktuelles max. Damit könntest du dann Ausgabe wie:
(1 3 4)
(2 2 4)
(3 1 4)
usw. erzeugen und wärst, soweit ich die Aufgabe verstanden habe, fertig. Eventuell braucht man auch zwei Schleifen, eine, die von 2 bis max zählt und eine, die die beiden zu addierenden Werte hoch und runter zählt, das habe ich noch nicht bis zu ende durchdacht und kann es momentan leider auch nicht testen.
@Marco13:
Es ist richtig, dass man Strings mit + verknüpfen kann, ich habe aber mal gelernt, dass das für den Compiler aufwändiger sei als der StringBuilder / StringBuffer. Ist da noch was dran oder optimiert der Compiler das weg? Würde mich mal sehr interessieren. Würde mich da nur ungern auf irgendwelche Decompiler verlassen... Vielleicht wäre hier auch String.format() noch eine Idee.

Grüße,
Andy

 

[Landei]

Es ist richtig, dass man Strings mit + verknüpfen kann, ich habe aber mal gelernt, dass das für den Compiler aufwändiger sei als der StringBuilder / StringBuffer. Ist da noch was dran oder optimiert der Compiler das weg? Würde mich mal sehr interessieren. Würde mich da nur ungern auf irgendwelche Decompiler verlassen... Vielleicht wäre hier auch String.format() noch eine Idee.

In einer Zeile wird das wegoptimiert, also "x" + 1 + "y" in new StringBuilder("x").append(1).append("y").toString() übersetzt.

Was man tunlichst vermeiden sollte, sind String-Additionen in Schleifen:

//schlecht
String s = "";
for(int i = 0; i < 100; i++) {
  s += i;
)

//gut
StringBuilder sb = new StringBuilder();
for(int i = 0; i < 100; i++) {
  sb.append(i);
)
String s = sb.toString();

 

[Marco13]

Es ist richtig, dass man Strings mit + verknüpfen kann, ich habe aber mal gelernt, dass das für den Compiler aufwändiger sei als der StringBuilder / StringBuffer. Ist da noch was dran oder optimiert der Compiler das weg? Würde mich mal sehr interessieren. Würde mich da nur ungern auf irgendwelche Decompiler verlassen... Vielleicht wäre hier auch String.format() noch eine Idee.

Für den Compiler ist es vielleicht aufwändiger: DER muss das ja ins entsprechende StringBuilder-Konstrukt übersetzen Aber bei des Auführung des Programms gilt das, was Landei gesagt hat. Und selbst wenn es langsamer wäre: Bei so wenigen +en lohnt es sich wohl kaum, dafür den StringBuilder auszupacken, und speziell in diesem Fall ist es besonders egal: Wenn eine Exception fliegt, ist's mit Performance und Ausführungzeit sowieso dahin

 

[Ein Keks]

das is ja als würde man zum jagen ne atombombe benutzen....
so wie ich die aufgabe verstehe ist die relativ trivial (natürliche Zahlen -> int, long kein double)
ich würd die ungefähr so lösen:

public class TupelFactory {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		for (Tupel tupel : createTupelList(10)) {
			System.out.println(tupel);
		}
	}

	public static List<Tupel> createTupelList(int max) {
		List<Tupel> tupel = new ArrayList<Tupel>();
		for (int a = 1; a < max; a++) {
			for (int b = 1; b < max; b++) {
				for (int c = 1; c < max; c++) {
					if (a + b == c) {
						tupel.add(new Tupel(a, b, c));
					}
				}
			}
		}
		return tupel;
	}
}

class Tupel {

	private int a;
        private int b;
        private int c;

	public Tupel(int a, int b, int c) {
		this.a = a;
		this.b = b;
		this.c = c;
	}

	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}

	public int getB() {
		return b;
	}

	public void setB(int b) {
		this.b = b;
	}

	public int getC() {
		return c;
	}

	public void setC(int c) {
		this.c = c;
	}

	@Override
	public String toString() {
		return "{"+a+","+b+","+c+"}";
	}
}

 

[Noctarius]

wenn ich die Aufgabe so lese, hat das in meinen Augen wenig mit Generics zu tun. Der Datentyp sollte hier meiner Meinung nach einfach int sein und dann kann man beliebig und sehr bequem damit rechnen.

Meinte auch nicht direkt zur Aufgabenstellung, sondern zu dem, was er bisher programmiert hat.