Rekursiivinen metodi tarkoittaa metodia, jonka sisältä kutsutaan toistamiseen metodia itseään. Perinteisillä tehtäväkierroksilla opimme rekursion käyttöä, mutta itselleni asia valkeni hehkeämmäksi vasta projektia koodatessa. Pelilogiikkani ongelma oli se, että tarvitsin metodia, joka tarkistaa ruudukon tietyn ruudun jokaisen naapurin, ja mikäli naapuri on samanlainen kuin alkuperäinen tietty ruutu, tarkistetaan kyseisenkin ruudun naapurit samanlaisia kuvioita etsien. Assistentti sekä viisas kurssitoverini ehdottivat kauan kammoksumaani sanaa – rekursio. Päätin ottaa aasia hännästä ja katsoa, mitä tapahtuu, kun minä ja rekursio katsomme toisiamme silmiin. Seuraavassa tekemäni metodin rekursio-idea hiukan lyhennettynä, mutta kuitenkin niin, että rekursio tullee selväksi. 

public boolean loytyykoSamaNaapuri(int x, int y, Kuva kuva){ 
        boolean loytyy1 = false;
        boolean loytyy2 = false;
        boolean loytyy3 = false;
        boolean loytyy4 = false;
        if(x – 1 >= 0){
            if(this.ruudukko[x - 1][y] == kuva){
                if(!this.koord.contains(new Point(x-1, y))){             
                    this.koord.add(new Point(x-1, y));                                                                          loytyykoSamaNaapuri(x-1, y, kuva);
                    loytyy1 = true;
                    }  
} 
            }
        if(x + 1 < this.annaLeveys()){
            if(this.ruudukko[x+1][y] == kuva){
                if(!this.koord.contains(new Point(x+ 1, y))){  
this.koord.add(new Point(x+1, y));
                    loytyykoSamaNaapuri(x+1, y, kuva);
loytyy2 = true;
                     } 
                }
            }
        if(y – 1 >= 0){
            if(this.ruudukko[x][y - 1] == kuva){
              if(!this.koord.contains(new Point(x, y-1)){  
                    this.koord.add(new Point(x, y – 1));
                    loytyykoSamaNaapuri(x, y-1, kuva);
loytyy3 = true;
                    }
                }
            }
        if(y + 1 < this.annaKorkeus()){
            if(this.ruudukko[x][y + 1] == kuva){
                if(!this.koord.contains(new Point(x, y+1))){
                this.koord.add(new Point(x, y +1));
loytyykoSamaNaapuri(x, y+1, kuva);
loytyy4 = true;
}
                }
            }

Yllä siis tarkastellaan tietyn x,y-ruudun jokaista suuntaa, tutkitaan löytyykö vierestä sama kuva kuin kyseinen ruutu on. Mikäli sama kuva löytyy esimerkiksi ruudun vasemmalta puolelta, lisätään tämän ruudun koordinaatit this.koord-listaan ja tehdään rekursiivinen tutkimus näillä uusilla koordinaateilla, eli kutsutaan sama metodi tarkistamaan myös uuden koordinaatin viereiset ruudut. Tämän metodin kautta itselleni selvisi lopulta rekursion järkevyys, olin välillä jopa niin epätoivon partaalla, että meinasin toteuttaa kyseisen metodin vähintään niillä 25 if-lauseella, jotka olisivatkin olleet sitä ohjelmointityyliä tyylikkäimmillään.

Kuten yllä nähdään, ei rekursio lopulta ole kovin monimutkainen asia. Javalla sen toteuttaminen on suhteellisen helppoa, on vain oltava varovainen ja tarkka, että logiikka on rekursiossa oikein. Vaarana voi olla se, että rekursio jää ikuisesti toistamaan itseään, ja siksi esimerkiksi yllä on neljä boolean-apumuuttujaa, jotka määritellään ensin falseksi. Mikäli samoja kuvia löytyy vierestä ja rekursiota lähdetään pyörittämään, vaihtuu apumetodi trueksi. Omassa koodissani metodin suorittaminen loppuu silloin, kun kaikki apumuuttujat pysyvät falseina, eli mistään ei ole löytynyt kuvatun ruudun kanssa samantyylistä kuvaa. Näin siis varmistetaan, että metodin suorittaminen loppuu joskus.

Kurssilla on yleisesti opittu, jo ennen rekursiota, se, että yhden metodin A sisältä voidaan kutsua myös muita metodeja, ja käyttää näiden metodien palautusarvoa metodin A edetessä. Esimerkiksi kun metodi A kutsuu sisältään metodia B, metodi A jää odottamaan metodin B edesottamuksia, ja toiminta jatkuu vasta sitten, kun metodi B on valmis ja antanut tuomionsa. Rekursiivisessa metodissa tämä toimii samalla tavalla, on vain otettava huomioon, että samasta metodista voi lähteä useita sisäkkäisiä aktivaatioita eli kutsukertoja samanaikaisesti.

Rekursio on näppärä apu ja järkevä käyttää, kun halutaan siisti vaihtoehto esimerkiksi iteratiiviselle, toistoon perustuvalle silmukkaratkaisulle. Esimerkiksi projektini kyseiseen metodiin olen erittäin tyytyväinen, mielestäni sen logiikka pelaa ja ratkaisu on siisti. Kannatti siis tutustua lähemmin rekursioon, se ei ollutkaan pahin viholliseni.