Sammenhæng mellem begreber
 |
public class Heltal {
int tal;
void set( int t ) {
tal = t;
}
int get() {
return tal;
}
}
public class Heltal {
private int tal;
public void set( int t ) {
tal = t;
}
public int get() {
return tal;
}
}
Heltals-objekt
 |
Definition: Interface Et objekts interface er samlingen af signaturer for de metoder som er tilgængelige udefra. |
1. set- og get-metoder
tal er umiddelbart indkapslet, men er den reelt beskyttet?
Selve instansvariablen er private, men metoderne set og get giver den samme adgang som hvis tal havde været public. tal er derfor i realiteten ikke indkapslet.
2. Instantiering
public class Heltal {
private int tal;
public void set( int t ) {
tal = t;
}
public int get() {
return tal;
}
}
public class Main {
public static void main( String[] argv ) {
Heltal vorTal = new Heltal();
vorTal.set( 5 );
System.out.println( vorTal.get() );
}
}
5
int[] vorTabel = new int[10];
<reference>.<metodekald>
Det er det vi gør i kaldet:
vorTal.set( 5 );
<reference> var vorTal og <metodekald> var set( 5 ).
Ligesom vi med arrays kunne have flere referencer til det samme array, kan vi have flere referencer til det samme objekt. Vi kunne f.eks. ændre anvendelsen til:
Heltal vorTal = new Heltal();
Heltal osseVor;
osseVor = vorTal;
vorTal.set( 5 );
System.out.println( osseVor.get() );
5
To referencer til samme objekt
 |
