Arv i OOP

I denna artikeln går vi igenom hur arv fungerar i objektorienterad programmering, och vilken användning man har av det.

Klasser kan ärva instansvariabler och metoder från en annan klass, vilket ger den klassen nästan exakt samma funktionalitet som klassen den ärver av. Den stora fördelen är att man kan lägga till ytterligare funktionalitet till klassen som ärver. Klassen som ärver från en annan klass brukar kallas sub-klass eller barn-klass, medan klassen som ärvs ifrån brukar kallas super-klass eller förälder-klass.

Att förstå hur arv fungerar är ganska enkelt, men att lära sig tillämpa det på ett bra sätt kan vara väldigt svårt. Därför kommer vi samtidigt som vi förklarar hur arv fungerar visa olika sätt att tillämpa det på, och berätta om för- och nackdelarna med dem.

För att visa exempel på arv ska vi skapa klassen Klocka, som ska simulera ett vanlig digitalur som hänger på väggen i nästan alla hem. Den ska ha metoderna tick(), som ökar klockan en sekund, och tillSträng(), som returnerar tiden i formatet TT:MM:SS. Klassen är inte så avancerad, så vi skriver den bara rätt upp och ner.

OBServera att en klocka egentligen inte är ett bra exempel på OOP i PHP. PHP-kod exekveras ju på en gång, så man har inte så stor nytta av en klocka som kan ticka, men i andra språk som inte exekveras på en gång (till exempel JavaScript) kan man ha nytt av den.

