Download Report

Objektorienterad modellering och design (EDAF25)
Grafer
Föreläsning 2
Traversering
Agenda
Djupet först
Grafer
Vid djupet-först-traversering av en graf utgår man från en startnod och
följer varje väg så långt det går innan man backar tillbaka och följer nästa
väg.
Djupetförsttraversering
Inför Lab 2
Objektorienterad modellering
Övning modellering
Introduktion till designprinciper
UML – klassdiagram
Man använder rekursion för att gå igenom noderna.
Man markerar noder som besökta när man har besökt dem, varje nod
har ett booleskt attribut visited som används för detta.
Att göra denna och nästa vecka:
Laboration 2 redovisas på fredag!
Man kan endast komma till noder som kan nås från startnoden. Det
betyder att om grafen har flera komponenter så kommer man bara att
besöka alla noder i startnodens komponent.
Läs Martin 7-9,11
Egen laboration Eclipse/UML
EDAF25 (F2)
VT 2015
1 / 43
EDAF25 (F2)
Grafer
Grafer
Traversering – Djupet först
Traversering – Djupet först
dfs(v)
markera v som besökt
för alla bågar e som utgår från noden v:
w = noden i andra änden av e
om inte w är besökt
dfs(w);
dfs(g)
markera alla noder i grafen som obesökta
for varje nod v i grafen
om v inte är besökt
dfs(v)
A
B
VT 2015
A
B
D
D
C
C
E
I vilken ordning besöks noderna om
startnoden är B?
Vad behöver vi lägga till för att samtliga
noder ska besökas?
EDAF25 (F2)
Noder
A:
B:
C:
E
För att besöka samtliga noder i en graf med
djupet-först-teknik kan vi behöva göra
upprepade anrop av metoden dfs(v) ovan
tills alla noder är besökta.
Bågar
D
A
C
A
D
D:
E:
2 / 43
Noder
A:
B:
C:
VT 2015
3 / 43
EDAF25 (F2)
A
C
A
D
D:
E:
C
Bågar
D
C
VT 2015
4 / 43
Grafer
Grafer
Laboration 2
Laboration 2 – D5. Generalisering
Sammanhängande graf
En oriktad graf är sammanhängade om det för varje par av noder gäller att
det finns en väg (en serie bågar) mellan noderna.
public class VertexVisitor<V,E> {
public boolean isDone() {
return false;
}
D1 Undersök om en oriktad graf är
sammanhängande.
D2 Räkna antalet komponenter i en graf.
D3 Avgör om det finns en väg mellan två
noder.
En klass med följande metoder införs:
A
public void preVisit(Graph.Vertex<V,E> v) {}
B
D
public void postVisit(Graph.Vertex<V,E> v){}
}
C
E
D4 Hitta en väg mellan två noder.
D5 Generalisering
EDAF25 (F2)
VT 2015
5 / 43
EDAF25 (F2)
Grafer
Grafer
Laboration 2 – D5. Generalisering
Laboration 2 – D5. Generalisering
Den generella varianten av djupetförstgenomgång utgående från en nod v
får en extra parameter av typen VertexVisitor:
public
static <V,E> void dfs(Graph.Vertex<V,E> v,
VertexVisitor<V,E> visitor) {
if (visitor.isDone()) {
return;
}
visitor.preVisit(v);
v.visit();
for (Graph.Edge<V,E> e : v) {
Graph.Vertex<V,E> w = e.destination();
if (!w.isVisited()) {
dfs(w,visitor);
}
}
visitor.postVisit(v);
VT 2015
6 / 43
VT 2015
8 / 43
VertexVisitor
DFS
+ dfs(Vertex, VertexVisitor)
+ isDone(): boolean
+ preVisit(Vertex)
+ postVisit(Vertex)
PathVisitor
- done: boolean
- destination: Vertex
+ isDone(): boolean
+ preVisit(Vertex)
CountingVisitor
- count: int
+ preVisit(Vertex)
}
EDAF25 (F2)
VT 2015
7 / 43
EDAF25 (F2)
Introduktion till objektorienterad modellering
Introduktion till objektorienterad modellering
Vid en motorcykeltävling registreras start- och sluttider på filer med
följande format.
StartNr
1
2
3
Starttid
12.00.00
12.01.00
12.02.00
StartNr
3
2
1
Sluttid
13.05.06
13.15.16
13.23.34
Ett förslag ...
public class Time implements Comparable<Time> {
private int sec;
public Time(String time)
public Time difference(Time other)
public int compareTo(Time other)
public String toString()
}
Ett sorteringsprogram läser filerna och producerar följande resultat.
StartNr
1
2
3
Totaltid
1.23.34
1.14.16
1.03.06
Starttid
12.00.00
12.01.00
12.02.00
Sluttid
13.23.34
13.15.16
13.05.06
Konstruera en klass, Time, som kan användas för att representera tider i
start- och resultatlistor. Vilka attribut och metoder behövs?
EDAF25 (F2)
VT 2015
VT 2015
10 / 43
VT 2015
12 / 43
Introduktion till objektorienterad modellering
Punkt med dålig design ...
... och sträcka
public class Point {
private double x, y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public void setX(double x) {
this.x = x;
}
public double getX() {
return x;
}
// omissions
EDAF25 (F2)
EDAF25 (F2)
9 / 43
Introduktion till objektorienterad modellering
public class Segment {
private Point point0, point1;
// Standard constructor omitted
public double length() {
double dx = point1.getX()--point0.getX();
double dy = point1.getY()--point0.getY();
return Math.sqrt(dx*dx+dy*dy);
}
}
VT 2015
11 / 43
EDAF25 (F2)
OMD – Designprinciper
OMD – Designprinciper
Redesign
Redesign
public class Point {
private double x, y;
public double distanceTo(Point other) {
double dx = this.x - other.x;
double dy = this.y - other.y;
return Math.sqrt(dx*dx + dy*dy);
}
}
EDAF25 (F2)
public class Segment {
private Point point0, point1;
public double length() {
return point1.distanceTo(point0);
}
}
VT 2015
13 / 43
OMD – Designprinciper
EDAF25 (F2)
VT 2015
14 / 43
VT 2015
16 / 43
OMD – Designprinciper
2D-punkter
Nytt krav: Vi vill kunna implementera 3D-punkter också.
public class Point2d implements Point {
private double x, y;
public double distanceTo(Point point) {
Point2d other = (Point2d) point;
double dx = this.x - other.x;
double dy = this.y - other.y;
return Math.sqrt(dx*dx + dy*dy);
}
}
Vi skapar ett interface.
public interface Point {
public double distanceTo(Point other);
}
EDAF25 (F2)
VT 2015
15 / 43
EDAF25 (F2)
OMD – Designprinciper
OMD – Designprinciper
Anderssons lokalitetsprincip, ALP
3D-punkter
Operationer skall implementeras där operanderna är lättast tillgängliga.
Recept: Undvik getters!
public class Point3d implements Point {
private double x, y, z;
public double distanceTo(Point point) {
Point3d other = (Point3d) point;
double dx = this.x - other.x;
double dy = this.y - other.y;
double dz = this.z - other.z;
return Math.sqrt(dx*dx + dy*dy + dz*dz);
}
}
Övergripande designprinciper
Abstraktion
Modularisering
Integritet – skydda representationen
Lokalisering – implementera operationer där operanderna finns
EDAF25 (F2)
VT 2015
EDAF25 (F2)
17 / 43
God praxis enligt Martin
VT 2015
18 / 43
VT 2015
20 / 43
Utvecklingsmodellen
Agile
Designa ej på spekulation, dvs för saker som kanske inte kommer att
användas.
Agile Software Development
Gör om designen när den inte längre är bra. Refaktorisering.
Agile betyder vig, rörlig, kvick eller anpasslig.
Optimera inte programmet förrän du konstaterat att det är
nödvändigt.
På svenska vanligen: lättrörlig
Producera ingen dokumentation om den inte behövs genast och är
betydelsefull. (Martin)
EDAF25 (F2)
VT 2015
19 / 43
EDAF25 (F2)
Utvecklingsmodellen
Objekorienterad modellering
Extreme Programming, XP
Aktivitet
Berättelser (stories)
Aritmetiska uttryck
Korta iterationer
Ett aritmetiskt uttryck är antingen ett tal eller en addition, multiplikation,
subtraktion eller division av två uttryck.
kontinuerlig integrering
XP
Testa först (TDD)
Ett exempel på en Agil praxis. Det
finns många!
Parprogrammering
Modellera aritmetiska uttryck med substantivmetoden och förse klasserna
med en metod som beräknar uttryckets värde.
Enkel design
Ständig refaktorisering
EDAF25 (F2)
VT 2015
21 / 43
EDAF25 (F2)
VT 2015
Objekorienterad modellering
Objekorienterad modellering
Aktivitet
Aktivitet
22 / 43
Aritmetiska uttryck - lösning
Aritmetiska uttryck - lösning
Ett aritmetiskt uttryck är antingen ett tal eller en addition, multiplikation,
subtraktion eller division av två uttryck.
Ett aritmetiskt uttryck är antingen ett tal eller en addition, multiplikation,
subtraktion eller division av två uttryck.
EDAF25 (F2)
Expr
Num
Add
Sub
Mul
Div
Expr
Num
VT 2015
23 / 43
EDAF25 (F2)
Add
Sub
Mul
Div
VT 2015
24 / 43
Objekorienterad modellering
Objekorienterad modellering
Aktivitet
Aktivitet
Aritmetiska uttryck - lösning
Aritmetiska uttryck - lösning
Ett aritmetiskt uttryck är antingen ett tal eller en addition, multiplikation,
subtraktion eller division av två uttryck.
Ett aritmetiskt uttryck är antingen ett tal eller en addition, multiplikation,
subtraktion eller division av två uttryck.
<<interface>>
<<interface>>
Expr
Expr
Num
Add
EDAF25 (F2)
Sub
+value():int
Mul
Div
VT 2015
Num
25 / 43
Add
Sub
Mul
Div
EDAF25 (F2)
Objekorienterad modellering
Objekorienterad modellering
Aktivitet
Aktivitet – Expr och Num
VT 2015
26 / 43
VT 2015
28 / 43
Aritmetiska uttryck - lösning
Ett aritmetiskt uttryck är antingen ett tal eller en addition, multiplikation,
subtraktion eller division av två uttryck.
EDAF25 (F2)
VT 2015
27 / 43
«interface»
public interface Expr {
public int value();
}
+ value(): int
public class Num implements Expr {
private int value;
public int value() {
return value;
}
}
- value: int
EDAF25 (F2)
Expr
Num
Objekorienterad modellering
Objekorienterad modellering
Aktivitet – Num
Aktivitet – Implementera Add
Num behöver en standardkonstruerare
«interface»
public class Num implements Expr {
private int value;
public Num(int value) {
this.value = value;
}
public int value() {
return value;
}
}
«interface»
Expr
Expr
+ value(): int
public class Add implements Expr {
private Expr expr1, expr2;
public int value() {
return expr1.value() + expr2.value();
}
}
Num
- value: int
+ value(): int
Add
- expr1: Expr
- expr2: Expr
+ Num(int)
Standardkonstruerare visas ej i fortsättningen.
EDAF25 (F2)
VT 2015
EDAF25 (F2)
29 / 43
Objekorienterad modellering
Objekorienterad modellering
Aktivitet – Expr Exempel
UML
Uttryck
1
1+2
1+2*3
1*2+3
Instans av Expr
new Num(1);
new Add(new Num(1),new Num(2));
new Add(new Num(1), new Mul(new Num(2), new Num(3));
new Add(new Mul(new Num(1), new Num(2)), new Num(3));
VT 2015
30 / 43
VT 2015
32 / 43
Unified Modeling Language
Visuell representation av ett system under utveckling
Booch, Rumbaugh, Jacobson, slutet av 90–talet
Många läroböcker och verktyg
Industristandard
EDAF25 (F2)
VT 2015
31 / 43
EDAF25 (F2)
Objekorienterad modellering
Objekorienterad modellering
UML
UML – klassdiagram
Diagram
Funktionell modell – Användningsfall (Use cases)
Statisk modell – Klassdiagram, Objektdiagram
Dynamisk modell – Sekvensdiagram, Tillståndsdiagram
EDAF25 (F2)
VT 2015
33 / 43
EDAF25 (F2)
UML – klassdiagram
UML – klassdiagram
Klasser
Abstrakta klasser och gränssnitt
EDAF25 (F2)
VT 2015
35 / 43
EDAF25 (F2)
VT 2015
34 / 43
VT 2015
36 / 43
UML – klassdiagram
UML – klassdiagram
Generalisering
Realisering
EDAF25 (F2)
VT 2015
37 / 43
EDAF25 (F2)
UML – klassdiagram
UML – klassdiagram
Parametriserade klasser
Associationer
EDAF25 (F2)
VT 2015
39 / 43
EDAF25 (F2)
VT 2015
38 / 43
VT 2015
40 / 43
UML – klassdiagram
UML – klassdiagram
Aggregering och sammansättning
Aggregering och sammansättning
Kommer ni ihåg ...
public class Add implements Expr {
private Expr expr1, expr2;
public int value() {
return expr1.value() + expr2.value();
}
}
EDAF25 (F2)
VT 2015
41 / 43
VT 2015
43 / 43
UML – klassdiagram
Beroende
EDAF25 (F2)
EDAF25 (F2)
«interface»
Expr
+ value(): int
Add
- expr1: Expr
- expr2: Expr
VT 2015
42 / 43