Java: Föreläsning 2

• wait, notify för trådar
• equals, clone, toString m.fl.
• C++ har ingen Object-klass, så objekthierarkin i ett C++-program är en skog och inte bara ett träd! (Egentligen ännu värre, pga multipelt arv.)

Skydda data och metoder - 1

• public: alla kan komma åt dem
• protected: subklasser, och andra klasser i samma paket
• private: bara klassen själv
• default: paketåtkomst. Andra klasser i samma paket!

Tips

• Gör oftast instansvariabler privata
• Ha så få instansvariabler som möjligt
• Gör interna hjälpmetoder privata (de ska ju inte anropas utifrån)
• Man kan ha public-variabler (jämför struct i C)

Dålig felhantering i C

Vad kan gå fel i följande C-program, unsafe-hello.c?

#include <stdio.h>

int main(int argc, char* argv[]) {
    printf("Hello, world!\n");
    return 0;
} /* main */

En säkrare version, safe-hello.c:

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char* argv[]) {
    if (printf("Hello, world!\n") != 14) {
        fprintf(stderr,
		"Kunde inte skriva hela texten!\n");
        return EXIT_FAILURE;
    }
    if (fclose(stdout) != 0) {
        fprintf(stderr,
		"Kunde inte skriva till filen!\n");
        return EXIT_FAILURE;
    }
    return 0;
} /* main */

Bra felhantering i Java: Undantag ("exceptions")

Liknelse: När man använder sig av ett subsystem (till exempel att man anropar metoden tvätta i objektet t av klassen Tvättmaskin) ska man inte behöva stå och kontrollera att den verkligen tvättar. I stället låter man den tvätta bäst den vill, och om något går fel kommer det ett undantagsobjekt flygande och träffar en i huvudet.

• Programmeraren måste skriva kod som fångar undantagen.
• (För vissa typer av undantag. Andra kan lämnas "ofångade".)
• Ofångade undatag avslutar programmet med ett felmeddelande.
• Inga tysta fel, som man inte märker förrän nästa år när man tittar på filen som skulle ha skrivits!

Livet blir lättare med undantag

En bra sak med undantag är att de kan kastas "genom" en metod. Även om den metoden inte gör någon felhantering alls, kan det kastade undantaget skickas vidare till anroparen. Studera detta utdrag ur ett Java-program som inte innehåller någon felhantering (dinner-1/Dinner.java):

    private void drinkCoffee() {
        // Drick kaffe
    }

    private void eatDinner() {
        eatAppetizer();
        eatMainCourse();
        eatDessert();
        drinkCoffee();
    }

    public static void main(String[] args) {
        Dinner d = new Dinner();
        d.eatDinner();
        System.out.println("Ätandet klart.");
        System.out.println("(Kanske i alla fall.)");
    } // main

    private boolean drinkCoffee() {
        if (coffeePot == null)
            return false;
        else {
            // Drick kaffe. Det gick bra:
            return true;
        }
    }

    private boolean eatDinner() {
        if (eatAppetizer() == false)
            return false;
        if (eatMainCourse() == false)
            return false;
        if (eatDessert() == false)
            return false;
        if (drinkCoffee() == false)
            return false;
        return true;
    }

    public static void main(String[] args) {
        Dinner d = new Dinner();
        if (d.eatDinner() == false)
            System.out.println("Ätandet misslyckades!");
    } // main

Bättre med undantag! Utdrag ur dinner-3/Dinner.java:

    private void drinkCoffee() throws NoCoffeePotException {
        if (coffeePot == null)
            throw new NoCoffeePotException();
        else {
            // Drick kaffe
        }
    }

    private void eatDinner() throws NoCoffeePotException {
        eatAppetizer();
        eatMainCourse();
        eatDessert();
        drinkCoffee();
    }

    public static void main(String[] args) {
        Dinner d = new Dinner();
        try {
            d.eatDinner();
        }
        catch (NoCoffeePotException e) {
            System.out.println("Ingen kaffepanna!");
        }
        catch (Exception e) {
            System.out.println("Något annat gick snett.");
        }
    } // main

class NoCoffeePotException extends Exception {

} // class NoCoffeePotException

Inbyggda undantag

Checked exceptions ("kontrollerade undantag") måste fångas med try och catch, eller deklareras med throws. Unchecked exceptions ("okontrollerade undantag") behöver inte.

• Okontrollerade:
  • Error: System- och JVM-fel
    (exempel: ClassFormatError, OutOfMemoryError)
  • RunTimeException: Mer hanterbara fel
    (exempel: ArithmeticException, NullPointerException)
• Kontrollerade:
  • Exception: "Normala" fel
    (exempel: FileNotFoundException, UnknownHostException)

Exempel på program med undantag: DivZeroException

• Lagra ett tal
• Loopa runt och läs ett nytt tal
• Udda tal: addera
• Jämt tal: dividera
• Fortsätt vid division med 0 mha egen undantagshantering
• Avsluta kontrollerat vid fel inmatning

import java.io.BufferedReader;
import java.io.InputStreamReader;

// Att kastas vid division med noll
class DivZeroException extends Exception {

} // class DivZeroException

class Number {
    public Number(int tal) {
        this.num = tal;
    } // Number

    public void addera(int tal) {
        this.num = this.num + tal;
    } // addera

    public void dividera(int tal)
      throws DivZeroException {
        if (tal == 0)
            throw new DivZeroException();
        this.num = this.num / tal;
    } // dividera