PHP - PHP: Hypertext Preprocessor
<?php class Klocka{ private $timme; private $minut; private $sekund; public function __construct(){ // Alla klockor börjar på 12:00:00 $this->timme = 12; $this->minut = 0; $this->sekund = 0; } public function tick(){ if($this->sekund == 59){ if($this->minut == 59){ if($this->timme == 23){ $this->timme = 0; }else{ $this->timme++; } $this->minut = 0; }else{ $this->minut++; } $this->sekund = 0; }else{ $this->sekund++; } } public function tillSträng(){ $sträng = ''; // Timme if($this->timme <= 9){ $sträng .= '0'; } $sträng .= $this->timme.':'; // Minut if($this->minut <= 9){ $sträng .= '0'; } $sträng .= $this->minut.':'; // Sekund if($this->sekund <= 9){ $sträng .= '0'; } $sträng .= $this->sekund; return $sträng; } } ?>

När man har skrivit sin kod ska man alltid kolla igenom den och se om den går att göra bättre. Det underlättar enormt när man kommer tillbaka till den vid ett senare tillfälle och ska ändra, så går den här koden att förbättra? Den är inte så avancerad, det enda man kan klaga på är att vi har en massa nästlade villkorssatser i metoden tick, vilket gör att det är svårt att följa med vad som egentligen händer. Att lägga in kommentarer som förklarar detta i varje villkorssats gör koden snarare ännu mer svåröverskådligare än vad den redan är, så det är ingen bra lösning. Vi kan dock dela upp metoden i flera mindre metoder, och då blir varje mindre metod lekande lätt att förstå.

Att dela upp ett problem i flera mindre delproblem är en teknik som går under namnet Söndra och Härska (på engelska Divide and Conquer). Den gör att stora svåröverskådliga problem blir till flera små lättöverskådliga problem som är enkla att lösa.

Så, när vi applicerar Söndra och Härska-tekniken på vårt problem blir vår kod såhär:

<?php class Klocka{ private $timme; private $minut; private $sekund; public function __construct(){ // Alla klockor börjar på 12:00:00 $this->timme = 12; $this->minut = 0; $this->sekund = 0; } public function tick(){ $this->ökaSekund(); } private function ökaSekund(){ if($this->sekund == 59){ $this->sekund = 0; $this->ökaMinut(); }else{ $this->sekund++; } } private function ökaMinut(){ if($this->minut == 59){ $this->minut = 0; $this->ökaTimme(); }else{ $this->minut++; } } private function ökaTimme(){ if($this->timme == 23){ $this->timme = 0; }else{ $this->timme++; } } public function tillSträng(){ $sträng = ''; // Timme if($this->timme <= 9){ $sträng .= '0'; } $sträng .= $this->timme.':'; // Minut if($this->minut <= 9){ $sträng .= '0'; } $sträng .= $this->minut.':'; // Sekund if($this->sekund <= 9){ $sträng .= '0'; } $sträng .= $this->sekund; return $sträng; } } ?>

Nu är koden inte alls svår att förstå någonstans, vilket tyder på att den är bra skriven.

Men hur kommer arv in i bilden? Jo, vi har nu denna klassen och kan skapa instanser av den som vilken vanlig klass som helst, så vi kan simulera klockor med hjälp av den. Vår nästa uppgift är att skapa en klass som simulerar en alarmklocka, alltså en klocka man även kan ställa in en alarmtid på, och det är nu vi kan utnyttja arv. En alarmklocka fungerar ju precis som en vanlig klocka, fast med lite extra funktionalitet, så alarmklockan ska ha allting som klockan har.

I PHP använder man nyckelordet extends på följande sätt för att en klass ska ärva från en annan:

<?php // Inkludera klassen Klocka include_once 'Klocka.php'; class Alarmklocka extends Klocka{ // Nu har denna klassen samma egenskaper som finns i klassen Klocka! } ?>

Svårare än såhär är det inte att ärva, och vi kan redan nu skapa instanser av Alarmklocka, och den kommer fungerar exakt på samma sätt som klassen Klocka.

Följande koder:

PHP - PHP: Hypertext Preprocessor
<?php include_once 'Alarmklocka.php'; $klocka = new Alarmklocka(); $klocka->tick(); $klocka->tick(); $klocka->tick(); echo $klocka->tillSträng(); ?>
PHP - PHP: Hypertext Preprocessor
<?php include_once 'Klocka.php'; $klocka = new Klocka(); $klocka->tick(); $klocka->tick(); $klocka->tick(); echo $klocka->tillSträng(); ?>

Kommer båda resultera i följande output:

12:00:03

Det finns dock en del saker att tänka på. Det första är synligheten på egenskaperna. Klassen som ärver kan inte använda egenskaper från föräldraklassen som har synligheten private, för private tillåter endast att klassen som deklarerar egenskaperna använder dem. Vi kan alltså inte göra följande:

<?php // Inkludera klassen Klocka include_once 'Klocka.php'; class Alarmklocka extends Klocka{ public function enMetod(){ // Här kan vi till exempel inte skriva $this->minut, eftersom den är private i klassen Klocka } } ?>

Vad är lösningen på det här, då? Jo, en lösning är att vi i föräldra-klassen deklarerar alla egenskaper som public, då kommer barn-klassen åt alla dessa egenskaper. Men det öppnar ju upp att man kan ändra instansvariablerna utifrån klassen på följande sätt:

PHP - PHP: Hypertext Preprocessor
<?php // Inkludera klassen Klocka include_once 'Klocka.php'; $klocka = new Klocka(); // Om man deklarerar instansvariablerna som public kan man göra såna här idiotiska saker $klocka->sekund = 333; ?>

Det vill vi ju inte, så vad är lösningen? Jo, det finns en tredje synlighet utöver public och private, och det är protected. Egenskaper som är deklarerade som protected kan man inte komma åt utifrån på detta sättet (precis som egenskaper deklarerade som private), men man kan komma åt dem i barn-klasser (precis som egenskaper deklarerade som public), så det är en blandning av public och private.

Så om vi i klassen Klocka ger instansvariablerna timme, minut och sekund synligheten protected istället kan klassen Alarmklocka använda sig av dessa.

<?php class Klocka{ // Ge instansvariablerna synligheten protected istället protected $timme; protected $minut; protected $sekund; // Och resten som innan... } ?>
<?php // Inkludera klassen Klocka include_once 'Klocka.php'; class Alarmklocka extends Klocka{ public function enMetod(){ // Nu kan vi till exempel skriva $this->minut, eftersom den är protected i klassen Klocka } } ?>
PHP - PHP: Hypertext Preprocessor
<?php include_once 'Klocka.php'; $klocka = new Klocka(); // Och vi kan inte göra såna här idiotsaker, eftersom instansvariablerna har synligheten protected $klocka->sekund = 120; ?>

Nästa sak att tänka på är konstruktorn i klassen Alarmklocka. Här vill vi skicka med tiden då klockan ska larma. Sedan behöver vi några instansvariabler för att spara tiden då klockan ska larma.

<?php // Inkludera klassen Klocka include_once 'Klocka.php'; class Alarmklocka extends Klocka{ private $alarmTimme; private $alarmMinut; private $alarmSekund; public function __construct($timme, $minut, $sekund){ $this->alarmTimme = $timme; $this->alarmMinut = $minut; $this->alarmSekund = $sekund; } } ?>

Nu borde vi väll kunna köra följande kod, eller?

PHP - PHP: Hypertext Preprocessor
<?php include_once 'Alarmklocka.php'; // Ska larma 12:00:10 $klocka = new Alarmklocka(12, 0, 10); $klocka->tick(); $klocka->tick(); $klocka->tick(); echo $klocka->tillSträng(); ?>

Jo, det kommer att fungera, men inte som man antagligen förväntar sig. Det beror på att konstruktorn i klassen Klocka inte har körts, så instansvariablerna $timme, $minut och $sekund har inte tilldelats de värden vi anger i konstruktorn i klassen Klocka. Detta medför att PHP tror att de ska börja på värdet 0 istället, så vi kommer istället få följande output:

00:00:03

Men varför har inte konstruktorn i klassen Klocka körts? Jo, det beror på att vi har överlagrat den. I klassen Alarmklocka har vi en konstruktor, och den anropas när vi skapar en ny instans av klassen Alarmklocka, och det är bara den som anropas, förälderns konstruktor anropas aldrig.

Det samma gäller för alla metoder i en klass, inte bara konstruktorn. Om vi till exempel skulle skapa metoden tillSträng() i klassen Alarmklocka kommer inte metoden tillSträng() i klasssen Klocka att anropas om vi anropar den från en instans av klassen Alarmklocka.

Men vi vill ju att förälderns konstruktor körs när konstruktorn i klassen Alarmklocka, så vad är lösningen? Jo, med hjälp av nyckelordet parent och operatorn :: kan vi anropa egenskaper som föräldern har.

<?php // Inkludera klassen Klocka include_once 'Klocka.php'; class Alarmklocka extends Klocka{ private $alarmTimme; private $alarmMinut; private $alarmSekund; public function __construct($timme, $minut, $sekund){ // Kör förälderns konstruktor parent::__construct(); $this->alarmTimme = $timme; $this->alarmMinut = $minut; $this->alarmSekund = $sekund; } } ?>
PHP - PHP: Hypertext Preprocessor
<?php include_once 'Alarmklocka.php'; // Ska larma 12:00:10 $klocka = new Alarmklocka(12, 0, 10); $klocka->tick(); $klocka->tick(); $klocka->tick(); echo $klocka->tillSträng(); ?>
12:00:03

Nästa sak vi ska fixa är att klockan larmar när den tickar och slår över till tiden då larmet är satt. Hur kan vi lösa det på ett bra sätt? Det bästa sättet är troligtvis att använda designmönstert Observer, men för att inte krångla till det kommer vi istället nöja oss med att överlagra metoden tick() och låta den returnera värdet true om klockan börjar larma, annars false.

<?php // Inkludera klassen Klocka include_once 'Klocka.php'; class Alarmklocka extends Klocka{ private $alarmTimme; private $alarmMinut; private $alarmSekund; public function __construct($timme, $minut, $sekund){ // Kör förälderns konstruktor parent::__construct(); $this->alarmTimme = $timme; $this->alarmMinut = $minut; $this->alarmSekund = $sekund; } public function __tick(){ // Kör förälderns metod tick() parent::tick(); // Om larmtiden är samma som tiden nu... if($this->timme == $this->alarmTimme && $this->minut == $this->alarmMinut && $this->sekund == $this->alarmSekund ){ // ...returnera sant... return true; }else{ // ...annars falskt return false; } } } ?>
PHP - PHP: Hypertext Preprocessor
<?php include_once 'Alarmklocka.php'; // Ska larma 12:00:10 $klocka = new Alarmklocka(12, 0, 10); for($i=1; $i<=15; $i++){ // Öka klockan en sekund och kom ihåg om den larmade eller inte $larmade = $klocka->tick(); if($larmade){ echo 'Klockan larmade '.$klocka->tillSträng()."!<br>\n"; }else{ echo 'Klockan larmade inte '.$klocka->tillSträng().".<br>\n"; } } ?>
HTML - HyperText Markup Language
Klockan larmade inte 12:00:01.<br> Klockan larmade inte 12:00:02.<br> Klockan larmade inte 12:00:03.<br> Klockan larmade inte 12:00:04.<br> Klockan larmade inte 12:00:05.<br> Klockan larmade inte 12:00:06.<br> Klockan larmade inte 12:00:07.<br> Klockan larmade inte 12:00:08.<br> Klockan larmade inte 12:00:09.<br> Klockan larmade 12:00:10!<br> Klockan larmade inte 12:00:11.<br> Klockan larmade inte 12:00:12.<br> Klockan larmade inte 12:00:13.<br> Klockan larmade inte 12:00:14.<br> Klockan larmade inte 12:00:15.<br>
Klockan larmade inte 12:00:01.
Klockan larmade inte 12:00:02.
Klockan larmade inte 12:00:03.
Klockan larmade inte 12:00:04.
Klockan larmade inte 12:00:05.
Klockan larmade inte 12:00:06.
Klockan larmade inte 12:00:07.
Klockan larmade inte 12:00:08.
Klockan larmade inte 12:00:09.
Klockan larmade 12:00:10!
Klockan larmade inte 12:00:11.
Klockan larmade inte 12:00:12.
Klockan larmade inte 12:00:13.
Klockan larmade inte 12:00:14.
Klockan larmade inte 12:00:15.

Det här sättet ska man ju egentligen inte använda en alarmklocka på, men (återigen) eftersom PHP-kod exekveras i ett nafs kan man inte göra så mycket bättre saker. Om vi istället skulle använt språket JavaScript skulle vi till exempel kunnat använt metoden setIntervall för att anropa metoden tick() med en sekunds mellanrum, vilket skulle bli mer likt en klocka.

Men det här är styrkan med arv: att skapa en ny klass genom att ge en existerande klass utökad funktionalitet. Självklart kan man även skapa en klass som ärver från Alarmklocka, och den kommer då få tillgång till de egenskaper som både finns i klassen Alarmklocka och Klocka. Exempel på en sådan klass kan vara Väckarklocka, som även har en snooze-funktion (det vill säga, den larmar igen ~9 minuter efter larmet gått).

Men nu ska vi inte ta och göra det mer komplicerat än vad det är, utan nu ska vi reflektera över det vi gjort och dra slutsatser.

Vi har gett instansvariablerna synligheten protected för att låta klasser som ärver från denna få tillgång till dem. Genom att göra så har vi skapat ett beroende: vi kan inte byta implementation om det visar sig att det skulle behövas. En annan implementation på klassen Klocka skulle kunna vara denna, där vi istället har en instansvariabel som räknar ut klockans tid utifrån hur många sekunder som gått sedan midnatt.

<?php class Klocka{ // Antal sekunder sedan midnatt protected $sekunder; public function __construct(){ // Alla klockor börjar på 12:00:00 $this->sekunder = 12*60*60; } public function tick(){ // 23:59:59 = 86399 sekunder sedan 00:00:00 if($this->sekunder == 86399){ $this->sekunder = 0; }else{ $this->sekunder++; } } public function tillSträng(){ $sträng = ''; $sekunder = $this->sekunder; // Timme $timme = floor($sekunder/(60*60)); $sekunder -= $timme*60*60; if($timme <= 9){ $sträng .= '0'; } $sträng .= $timme.':'; // Minut $minut = floor($sekunder/60); $sekunder -= $minut*60; if($minut <= 9){ $sträng .= '0'; } $sträng .= $minut.':'; // Sekund $sekund = $sekunder; if($sekund <= 9){ $sträng .= '0'; } $sträng .= $sekund; return $sträng; } } ?>

Klassen Alarmklocka förutsätter att klassen Klocka har instansvariablerna $timme, $minut och $sekund, så om vi ändrar till denna implementationen måste vi även ändra koden i klassen Alarmklocka (och alla andra klasser som eventuellt ärver från klassen Klocka). Det kan bli väldigt mycket arbete, så vi bör undvika detta.

Vad är lösningen på detta, då? En bättre fråga är: vad är det som orsaker problemet? Jo, det är just att vi använt oss av synligheten protected på instansvariablerna och låter barn-klasserna ha tillgång till dem, så om vi istället låter alla instansvariabler ha synligheten private slipper vi såna här problem.

Men då återkommer vi till problemet att klassen som ärver (Alarmklocka) inte kan använda sig av instansvariablerna i föräldra-klassen, och vi är tillbaka på ruta 1. Men det finns faktiskt en lösning på detta, och det är att istället använda så kallade getters. Getters är ett namn på de metoder som enbart är avsedda för att returnera information om ett objekt, och de börjar oftast på namnet get (i alla fall på engelska, den bästa svenska översättningen blir väll "hämta").

Så, om vi istället skriver om våra klasser till följande så kan vi fortfarande använda arv, och vi slipper beroendet av implementationen mellan klasserna.

<?php class Klocka{ private $timme; private $minut; private $sekund; public function __construct(){ $this->timme = 0; $this->minut = 0; $this->sekund = 0; } // "Getter" för timme public function hämtaTimme(){ return $this->timme; } // "Getter" för minut public function hämtaMinut(){ return $this->minut; } // "Getter" för sekund public function hämtaSekund(){ return $this->sekund; } public function tick(){ $this->ökaSekund(); } private function ökaSekund(){ if($this->sekund == 59){ $this->sekund = 0; $this->ökaMinut(); }else{ $this->sekund++; } } private function ökaMinut(){ if($this->minut == 59){ $this->minut = 0; $this->ökaTimme(); }else{ $this->minut++; } } private function ökaTimme(){ if($this->timme == 23){ $this->timme = 0; }else{ $this->timme++; } } public function tillSträng(){ $sträng = ''; if($this->timme <= 9){ $sträng .= '0'; } $sträng .= $this->timme.':'; if($this->minut <= 9){ $sträng .= '0'; } $sträng .= $this->minut.':'; if($this->sekund <= 9){ $sträng .= '0'; } $sträng .= $this->sekund; return $sträng; } } ?>
<?php // Inkludera klassen Klocka include_once 'Klocka.php'; class Alarmklocka extends Klocka{ private $alarmTimme; private $alarmMinut; private $alarmSekund; public function __construct($timme, $minut, $sekund){ parent::__construct(); $this->alarmTimme = $timme; $this->alarmMinut = $minut; $this->alarmSekund = $sekund; } public function __tick(){ parent::tick(); // Använd getter-metoderna istället if($this->hämtaTimme() == $this->alarmTimme && $this->hämtaMinut() == $this->alarmMinut && $this->hämtaSekund() == $this->alarmSekund ){ return true; }else{ return false; } } } ?>

Vi kan nu utan problem byta implementation av klassen Klocka till följande:

<?php class Klocka{ private $sekunder; public function __construct(){ $this->sekunder = 12*60*60; } // "Getter" för timme public function hämtaTimme(){ return floor($sekunder/(60*60)); } // "Getter" för minut public function hämtaMinut(){ $timme = $this->hämtaTimme(); $sekunder = $this->sekunder - $timme*60*60; return floor($sekunder/60); } // "Getter" för sekund public function hämtaSekund(){ $timme = $this->hämtaTimme(); $minut = $this->hämtaMinut(); return $this->sekunder - $timme*60*60 - $minut*60; } public function tick(){ if($this->sekunder == 86399){ $this->sekunder = 0; }else{ $this->sekunder++; } } public function tillSträng(){ $sträng = ''; // Använd getter här istället $timme = $this->hämtaTimme(); if($timme <= 9){ $sträng .= '0'; } $sträng .= $timme.':'; // Använd getter här istället $minut = $this->hämtaMinut(); if($minut <= 9){ $sträng .= '0'; } $sträng .= $minut.':'; // Använd getter här istället $sekund = $this->hämtaSekunder(); if($sekund <= 9){ $sträng .= '0'; } $sträng .= $sekund; return $sträng; } } ?>

Båda implementationerna av klassen Klocka fungerar för klassen Alarmklocka, eftersom den enbart använder sig av metoder i föräldra-klassen som har synligheten public.

Betyder det att synligheten protected är helt värdelös? Nej, gör man bara rätt kan den vara väldigt användbar, men det kan vara svårt att veta vad som är rätt när man börjar med OOP. Men vad har vi gjort som inte är rätt? Jo, vi låter klassen Klocka implementera tiden i klockan, vilket egentligen är fel. En tid kan finnas utan en klocka, så det ska egentligen vara en egen klass (klassen Klockslag) som Klocka har en instansvariabel av.

Det kan vara svårt att förstå det resonemanget, och om så är fallet kan man istället tänka såhär i det här fallet:

Just nu låter vi en klocka spara en tid, men så måste det inte vara med klockor. En del klockor sparar flera olika tider (till exempel vad tiden är i Sverige, Indien och Japan), som till exempel affärsmän som reser mycket använder, så en klocka kan ha flera olika tider samtidigt. En klocka kan alltså ha flera tider, vilket gör att en tid och klocka inte är samma sak. En klocka ska bara se till att tiden ökas med en sekund varje gång den tickar.

Sedan sparar vi även ytterligare en tid i klassen Alarmklocka för att komma ihåg när den ska larma, så vår alarmklocka har faktiskt två tider i sig. Det är ytterligare ett tecken på att tid ska vara en egen klass, och inte en del av en klocka.

Så, vi skapar klassen Klockslag, som faktiskt mer eller mindre är identisk med klassen Klocka som vi har den nu. Vi vet även om att vi kommer behöva kunna jämföra två olika klockslag och se om de är lika (för att se om alarmtiden är samma tid som den aktuella tiden i klockan), så vi skapar även en metod i denna klassen som kollar ifall angivet klockslag (medskickat som argument) är samma som klockslaget i instansen.

PHP - PHP: Hypertext Preprocessor
<?php class Klockslag{ private $timme; private $minut; private $sekund; public function __construct($timme, $minut, $sekund){ $this->timme = $timme; $this->minut = $minut; $this->sekund = $sekund; } public function ökaSekund(){ if($this->sekund == 59){ $this->sekund = 0; $this->ökaMinut(); }else{ $this->sekund++; } } public function ökaMinut(){ if($this->minut == 59){ $this->minut = 0; $this->ökaTimme(); }else{ $this->minut++; } } public function ökaTimme(){ if($this->timme == 23){ $this->timme = 0; }else{ $this->timme++; } } public function ärSammaKlockslag(Klockslag $andraKlockslaget){ if($andraKlockslaget->timme == $this->timme && $andraKlockslaget->minut == $this->minut && $andraKlockslaget->sekund == $this->sekund ){ return true; }else{ return false; } } } ?>

Att skapa klassen Klocka blir nu lekande lätt, och instansvariabeln som sparar aktuellt klockslag kan utan problem ha synligheten protected (se varför efter koden).

<?php class Klocka{ protected $aktuellTid; public function __construct(){ // Alla klockor startar på 12:00:00 $this->aktuellTid = new Klockslag(12, 0, 0); } public function tick(){ $this->aktuellTid->ökaSekund(); } public function tillSträng(){ return $this->aktuellTid->tillSträng(); } } ?>

Och klassen Alarmklocka blir nu inte heller svår att skriva, eftersom instansvariabel $aktuellTid har synligheten protected.

<?php // Inkludera alla klasser include_once 'Klocka.php'; include_once 'Klockslag.php'; class Alarmklocka extends Klocka{ // Alarmtiden private $alarm; public function __construct($timme, $minut, $sekund){ // Kör förälderns konstruktor... parent::__construct(); // ...och spara alarmtiden som en instans av klassen Klockslag $this->alarm = new Klockslag($timme, $minut, $sekund); } public function __tick(){ parent::tick(); // Kolla om den aktuella tiden är samma som alarmtiden if($this->aktuellTid->ärSammaTid($this->alarm)){ return true; }else{ return false; } } } ?>

Nu är visserligen klassen Alarmklocka beroende av klassen Klocka eftersom den använder sig av instansvariabeln $aktuellTid som finns i klassen Klocka, men det är inga problem. Vi kommer aldrig i framtiden ta bort denna instansvariabel, för en klocka utan ett klockslag är ingen klocka. Vi kan även byta implementationen av klassen Klockslag, koden i klasserna kommer att fungera i alla fall.


Som sades i början, att förstå hur arv fungerar är ganska lätt, men att veta hur man ska tillämpa det är desto värre. Det kan vara svårt att avgöra när man ska använda arv och när man bara ska ha en instans av en klass. Det kan vara väldigt lockande att tro att klassen Klocka ska ärva från klassen Klockslag, för allt som finns i Klockslag ska ju även finnas i en klocka (öka en sekund, öka en minut, öka en timme, kolla om angiven tid är samma som den i klockan), men det är fel. En klocka är inte en utökning av tid, en klocka är något som använder sig av tiden. Att tänka såhär kan ofta hjälpa en att avgöra om arv är rätt att använda i situationen eller ej.