3. Konstruktorer
Vores Heltal-objekt havde brug for at vi initialiserede det med en passende værdi. Derfor må den første anvendelse forventes at være et kald af set-metoden. Det er ikke specielt for klassen Heltal, langt de fleste objekter i denne verden har brug for at "starte op" og gøre sig klar til tilværelsen i et objektsystem. Derfor har man en speciel metode-lignendende indretning der kaldes en konstruktor. Den er ikke en metode, men den ligner. Lad os se eksemplet igen, med en passende konstruktor:
public class Heltal {
private int tal;
public Heltal( int t ) {
tal = t;
}
public void set( int t ) {
tal = t;
}
public int get() {
return tal;
}
}
public class Main {
public static void main( String[] argv ) {
Heltal vorTal = new Heltal( 5 );
System.out.println( vorTal.get() );
}
}
5
Den metodelignende indretning i starten af klassen adskiller sig kun syntaktisk fra en metode ved at den ikke har nogen retur-type, den kan nemlig ikke returnere noget. En anden speciel syntaktisk egenskab ved konstruktoren er at den altid skal hedde det samme som klassen.
Semantisk er forskellene fra en metode større. En konstruktor kan ikke kaldes direkte. Den kaldes indirekte ved instantieringen som det ses i anvendelsen. Ved at anføre 5 i instantieringen bliver konstruktoren kaldt med denne parameter. Datakernen bliver initialiseret og der "returneres". Rent syntaktisk ligner instantieringen efter new et kald af konstruktoren og der er ikke noget problem i at tænke på den som sådan.
Instantieringen er den eneste situation hvor konstruktoren kan blive udført, derefter træder den fuldstændig ud af billedet, som en "navlestreng" der har udtjent sit formål.
3.1 Kode-redundans
Redundans (eng.: redundancy, dk.: overflødighed) betyder generelt at noget forekommer flere gange/steder. Kode-redundans er når flere dele af kildeteksten gør det samme, at de derfor i virkeligheden er den samme kode.
Af hensyn til vedligeholdelsen af programmer er det generelt en fordel, at kode som gør det samme kun forekommer ét sted, at man undgår koderedundans! Koderedundans bevirker nemlig, at man skal foretage eventuelle ændringer flere steder. Ud over at det forøger arbejdsbyrden ved vedligeholdensen, er det også en potentiel kilde til fejl - husker man at få ændret alle steder?
I vores eksempel sætter vi to steder direkte tal til en værdi: I konstruktoren og i set-metoden. Vi kunne nøjes med at have denne kode i set-metoden, og i konstruktoren kalde denne metode:
public Heltal( int t ) {
set( t );
}
public void set( int t ) {
tal = t;
}
Nu står tildelingen kun ét sted, og vi skal nu kun huske at rette ét sted; hvis vi vil ændre på hvad der sker ved tildelingen.
Eksemplet er meget simpel, og kun lidt er vundet, men det illustrerer princippet og det kunne have været meget mere. Jeg har set projekter hvor op til en side var gentaget flere steder i programmet.
4. class Tidspunkt
4.1 Design-overvejelser
4.2 Implementation
I det følgende vil vi starte med datakernen, dernæst konstruktorerne og endelig operationerne. Det er en naturlig rækkefølge, ikke alene ved implementationen men også ved opbygningen af et mere detaljeret design end det vi har lavet ovenfor.
4.2.1 Datakernen
Datakernen skal indeholde en tidsangivelse. Vi vil afgrænse det til et vist antal timer, minutter og sekunder, og dermed bliver tidspunktet et klokkeslæt.
public class Tidspunkt {
private int totalSekunder;
...
}
Vi indkapsler som altid instansvariablen med private, for at beskytte den mod direkte tilgang udefra.
4.2.2 toString
Inden vi går videre til konstruktorerne og metoderne, vil vi først lave en meget nyttig metode. Metoden anvendes primært til test-formål; hvor den giver os mulighed for på en simpel måde at observere objektet efterhånden som vi arbejder med det. Denne metode er en toString-metode der skal returnere en tekststreng som beskriver objektets tilstand. I vores eksempel bliver det selve tidspunktet, som tekststreng, der skal returneres:
public int getTimer() {
return totalSekunder / 3600;
}
public int getMinutter() {
/*
* tager først modulus med TIME for at få fjernet timerne, og dermed kun
* have minutter og sekunder regnet sammen til totalsekunder.
*
* dernæst tages division med MINUT for at få hele minutter.
*/
return ( totalSekunder % 3600 ) / 60;
}
public int getSekunder() {
return totalSekunder % 60;
}
public class Tidspunkt {
private static final int MINUT = 60;
private static final int TIME = 60 * MINUT;
...
public int getTimer() {
return totalSekunder / TIME;
}
public int getMinutter() {
return ( totalSekunder % TIME ) / MINUT;
}
public int getSekunder() {
return totalSekunder % MINUT;
}
...
}
public class Tidspunkt {
...
public String toString() {
return "[" + getTimer() + ":" + getMinutter() + ":" + getSekunder() + "]";
}
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt();
System.out.println( vorTid.toString() );
}
}
[0:0:0]
Vi har her valgt at toString sætter kantede paranteser omkring beskrivelsen af objektets tilstand. Det er en konvention jeg selv har indført, da den hjælper til at identificere teksten som en tilstand i udskrifter.
Vi ser her at timer, minutter og sekunder fra starten er 0; hvilket skyldes at totalSekunder er 0, selvom vi ikke noget sted har tildelt totalSekunder denne værdi. Det skyldes at instans-variable, der er integers, automatisk initialiseres til 0 ved instantieringen. Det er en egenskab ved instans-variable som vi normalt ikke vil udnytte, da det gør programmet vanskeligere at læse: "Er det meningen at de skal være 0, eller har vi glemt at sætte dem til noget?". Hvis vi selv sætter dem til 0, er der ikke noget at være i tvivl om - vi har kommunikeret et klart budskab til læseren!
// PRE: x tilhører [0:99]
private String twoDigits( int x ) {
if ( x >= 10 ) // er allerede to-cifret
return "" + x;
else
return "0" + x;
}
public class Tidspunkt {
...
public String toString() {
return "[" + getTimer() + ":" +
twoDigits( getMinutter() ) + ":" +
twoDigits( getSekunder() ) + "]";
}
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt();
System.out.println( vorTid.toString() );
}
}
[0:00:00]
4.2.3 Fra timer, minutter og sekunder til totalsekunder.
private int getTotalSekunder( int timer, int minutter, int sekunder ) {
return timer * TIME + minutter * MINUT + sekunder;
}
public void set( int timer, int minutter, int sekunder ) {
totalSekunder = getTotalSekunder( timer, minutter, sekunder );
}
public void setTimer( int timer ) {
set( timer, getMinutter(), getSekunder() );
}
public void setMinutter( int minutter ) {
set( getTimer(), minutter, getSekunder() );
}
public void setSekunder( int sekunder ) {
set( getTimer(), getMinutter(), sekunder );
}
4.2.4 Konstruktorer
public class Tidspunkt {
...
private int totalSekunder;
public Tidspunkt( int timer, int minutter, int sekunder ) {
set( timer, minutter, sekunder );
}
...
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt( 12, 30, 0 );
System.out.println( vorTid.toString() );
}
}
[12:30:00]
4.2.4.1 Overloading af konstruktorer
Man kan udemærket have flere konstruktorer, og det er mere reglen end undtagelsen.
Det gøres ved at overloade konstruktorer på samme måde som det gøres med metoder.
Lad os lave endnu en konstruktor, der kan bruges når man ikke ønsker at angive et antal timer, minutter og sekunder, men i stedet ønsker at tidspunktet skal initialiseres til 0, dvs. 0:00:00:
public class Tidspunkt {
...
private int totalSekunder;
public Tidspunkt() {
totalSekunder = 0;
}
public Tidspunkt( int timer, int minutter, int sekunder ) {
set( timer, minutter, sekunder );
}
...
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt();
System.out.println( vorTid.toString() );
}
}
[0:00:00]
Overloading fungerer efter helt de samme mekanismer som overloading af metoder, idet der vælges den konstruktor som matcher de aktuelle parametres antal og typer.
Man bemærker at totalSekunder eksplicit bliver sat til 0, selvom det ellers sker automatisk. Det er gjort for at tydeliggøre at det er hensigten - for at gøre programmet lettere at læse/forstå. Som tidligere nævnt øger det læsbarheden at man initialiserer alle instans-variable i konstruktoren, i stedet for at falde tilbage på den automatiske initialisering til 0.
Hvis man sammenligner de to konstruktorer observer man en vis lighed. De sætter begge totalSekunder til en værdi. Konstruktoren med de tre parametre gør det indirekte ved at kalde set-metoden, mens konstruktoren uden parametre gør det direkte ved assignment. Selv om ligheden er meget begrænset, vil vi bruge den som et eksempel på hvordan man kan fjerne kode-redundans - et fænomen der ofte er mere omfattende i konstruktorer end det ses her.
public Tidspunkt() {
set( 0, 0, 0 );
}
For helt at fjerne redundansen skal vi have den ene konstruktor til at kalde den anden. Kan man det? Ja!
4.2.4.2 Konstruktorer der kalder konstruktorer
Det gøres ved noget der ligner et metodekald:
public class Tidspunkt {
...
public Tidspunkt() {
this( 0, 0, 0 );
}
public Tidspunkt( int timer, int minutter, int sekunder ) {
set( timer, minutter, sekunder );
}
...
}
Der er ikke nogen metode der hedder this, men kaldet betyder at den konstruktor, der passer med parametrene bliver kaldt. På den måde er det den anden konstruktor, der foretager initialiseringen ud fra de aktuelle parametre i kaldet.
Kode-redundansen er nu væk, og vil man senere foretage ændringer, skal man kun gøre det ét sted. En sådan ændring kunne f.eks. være at indføre en kontrol af at minutter og sekunder ikke overstiger 59. I den aktuelle situation vil man placere en sådan kontrol i set-metoden.
4.2.4.3 Default-konstruktor
Definition: Default-konstruktor En default-konstruktor, er en konstruktor der ikke har nogen formelle parametre. |
Før vi lavede den første konstruktor til klassen Tidspunkt kunne vi allerede have lavet instanser med f.eks.:
Tidspunkt vorTid = new Tidspunkt();
Her er der ikke anført nogen aktuelle parametre, og den konstruktor der bliver kaldt er default-konstruktoren. Men hvordan kan det så lade sig gøre før vi overhovedet har lavet nogen konstruktor? Det kan det, fordi Java selv laver en default-konstruktor til alle klasser. Denne konstruktor er på formen:
public Tidspunkt() {
}
En konstruktor der intet gør!
Hvis vi selv laver en eller flere konstruktorer til en klasse, vil Java undlade at lave en default-konstruktor, uanset om vi selv har lavet en default-konstruktor.
4.2.4.4 Set-konstruktor
Definition: Set-konstruktor En set-konstruktor[[Betegnelsen "set-konstruktor", er undertegnedes egen opfindelse, og man skal derfor ikke forvente at andre nødvendigvis forstår hvad man taler om, hvis man bruger den. Det er muligt at andre i tidens løb har fundet på samme betegnelse for denne slags konstruktorer, da jeg finder den meget nærliggende, men jeg er ikke bekendt med det.]], er en konstruktor der tager datakernen som parameter. |
Set-konstruktoren repræsenterer en primitive form for initialisering af objektet; hvor man sender de data med, som uden videre skal placeres i datakernen. Navnet skyldes naturligvis den store lighed med set-metoder.
Om det er hensigtsmæssigt at lave en set-konstruktor afhænger ofte af hvor intuitiv den repræsentation man har valgt i data-kernen er. I vores klasse: Tidpunkt, må vi nok indrømme, at selvom total-sekunder gør implementationen simplere, så kan selve begrebet total-sekunder ikke forventes at være intuitivt for den der anvender klasse. Det er blot en intern data-repræsentation, der ikke bør have betydning for klassens interface. Selvom det derfor ikke er videre oplagt at lave en set-konstruktor til Tidspunkt-klassen, vil vi gøre det for at illustrere hvad en set-konstruktor er:
public Tidspunkt( int totalSekunder ) {
this.totalSekunder = totalSekunder;
}
Når man laver set-konstruktorer, der helt eller delvist tager datakernen som parameter, skal man vælge navne til de formelle parametre. Det kan man gøre på mange måder - vi vil se på de mest almindelige.
Man kan vælge at forkorte parametrenes navne til start-bogstavet for den tilsvarende instans-variabel, evt. flere start-bogstaver hvis flere variable starter med det samme bogstav. Det går ud over læsbarheden med én-bogstavs parameter-navne, men da en set-konstruktorer har et trivielt indhold er læsbarheden i forvejen så høj, at man ikke har noget behov for beskrivende parameternavne.
Man ser også nogle gange at der sættes en underscore foran navnet på instans-variabelen og at man bruge det som parameternavn:
public Tidspunkt( int _totalSekunder ) {
totalSekunder = _totalSekunder;
}
Jeg har selv anvendt denne metode en kort overgang, men kasserede den fordi jeg synes det kan være vanskeligt, at se om man har husket underscore i assignments.
4.2.4.4.1 this-referencen
En tredie mulighed er at bruge en this-reference. Vi har allerede set ordet this brugt til kald mellem konstruktorer i samme klasse, men det har også en anden betydning.
Enhver instans har en reference til sig selv, der hedder this. Vha. denne reference kan objektet referere til sine metoder og variable.
this-referencen
 |
