Idag
• Ett exempel
• Undantag
• Substitutierbarhet, subtyper, subklasser
• När val av metod beror av typerna hos två objekt
• Lite om överlagring
Ett lite större exempel
Ett gränssnitt Shape med metod area().
Circle, Rectangle, Square, Triangle implementerar Shape.
Exempel, version 2
Notera: för samtliga figurer gäller: arean av en instans ändras aldrig
Idé:
En instansvariabel ’area’. Låt konstruktorn beräkna arean.
(Vi ändrar endast Circle och Rectangle)
Exempel, version 3
Både Circle och Rectangle har en instansvariabel area och en metod area() med exakt samma definition.
Idé:
Skapa en klass ShapeClass. Låt Circle och Rectangle ärva av denna. Placera det som är gemensamt,
instansvariabeln och metoden area(), här.
Exempel, version 4
Vi kan plocka bort några av instansvariablerna för Circle och Rectangle:
diameter, side1, side2 Idé:
Skapa en klass ShapeClass. Låt Circle och Rectangle ärva av denna. Placera det som är gemensamt,
instansvariabeln och metoden area(), här.
Mer ideer
Gör samma sak med Triangle och Square
Låt ShapeClass få en konstruktor med ett argument Då kan instansvariabeln area bli privat
Olika typer av fel
• Kompileringsfel: programkoden följer inte Javas regler
• Exekveringsfel: fel som uppstår när programmet körs och medför att programmet inte kan fortsätta
exekvera.
Exempel: en fil som ska öppnas saknas, använding av referensvariabel som inte refererar något objekt.
• Logiska fel: programmet gör inte det vi väntade oss Exekveringsfel handlar ofta om problem som ligger
Undantag
Engelska: exceptions
Skansholm: exceptionella händelser
Fel som genereras om man försöker öppna en fil som inte finns, dividera med noll, indexera utanför en array osv.
Exempel:
Skriv ett program som 1. ber om ett filnamn 2. öppnar filen
3. läser innehållet
4. gör nåt med innehållet 5. stänger filen
Alla operationer kan gå snett!
Motivation (forts)
En lösning: skriv uttryckliga tester för alla felsituationer h = open_file(...)
if (h.error) {
// hantera felet } else {
// fortsätt att läsa filen }
Om man ska hantera alla felsituationen blir kontrollflödet komplicerat!
Dessutom: det är svårt att testa koden.
Exempel
class A {}
class B extends A {}
class Exce2 {
static void main (String [] arg) { A x = new A();
B y = (B)x;
} }
Exempel, testkörning
$ java Exce2
Exception in thread "main"
java.lang.ClassCastException: A at Exce2.main(Exce2.java:8)
public class ExceNull {
private void method() {}
public static void main(String[] arg) { ExceNull n = null;
n.method();
} }
harpo$ javac ExceNull.java harpo$ java ExceNull
Exception in thread "main" java.lang.NullPointerException at ExceNull.main(ExceNull.java:7)
class A {
public int m(int x) { return 100/x;
} }
public class Exce {
public static void main (String[] arg) { int x = Integer.parseInt(arg[0]);
A a = new A();
int z = a.m(x);
System.out.println("100/"+x+" = "+ z);
}}
Undantag
Frågor om undantag.
• Vilka typer av undantag finns det?
• Hur genereras dem?
• Hur kan man hantera dem?
Typer av undantag
Ett undantag i Java är ett objekt av någon subklass till klassen java.lang.Throwable.
Undantagen kan delas upp i tre grupper:
• Error (Fel)
• Run-time exception
• Checked exception (Kontrollerade undantag)
Typer av undantag (forts)
• Error
Fel som vanligtvis inte kan hanteras, tex att maskinen har slut på minne.
• Run-time exception
‘Vanliga programfel’, tex division med noll, fel i
arrayindexering, fel i typkonvertering, eller access av null-objekt.
• Kontrollerade undantag
Fel som rimligtvis bör hanteras av programmet, till
De viktigaste typerna av undantag
undantag Kontrollerade
....
RunTimeException
....
.... ....
....
Error
Throwable
Exception Object
Typer av undantag (forts)
• Det finns två viktiga klasser som ärver direkt från Throwable,
• java.lang.Error och java.lang.Exception
• java.lang.Exception har en viktig subklass java.lang.RuntimeException
Typer av undantag (forts)
Vilket typ av undantag?
• Ett undantag tillhör gruppen Error
om det tillhör en klass som ärver från java.lang.Error
• Ett undantag tillhör gruppen Run-time Exception om det tillhör en klass som ärver från
java.lang.RuntimeException
Tips: RuntimeException har en konstruktor som tar Throwable som argument. . .
• Alla andra undantag tillhör gruppen Checked Exception.
Exempel: IOException
Att kasta ett undantag
(Generera exceptionella händelser) class Undantag extends Exception {}
class A {
void m() throws Undantag { throw new Undantag();
} }
Kasta undantag (forts)
• Notera: Vi måste deklarera att metoden m kastar undantag (och vilken typ av undantag).
• Detta gäller för alla kontrollerade undantag (checked exceptions).
• Undantag skapas med new (som alla andra objekt).
Hantera undantag
En sats
try { ... } catch (U1 e) {
hantera felet }
catch (U1 e) { hantera felet }
finally { avsluta }
evaluerar ... och fångar alla fel av klassen U1 och U2 och avslutar med att “avsluta”
Exempel: try-catch 2
class Exce6 {
static int div (int x, int y) { int r;
try {
r = x / y;
}
catch (ArithmeticException e) { r = 0;
}
return r;
}
Exempel: try-catch 2 (forts)
static void main (String [] arg) { int x = Integer.parseInt(arg[0]);
int y = Integer.parseInt(arg[1]);
int z = div(x,y);
System.out.println(z);
} }
Exempel: try-catch 2 (körexempel)
harpo$ java Exce6
Exception in thread "main"
java.lang.ArrayIndexOutOfBoundsException: 0 at Exce6.main(Exce6.java:13)
harpo$ java Exce6 100 7 14
harpo$ java Exce6 100 0 0
harpo$
Att passa ett undantag vidare
Vad händer om en metod inte fångar ett kontrollerat undantag?
• För att den saknar en try-sats, eller
• för att try-satsen inte fångar just den typen av undantag.
Undantaget passas vidare till anroparen.
Vilket innebär att anroparen också måste deklarera undantaget.
Finally
När körs finally-delen?
En try kan terminera på tre olika sätt.
1. { ... } terminerar normalt.
2. { ... } kastar ett undantag som hanteras av en catch-klausul.
3. { ... } kastar ett undantag som inte hanteras.
När körs finally-delen? (forts) 1. Normal terminering.
Finally-delen körs efter att { ... } terminerat 2. Undantag kastas och hanteras av en catch.
Finally-delen körs efter att hanteraren körts.
3. Undantag kastas men hanteras inte.
Finally-delen körs före undantaget passas vidare.
Finally-delen körs alltid.
Bra för att (tex) stänga filer.
(Men close() kan kasta en IOException som måste
Undantag, sammanfattning
Alla fel som uppstår vid körning representeras som undantag
Undantag är objekt i någon subklass till Throwable
Undantag kan hanteras (med try-catch) eller deklarertas (med throws)
Vissa undantag (kontrollerade undantag, eller checked exceptions) måste deklareras; om en metod kan kasta ett sådant måste den deklarera det
Subklasser, subtyper, sustutierbarhet
En klass B ärver av en klass A.
Kan objekt av klassen B användas överallt där objekt av typen A förväntas?
Relation klasser-gränssnitt?
Substutition
Ersätt ett objekt ur en typ T med ett objekt ur en subtyp T′ till T.
1. Kompilerar programmet?
2. Kan det köra normalt?
3. Beter det sig “som om” vi arbetade med ett objekt ur supertypen T?
Finns olika definitioner av subtyp. Ibland krävs att att alla 3 ska gälla.
Brott mot S, exempel
class Person {
String beskriv () {
return "Jag är en person";
} }
class Anställd extends Person { String beskriv () {
return "Jag är en anställd";
}
Brott mot S, exempel
class Person {
boolean ärAnställd() { return false;
} }
Brott mot S, exempel
class Anställd extends Person { boolean ärAnställd() {
return true;
} }
Brott mot S, exempel
class Person {
String getAddress() { ...
} ...
}
class Hemlös extends Person { String getAddress () {
throw new UnsupportedOperationException();
} }
Brott mot S, exempel
public class PersonTest { void m (Person P) {
if(P instanceof Anställd) {
System.out.println("Den här har ett jobb");
} } }
Substutitionsprincipen
Substutitionsprincipen: alla tre frågprna med ja besvarade
För att S ska gälla krävs att programmet uppfyller vissa kriterier:
• ingen kod som testar på klasstillhörighet
• arv får aldrig förändra betende
• viss flexibilitet i vad som är betendet hos ett program
Överlagring (overloading) av konstruktorer En klassdefinition...
class Person { int ålder;
String namn;
[...]
}
Java tillåter att en klass har flera konstruktorer.
Person (String n, int å) { ålder = å;
namn = n; }
Person(String n) { ålder = 65;
namn = n; } Person (int å) {
ålder = å;
namn = "Nisse"; }
Person () { ålder = 65;
namn = "Nisse"; }
Överlagring av konstruktorer: Exempel
Person x;
x = new Person ("Kalle", 42);
System.out.println("Personen "
+ x.namn + " är "
+ x.ålder + " år gammal");
x = new Person (42);
System.out.println("Personen "
+ x.namn + " är "
+ x.ålder + " år gammal");
Exempel: Överlagring (forts) x = new Person ();
System.out.println("Personen "
+ x.namn + " är "
+ x.ålder + " år gammal");
Körexempel
Personen Kalle är 42 år gammal Personen Nisse är 42 år gammal Personen Nisse är 65 år gammal
överlagring av metoder class Ut {
static void skriv(String s) {
System.out.println("En sträng:"+ s); } static void skriv(int x) {
System.out.println("Ett heltal:"+ x); } static void skriv(double d) {
System.out.println("Ett flyttal:"+ d); } static void skriv(int [] a) {
Överlagring av metoder: exempel Ut.skriv(42);
Ut.skriv("eh");
Ut.skriv(3.14);
Ut.skriv( new int[] {5,6,7});
Körexempel:
Ett heltal:42 En sträng:eh Ett flyttal:3.14
En array:[I@73d6a5
class B {
public void m2(int i) {
System.out.println("B-m2");
} }
class C extends B {
public void m2(char i) {
System.out.println("C-m2");
} }
public class J172 {
public static void main (String[] arg) { B b = new B();
b.m2(42);
C c = new C();
c.m2(42);
c.m2((char) 42);
} }
harpo$ java J172 B-m2
B-m2
