Review Übungsblatt 1

• Ergebnisse
  • Mittel: 8,0 Punkte
  • Median: 8,5 Punkte
• Häufige Fehler

A.2 A Million Squared

// Aufgabe
int a = 1000000;
int b = 1000000;
int c = a * b;

// Falsch: Overflow, da a*b mit int-Genauigkeit berechnet wird
long c = a * b;
// Falsch: Explizitere Variante von obigem Code
long c = (long) (a * b);

// Korrekt: a*b wird mit long-Genauigkeit berechnet wird
long c = (long) a * b;

• Arithmetische Operationen arbeiten meist mit „größtem“ beteiligten Datentyp
• Ausnahme: Ganzzahldatentypen kleiner int (dazu gleich mehr)

A.4 Bytes You

// Aufgabe
byte a = 24;
byte b = 7;
byte c = a * b;

// Falsch: Behebt den ursprünglichen Fehler, führt aber zu Overflow
byte c = (byte) (a * b);

// Korrekt
int c = a * b;

• Fehler: Typfehler (int to byte)
  • Ergebnis der Muliplikation ist int (siehe JLS §5.6.2)
  • Unerlaubte Assignment Conversion (siehe JLS §5.2)
  • Compile-Fehler unabhängig von tatsächlichem Overflow

A.5 To Be Precise…

// Aufgabe: ergibt true
1E300 * 1E20 == 1 / 0.0;

// Aufgeschlüsselt
double a = 1E300 * 1E20;    // Infinity
double b = 1 / 0.0;         // Infinity

// Eine gute Lösung
Math.abs(a - b) < 0.1E-5

// Aufgeschlüsselt
double c = a - b;           // NaN
double d = Math.abs(c);     // NaN
boolean e = d < 0.1E-5      // false

• Zur Erinnerung: xEn entspricht x⋅10ⁿ
• Was wenn man so 1/0.0 mit sich selbst vergleicht?

B.2 Mantellinie

Math.pow(Math.pow(coneX.height, 2) + Math.pow(coneX.base.radius, 2), 0.5);
// vs.
Math.sqrt(Math.pow(coneX.height, 2) + Math.pow(coneX.base.radius, 2));
// vs.
Math.hypot(coneX.height, coneX.base.radius);

• Für Klassen aus java.lang ist kein import nötig!
• Math.hypot() ist kürzer und behandelt Overflows

B.2 Basis von Cone

// So nicht
class Cone {
    double base;
    // ...
}
coneX.base = circleX.area;
// ...
coneX.surface = coneX.base + Math.PI * circleX.radius * s;

// So wird’s gemacht
class Cone {
    Circle base;
    // ...
}
coneX.base = circleX;
// ...
coneX.surface = coneX.base.area + Math.PI * coneX.base.radius * s;

• Die Basis muss vom Typ Circle sein
• Zugriff auf Kreisattribute entsprechend anpassen

Naming Conventions

// So nicht
class Cone {
    double surfacearea;
    // ...
}

// So wird’s gemacht
class Cone {
    double surfaceArea;
    // ...
}

• lowerCamelCase für lokale Variablen, Methoden, Attribute: surfaceArea
• UpperCamelCase für Klassen, Interfaces, Enums: RobotUnicorn

Stilbruch

// So nicht
coneX.surface=coneX.base.area+coneX.base.radius*Math.PI⤦
    *Math.sqrt(Math.pow(coneX.base.radius,2.0)+Math.pow(coneX.height,2.0));

// So auch nicht
coneX.surfaceLine=Math.sqrt(Math.pow(coneX.base.radius,2.0)⤦
    +Math.pow(coneX.height,2.0));
coneX.surface=coneX.base.area+coneX.base.radius*Math.PI*surfaceLine;

// So wird’s gemacht
double s = Math.hypot(coneX.height, coneX.base.radius);
coneX.surface = coneX.base.area + coneX.base.radius * Math.PI * s;

• Lange Zeilen vermeiden
  • z.B. Zwischenergebnisse in lokalen Variablen
  • keine Attribute für Zwischenergebnisse einführen
• Spaces vor und nach Operatoren
• Tabs oder Spaces für Einrückung

Kommentare

// Weniger sinnvolles Kommentar
class Cone {
    // Attribute deklarieren
    Circle base;
    double area;
    double volume;
    double surfacearea;
}

// Sinnvolle Kommentare
class Cone {
    Circle base;
    double height;          // in cm
    double surface;         // in cm²
    double volume;          // in cm³
}

• Kommentare nur bei echtem Mehrwert verwenden
• Lieber Helper-Methoden statt kommentierte Abschnitte

Conditionals

• if, else und else if
• switch und case

if

// Syntax
if (Bedingung) {
    Rumpf
}

// Example (x is any given int)
if (x != 42) {
    System.out.println("Die Antwort ist falsch");
}

• if wertet einen boolschen Ausdruck aus
• Der Code im Rumpf wird nur ausgeführt wenn die Bedingung true ist

else

// x is any given int
if (x == 5) {
    System.out.println("x ist 5");
} else {
    System.out.println("x ist nicht 5");
}

• Der Rumpf eines else wird ausgeführt wenn die vorigen Bedingungen false sind

else if

// x is any given int
if (x == 5) {
    System.out.println("x ist 5");
} else if (x > 5) {
    System.out.println("x ist größer als 5");
} else {
    System.out.println("x ist kleiner als 5");
}

• So kann man mehrere if-Statements „aneinander hängen“

switch und case

// syntax
switch (Variable oder Ausdruck) {
    case WERT1:
        // do something
        break;
    case WERT2:
        // do something else
        break;
    default:
        // do something in (no)case
}

• switch und case in der Java Documentation

switch und case

// x is any given int
switch (x) {
    case 42:
        System.out.println("x is _the_ answer");
    case 1337:
        System.out.println("x is leet");
        break;
    default:
        System.out.println("x is boring");
}

Was wird ausgegeben wenn x == 42?

Wird das break weggelassen oder vergessen wird der nächste Codeblock auch ausgeführt

Checkstyle

• Was ist es?
• Kann ich es essen?
• Woher bekomme ich es?
• Was tut es?
• Wie benutze ich es?
• Anwendungsbeispiel

Was ist Checkstyle?

Checkstyle ist ein in der Softwareentwicklung verwendetes Werkzeug für die statische Code-Analyse zur Prüfung des Programmierstils von Java Sourcecode.

Artikel zu Checkstyle im Programmieren Wiki

Kann ich es Essen?

Nein.

Woher bekomme ich Checkstyle?

• Programm von sourceforge.net!
• Regelsatz von der Vorlesungsseite
  • Achtung: wird potentiell bei jedem Übungsblatt aktualisiert

Was prüft Checkstyle?

• Maximal 120 Zeichen pro Zeile
• Maximal eine Klasse pro Datei
• Maximal 80 Zeilen Code pro Methode
• Whitespaces
• Naming Conventions
• uvm.

Wie benutze ich Checkstyle?

java -jar <CS-JAR> -c <REGELSATZ> <JAVA-DATEI>

• <CS-JAR>:Pfad zur checkstyle-X.X-all.jar
• <REGELSATZ>: Pfad zum Regelsatz (.xml)
• <JAVA-DATEI>: Pfad zur zu testenden Datei (.java)