Det er det man benytter i den tredie måde at navngive de formelle parametre til en set-konstruktor:
public Tidspunkt( int totalSekunder ) {
this.totalSekunder = totalSekunder;
}
Ved at give parametre de samme navne som instans-variablene afskærer vi os umiddelbart fra at bruge instans-variablene. Når vi skriver totalSekunder i konstruktoren (eller hvis det havde været en metode), vil det være parameteren der bliver anvendt, og instans-variabelen med samme navn vil ikke være tilgængelig.
Her er det, at vi bruge this-referencen til at tilgå objektet selv. Vi gør det ved at anvende referencen som ved et metodekald, men nu er det en variabel, og ikke et kald, der optræder efter punktum.
<reference>.<instans-variabel>
hvor <reference> er this og <instans-variabel> er f.eks. totalSekunder.
this.totalSekunder
this kan også anvendes som en reference man kan give til andre objekter, så de får mulighed for at kommunikere med objektet.
4.2.4.5 Copy-konstruktor
Definition: Copy-konstruktor En copy-konstruktor, er en konstruktor der tager en anden instans af samme klasse som parameter, og kopierer datakernen. |
En sådan copy-konstruktor kunne være praktisk til vores klasse Tidspunkt. Så ville man ved instantiering kunne angive en instans af Tidspunkt (som allerede var lavet), som vores nye objekt skulle kopiere sin tilstand fra. Dvs. den skulle sætte sit tidspunkt til at være det samme.
For at kunne gøre det må vi kunne overføre objekter som parametre. Det kan man ikke i Java, men man kan gøre noget der på sin vis er bedre: Man kan overføre referencer som parametre!
I virkeligheden er det nøjagtig det samme der sker som ved parametre af primitive typer, f.eks. integers. Det der sker, er et assignment fra den aktuelle parameter til den formelle parameter. Lad os se skelettet af vores copy-konstruktor med en anvendelse:
public class Tidspunkt {
...
private int totalSekunder;
public Tidspunkt( Tidspunkt other ) {
...
}
...
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt tid1 = new Tidspunkt( 12, 0, 0 );
Tidspunkt tid2 = new Tidspunkt( tid1 );
}
}
I anvendelsen laver vi først en instans tid1 med tidspunktet 12:00:00, og dernæst laver vi endnu en instans; hvor vi overfører referencen til den første som parameter, for at tid2 skal få samme tidspunkt.
Hvis vi tænker på det som et assignment, svarer overførslen til:
Tidspunkt other = tid1
Her er det netop et assignment mellem reference-variable, og både other og tid1 vil nu referere til det samme objekt. På den måde har main-metoden fortalt konstruktoren "hvor" det objekt er som den skal kopiere sin datakerne fra befinder sig. Når vi skal tilgå tidspunktet i det andet objekt, gør vi det ved at bruge denne reference. Det færdige resultat bliver:
public class Tidspunkt {
private int totalSekunder;
public Tidspunkt( Tidspunkt other ) {
this.totalSekunder = other.totalSekunder;
}
...
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt tid1 = new Tidspunkt( 12, 0, 0 );
Tidspunkt tid2 = new Tidspunkt( tid1 );
System.out.println( tid1 );
System.out.println( tid2 );
}
}
[12:00:00]
[12:00:00]
Der er her to ting der kræver en forklaring.
Den første er brudet på indkapslingen. Den ene instans af Tidspunkt læser direkte fra instans-variabelen i den anden instans af Tidspunkt. At det kan lade sig gøre skyldes et fænomen som kaldes "friends". To instanser er friends hvis de er af samme klasse, og venner deler jo! Mellem friends er alt public, uanset hvad der ellers måtte være angivet i klassen.
Det forklarer hvorfor det er muligt - men brud på indkapslingen!? Der er ganske unike situationer; hvor (jeg mener) det er acceptabelt at man bryder indkapslingen - copy-konstruktorer er én af den. Det skyldes en række egenskaber ved en copy-konstruktor:
En copy-konstruktor læser kun fra den anden instans, den ændrer ikke noget. Alt foregår inden for samme klasse, så navne på instans-variable er ikke fremmede. Skal disse navne f.eks. ændres, spreder ændringerne sig ikke uden for klassen. |
Grunden til at man så vidt muligt skal holde sig til streng objektorientering, er for at opnå de foredele der er ved objektorientering og undgå de problemer man skaber når man ikke bruger det. Det er derfor argumentationen ovenfor tager udgangspunkt i de fordele og ulemper der spiller ind, i relation til det objektorienterede.
Den anden ting, der kræver en forklaring i eksemplet ovenfor, er det manglende kald af toString i System.out.println. Metoden println er en instans-metode, men vi kalder den på en speciel måde som vi skal se nærmere på i forbindelse med static i et senere kapitel. Metoden er overloaded med et utal af forskellige type (se evt. afsnittet "PrintStream" i kapitlet "Streams"). To af disse typer er String og Object. Når vi tidligere har kaldt toString, har det været den version af println der tager en String som blev kaldt og den har udskrevet den tekststreng der beskrev objektet. Når man i stedet undlader toString, er det den version der tager et Object som bliver brugt (vi skal senere i kapitlet "Nedarvning" se hvorfor dette sker). Denne version af println kalder toString på ethvert objekt den modtager som parameter, og vi opnår derved samme effekt som hvis vi selv kaldte toString.
public void println( Object obj ) {
println( obj.toString() );
}
Vi vil derfor normalt ikke selv kalde toString, da det forkorter notationen, at udnytte denne overloading.
I Java ligger det fast, at parameter-overfører man en primitiv type bliver værdien altid kopieret over i den metode man kalder, og parameter-overfører man et objekt bliver det altid en reference der kopieres over til den metode man kalder. Som nævnt er det, det samme der sker - et assignment fra en aktuel parameter til en formel parameter.
I f.eks. C++ ligger det ikke fast, og man kan efter eget valg f.eks. overføre en integer vha. en reference, eller et objekt som en kopi. I den forbindelse har man to betegnelser, der er gode at kende: Pass by value og pass by reference. Pass by value, er at man kopierer data over i metodens formelle parametre, mens pass by reference, er at man i stedet overfører en reference til data.
Hvis man derfor skal beskrive mulighederne i Java med disse termer, kan det gøres med:
Alle primitive typer overføres med pass by value. Alle ikke-primitive typer overføres med pass by reference. |
Med alle ikke-primitive typer, menes objekter og arrays.
Disse to forskellige former for parameter-overførsel kan i starten forvirre, men husker man én ting, er det i virkeligheden enkelt at forstå: I Java fungerer det altid som assignment!
4.2.5 Metoder
4.2.5.1 Ændringer
public class Tidspunkt {
...
public void addTimer( int timer ) {
totalSekunder += timer * TIME;
}
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt( 12, 30, 0 );
vorTid.addTimer( 1 );
System.out.println( vorTid );
}
}
[13:30:00]
public class Tidspunkt {
...
public void addMinutter( int minutter ) {
totalSekunder += minutter * MINUT;
}
public void addSekunder( int sekunder ) {
totalSekunder += sekunder;
}
}
public class Tidspunkt {
...
public void add( int timer, int minutter, int sekunder ) {
totalSekunder += getTotalSekunder( timer, minutter, sekunder );
}
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt( 12, 30, 0 );
vorTid.add( 1, 0, 0 );
System.out.println( vorTid );
}
}
[13:30:00]
public class Tidspunkt {
...
public void add( Tidspunkt other ) {
this.totalSekunder += other.totalSekunder;
}
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt( 12, 30, 0 );
Tidspunkt enTime = new Tidspunkt( 1, 0, 0 );
vorTid.add( enTime );
System.out.println( vorTid );
}
}
[13:30:00]
vorTid.add( enTime );
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt( 12, 30, 0 );
vorTid.add( new Tidspunkt( 1, 0, 0 ) );
System.out.println( vorTid );
}
}
Tidspunkt other = new Tidspunkt( 1, 0, 0 )
vorTid.add( new Tidspunkt( -1, 0, 0 ) );
public class Tidspunkt {
...
public void sub( Tidspunkt other ) {
this.totalSekunder -= other.totalSekunder;
}
}
public class Main {
public static void main( String[] argv ) {
Tidspunkt vorTid = new Tidspunkt( 12, 30, 0 );
vorTid.sub( new Tidspunkt( 1, 0, 0 ) );
System.out.println( vorTid );
}
}
[11:30:00]
4.2.4.2 Sammenligninger
public class Tidspunkt {
...
public boolean equals( int timer, int minutter, int sekunder ) {
return totalSekunder == getTotalSekunder( timer, minutter, sekunder );
}
}
public boolean equals( Tidspunkt other ) {
return this.totalSekunder == other.totalSekunder;
}
Metoden der ser på ulighed kaldes normalt compareTo, og returner et tal der giver "resultatet" af sammenligningen. Man giver det ene objekt til det andet og siger: "Sammenlign dig med det her objekt!". Svaret er et af tre mulige:
Retur-værdier fra compareTo
Værdi |
Betydning |
-1 |
"Den er større end mig" |
0 |
"Vi er lige store" |
1 |
"Jeg er størst" |
Enkelt nok, men umiddelbart lidt mærkeligt med værdierne. Man skal forstå det som om det objekt man sender med som parameter "trækkes fra", og det der returneres er et udtryk for fortegnet på resultatet.
Anvendelse af compareTo
 |