    public int varde() {
        return this.num;
    }

    private int num = 0;

    public static void main(String[] args) {
      BufferedReader kbd_reader =
          new BufferedReader(
                 new InputStreamReader(System.in));
      int tal = 1;
      String buf;
      Number num = new Number(14);

      System.out.println("Startar med: " + num.varde());
      System.out.println("Adderar udda tal.");
      System.out.println("Dividerar jämna tal." );

      try {
        while (tal != 99) {
            System.out.print("Ge ett tal (99 avslutar): ");
            buf = kbd_reader.readLine();
            tal = Integer.parseInt(buf);
            if (tal % 2 == 1)
                num.addera(tal);
            else
                try {
                    num.dividera(tal);
                }
                catch (DivZeroException e) {
                    System.out.println("Ojdå! Division med 0.");
                }

            System.out.println("Nu är talet: " + num.varde());
        } // while
      } // try
      catch (Exception e) {
          System.out.println("Fel inmatning / tangentbordsfel");
      } // catch
    } // main
} // class Number

pc105-246.oru.se DivZeroException > javac Number.java
pc105-246.oru.se DivZeroException > java Number
Startar med: 14
Adderar udda tal.
Dividerar jämna tal.
Ge ett tal (99 avslutar): 13
Nu är talet: 27
Ge ett tal (99 avslutar): 4
Nu är talet: 6
Ge ett tal (99 avslutar): Bengt
Fel inmatning / tangentbordsfel
pc105-246.oru.se DivZeroException > 

Gränssnitt (interface)

• En specifikation, inte en implementation.
• Exempel: Ett sånt här objekt ska ha en funktion fnorble, som...
• En klass kan implementera ett gränssnitt.
• En klass kan implementera flera gränssnitt. Som multipelt arv!
• Liknar en abstrakt klass, men implementerar ingenting.
• Nackdel: Man vet inte vad man får.

Exempel: Integralprogram

• Ett funktionsgränssnitt (interface Function) specar hur mattefunktioner ska skrivas...
• ...nämligen som en klass med funktionerna f, derivatan och anti_derivatan ("primitiv funktion").
• En integrallösare ska lösa integraler.
• Den vet att funktioner ser ut som gränssnittet Function.

public interface Funktion {
    public float f(float x);
    public float derivatan(float x);
    public float anti_derivatan(float x);
} // interface Funktion

public class Sinus implements Funktion {

    public float f(float x) {
	return (float)Math.sin(x);
    }

    public float derivatan(float x) {
	return (float)Math.cos(x);
    }

    public float anti_derivatan(float x) {
	return -(float)Math.cos(x);
    }
} // class Sinus

public class Polynom implements Funktion {
    public float f(float x) {
	return x*x - x + 3.0f;
    }

    public float derivatan(float x) {
	return 2.0f*x - 1.0f;
    }

    public float anti_derivatan(float x) {
	return x*x*x/3.0f - x*x/2.0f + 3.0f*x;
    }
} // Polynom

public class Integral {
    public float integralen(Funktion fkn, float a, float b) {
	return fkn.anti_derivatan(b) - fkn.anti_derivatan(a);
    }
} // Integral

import java.io.*;

public class IntegralTest {
    public static void main(String[] args) {
	Sinus sinfunktion = new Sinus();
	Polynom polynom = new Polynom();
	Integral losare = new Integral();
	System.out.println("Sinusintegral: " +
			   losare.integralen(sinfunktion, 1.0f, 3.0f));
	System.out.println("Polynomintegral: " +
			   losare.integralen(polynom, 1.0f, 3.0f));
    } // main
} // IntegralTest

Sinusintegral: 1.5302948
Polynomintegral: 10.666667

Paket i Java

• Modulindelning med hjälp av katalogstrukturen
• Grupperar klasser, objekt, variabler m.m.
• Exempel:
  • java.io - in-/utmatning
    • Exempel: java.io.BufferedReader
    • Importera med import java.io.*;
    • Sen räcker det att skriva BufferedReader
  • java.lang - för javaspråket självt
    • Exempel: java.lang.Object
    • importeras automatiskt
  • java.awt - grafiska gränssnitt (gamla, dåliga)
  • javax.swing - grafiska gränssnitt (nya, bra)

Paketering av integral

• Skapa katalog:
  c:\eget\java\ht01\folex\integralpaket
• Lägg all källkod i katalogen
• Skriv package integralpaket; överst i varje fil
• Ta bort public på alla klasser (ger: endast paketåtkomst)
• Ange paket vid körning:
  java integralpaket.IntegralTest

package integralpaket;

class Polynom implements Funktion {
    public float f(float x) {
	return x*x - x + 3.0f;
    }

    public float derivatan(float x) {
	return 2.0f*x - 1.0f;
    }

    public float anti_derivatan(float x) {
	return x*x*x/3.0f - x*x/2.0f + 3.0f*x;
    }
} // Polynom

pc105-246.oru.se fo-02 > pwd
/home/padrone/tmp/java/forelasningar/fo-02
pc105-246.oru.se fo-02 > echo $CLASSPATH
/home/padrone/tmp/java/forelasningar/fo-02
pc105-246.oru.se fo-02 > java integralpaket.IntegralTest
Sinusintegral: 1.5302948
Polynomintegral: 10.666667
pc105-246.oru.se fo-02 > 

Nästa gång: Applet