Zdrojový kód z 3. prednášky

import sk.upjs.jpaz2.*;

public class Spustac {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // Trieda WinPane ma viacero konstruktorov. Tu je ukazka konstruktora s
                // 2 parametrami, ktorymi vieme urcit rozmery vytvorenej kresliacej
                // plochy
                WinPane plocha = new WinPane(400, 400);

                // Klasika - ObjectInspector
                ObjectInspector oi = new ObjectInspector();
                oi.inspect(plocha);

                // Klasika - korytnacka Jozko
                MojaTurtle jozko = new MojaTurtle();
                plocha.add(jozko);
                oi.inspect(jozko);
                jozko.center();

                // Vytvorime objekt korytnacky "vedca" - objekt je referencovany z
                // premennej albert
                Vedec albert = new Vedec();
                oi.inspect(albert);

                // Ukazka vypisovania do konzoly (niekedy to moze byt rychlejsie ako
                // pouzitie ObjectInspectora)
                System.out.println("Ahoj");
                System.out.println(367);
                System.out.println(albert.cifernySucet(367));

                // Vytvorenie objektu triedy String, ktory bude obsahovat 4-znakovy
                // retazec Ahoj. Vytvoreny objekt bude referencovany z premennej s.
                String s = new String("Ahoj");
                // Nechame vytvoreny retazcovy objekt skumat inspektorom
                oi.inspect(s);
        }
}

import java.awt.Color;

import sk.upjs.jpaz2.*;

public class MojaTurtle extends Turtle {

        /**
         * Realizuje nahodnu pochodzku so zadanym poctom krokov a natacanim v
         * nasobkoch uhla 90
         *
         * @param pocetKrokov
         *            pocet krokov, ktore ma korytnacka zrealizovat
         */
        public void nahodnaPochodzkaKruh(int pocetKrokov) {
                double startX = this.getX();
                double startY = this.getY();

                for (int i = 0; i < pocetKrokov; i++) {
                        // Vygenerujeme realne nahodne cislo z <0, 4). Orezanim desatinnej
                        // casti (pretypovanim)
                        // ziskame cele cislo medzi 0 a 3. Jeho vynasobenim cislom 90
                        // ziskame nahodny uhol
                        // natocenia, ktory je nasobkom 90
                        int uhol = 90 * (int) (Math.random() * 4);
                        // Otocime sa o zvoleny uhol (tu prebehne implicitne pretypovanie z
                        // int na double)
                        this.turn(uhol);

                        if (this.getX() < 150) {
                                this.setPenColor(Color.green);
                        } else {
                                this.setPenColor(Color.red);
                        }

                        this.step(10);

                        if (this.distanceTo(startX, startY) > 100) {
                                this.step(-10);
                        }

                        JPAZUtilities.delay(30);
                }

                this.setPosition(startX, startY);
        }

        /**
         * Nakresli stvorcovu spiralu
         *
         * @return celkova dlzka krokov, ktore korytnacka zrealizovala
         */
        public double stvorcovaSpirala() {
                // Dlzka kroku, ktory mame najblizsie spravit
                double krok = 150;
                // V premennej prejdene si pamatame doposial prejdenu dlzku
                double prejdene = 0;

                // Opakujeme, kym je krok aspon 1 pixel (je ho vidiet)
                while (krok >= 1) {
                        // Spravime krok
                        this.step(krok);
                        // Pridame si krok k prejdenej dlzke
                        prejdene = prejdene + krok;
                        this.turn(90);
                        // Znizime dlzku kroku o 10%
                        krok = 0.9 * krok;
                        JPAZUtilities.delay(50);
                }

                // Vratime ako vysledok volania metody aktualnu hodnotu v premennej
                // prejdene
                return prejdene;
        }

        /**
         * To iste ako stvorcova spirala, ale na prerusenie (inak nekonecneho) while
         * cyklu pouzijeme prikaz break
         */
        public double stvorcovaSpirala2() {
                double krok = 150;
                double prejdene = 0;

                while (true) {
                        this.step(krok);
                        prejdene += krok;
                        this.turn(90);
                        krok = 0.9 * krok;
                        JPAZUtilities.delay(50);
                        // Ak je krok uz prilis maly, tak prerusime cyklus
                        if (krok < 1) {
                                break;
                        }
                }

                return prejdene;
        }

        /**
         * To iste ako stvorcova spirala, avsak metodu ukoncujeme vo vnutri
         * nekonecneho while cyklu pomocou prikazu return
         */
        public double stvorcovaSpirala3() {
                double krok = 150;
                double prejdene = 0;

                while (true) {
                        this.step(krok);
                        prejdene += krok;
                        this.turn(90);
                        krok = 0.9 * krok;
                        JPAZUtilities.delay(50);
                        // Ak je uz krok prilis maly, tak ukoncime vykonavanie metody a
                        // vratime aktualnu hodnotu v premennej prejdene
                        if (krok < 1) {
                                return prejdene;
                        }
                }
        }

}

import sk.upjs.jpaz2.Turtle;

public class Vedec extends Turtle {

        /**
         * Vypocita pocet delitelov kladneho celeho cisla
         *
         * @param n
         *            kladne cele cislo
         * @return pocet delitelov zadaneho cisla
         */
        public int pocetDelitelov(int n) {
                // Premenna, ktoru pouzijeme ako pocitadlo toho, kolko delitelov cisla n
                // sme nasli
                int vysledok = 0;

                // Skusame vsetky cele cisla od 1 po n ...
                for (int i = 1; i <= n; i++) {
                        // Vzdy, ked cislo n je delitelne cislom i (riadiaca premenna
                        // cyklu), zvysime pocitadlo (vysledok) o 1
                        if (n % i == 0) {
                                vysledok++;
                        }
                }

                // Vratime hodnotu v premennej vysledok
                return vysledok;
        }

        /**
         * Vypocita ciferny sucet zadaneho cisla
         *
         * @param cislo
         *            cislo, ktoreho ciferny sucet chceme vypocitat
         * @return ciferny sucet zadaneho cisla
         */
        public int cifernySucet(int cislo) {
                // Ak by cislo bolo zaporne, zmenime mu znamienko
                if (cislo < 0) {
                        cislo = -cislo;
                }

                // Namiesto if-u si vystacime aj s:
                // cislo = Math.abs(cislo);

                int vysledok = 0;

                while (cislo > 0) {
                        // Vyberam poslednu cifru
                        int cifra = cislo % 10;
                        // Cifru priratam k vysledku
                        vysledok = vysledok + cifra;
                        // Odtrhnem z cisla poslednu cifru
                        cislo = cislo / 10;
                }

                return vysledok;
        }

        /**
         * Spocita pocet vyskytov znaku 'a' v zadanom retazci (retazcovom objekte)
         *
         * @param s
         *            referencia na retazcovy objekt, v ktorom chceme spocitat pocet
         *            a-cok
         * @return pocet vyskytov znaku 'a' v zadanom retazci
         */
        public int pocetVyskytovA(String s) {
                // Premenna (pocitadlo), v ktorej si ratame, kolko a-cok sme zistili
                int vysledok = 0;
                // Prechadzame cez vsetky platne indexy znakov retazca referencovaneho z
                // premennej (parametra) s
                for (int i = 0; i < s.length(); i++) {
                        // Popytame si z s znak na zadanom indexe
                        char pismeno = s.charAt(i);
                        // Ak je vratene pismeno male a, zvysime hodnotu pocitadla
                        if (pismeno == 'a') {
                                vysledok++;
                        }
                }

                // Vratime, kolko a-cok sme nasli
                return vysledok;
        }
}