Når vi implementerer metoden begynder vi ikke at trække sekunder fra sekunder, minutter fra minutter osv. Det er meget enklere at omregne begge tidspunkter til sekunder og sammenligne dem.
public class Tidspunkt {
...
public int compareTo( Tidspunkt other ) {
int dif = this.totalSekunder - other.totalSekunder;
if ( dif < 0 )
return -1;
else if ( dif > 0 )
return 1;
else
return 0;
}
}
public int compareTo( Tidspunkt other ) {
return signum( this.totalSekunder - other.totalSekunder );
}
private int signum( int x ) {
if ( x != 0 )
return x / Math.abs( x );
else
return x; // eller 0
}
4.2.5 Testanvendelse
class Main {
public static void main( String[] argv ) {
Tidspunkt t1 = new Tidspunkt( 12, 30, 0 );
Tidspunkt t2 = new Tidspunkt( t1 );
System.out.println( "t1 lig t2: " + t1.equals( t2 ) );
t1.add( new Tidspunkt( 1, 0, 0 ) );
System.out.println( "t1: " + t1 );
System.out.println( "t1 compare to t2: " + t2.compareTo( t1 ) );
t1.setMinutter( 55 );
System.out.println( "t1: " + t1 );
System.out.println( "t1's timer: " + t1.getTimer() );
}
}
t1 lig t2: true
t1: [13:30:00]
t1 compare to t2: -1
t1: [13:55:00]
t1's timer: 13
5. Arrays af objekter
Tidspunkt[] tider = new Tidspunkt[10];
Tidspunkt vorTid;
Tidspunkt[] tider = new Tidspunkt[10];
System.out.println( tider[0] );
null
for ( int i=0; i<tider.length; i++ )
tider[i] = null;
for ( int i=0; i<tider.length; i++ )
tider[i] = new Tidspunkt( 2*i, 0, 0 );
for ( int i=0; i<tider.length; i++ )
System.out.println( tider[i] );
[0:00:00]
[2:00:00]
[4:00:00]
[6:00:00]
[8:00:00]
[10:00:00]
[12:00:00]
[14:00:00]
[16:00:00]
[18:00:00]
tider[3].add( tider[7] );
System.out.println( tider[3] );
[20:00:00]
6. Garbage Collector
I dette sidste afsnit skal vi se på noget af det mest specielle ved objekter, et hjørne hvor man ikke kommer så tit, men som man bør kende.
Hvad sker der når objekter dør? Kommer de ud på de evige bit-marker? Nej, de bliver taget af garbage collectoren!
Garbage collectoren er en del af Java's runtime-system - den virtuelle maskine. Garbage collectoren søger med mellemrum efter objekter, der ikke findes referencer til. Når den finder sådanne, frigives den del af lageret der ellers var allokeret til dem. Det betyder at man kan bruge objekter ud fra "brug og smid væk" mentaliteten - garbage collectoren skal nok komme og rydde op efter os.
Vi skal i senere kapitler se, at objekter kan have allokeret andre resourcer end lager, f.eks. netværks-forbindelser, filer og andet. Derfor kan det være hensigtsmæssigt at objekter får en sidste chance for at "rydde op efter sig" inden de bliver taget af garbage collectoren. Man har mulighed for at lave en metode, der hedder finalize, som garbage collectoren altid vil kalde lige før den "gør det onde" ved objektet.
Et simpelt eksempel kunne være:
public class C {
public void finalize() {
System.out.println( "signing off..." );
}
}
public class Main {
public static void main( String[] argv ) {
C c;
while ( true )
c = new C();
}
}
Signing off...
Signing off...
Signing off...
...
System.gc();
Epilog
String s1 = "Her";
String s2 = "Herning";
String s3 = "Hyrning";
System.out.println( s1.compareTo( s2 ) );
System.out.println( s1.compareTo( s3 ) );
-4
-20
Repetitionsspørgsmål
Svar på repetitionsspørgsmål