Zdrojový kód k 4. prednáške

import sk.upjs.jpaz2.Turtle;

public class Znakarka extends Turtle {

        /**
         * Overi, ci retazec je ciselny, t.j. sklada sa len zo znakov cifier
         *
         * @param s
         *            retazec, ktory ideme analyzovat
         * @return true, ak je to ciselny retazec
         */
        public boolean isNumeric(String s) {
                // Specialne osetrime pripad, kedy je referencia na zadany retazec null
                if (s == null) {
                        return false;
                }

                // Specialne osetrime pripad, kedy je referencovany retazec prazdny
                if (s.length() == 0) {
                        return false;
                }

                // Prechadzame vsetky platne indexy v retazci (hodnota premennej
                // i=0..LENGTH-1)
                for (int i = 0; i < s.length(); i++) {
                        // Vyberieme znak na indexe i
                        char znak = s.charAt(i);
                        // Ak vybrany znak nie je znakom cifry, tak ihned koncime s false
                        if (!(('0' <= znak) && (znak <= '9'))) {
                                return false;
                        }
                }

                // Ak sme sa dostali az sem, znamena to, ze return vo for-e nebol
                // aplikovany a teda nenasli sme ziaden znak, ktory by nebol znakom
                // cifry
                return true;
        }

        /**
         * Zduplikuje retazec zadany pocet krat.
         *
         * @param s
         *            retazec, ktory ideme duplikovat
         * @param pocet
         *            kolko krat sa ma retazec duplikovat
         * @return referencia na novovytvoreny retazec obsahujuci zduplikovanie
         *         zadaneho retazca urceny pocet krat
         */
        public String duplikuj(String s, int pocet) {
                // Specialne osetrime pripad, kedy je referencia na zadany retazec null
                if (s == null) {
                        return null;
                }

                // Referencia na objekt, ktory je medzivysledkom behu metody.
                // Na zaciatku referencuje prazdy retazec.
                String vysledok = new String("");

                // V kazdom kroku retazec, ktory je aktualnym medzivysledkom poziadame,
                // aby vytvoril novy retazec, ktory ma rovnaky obsah ako on sam s tym,
                // ze na koniec sa prida obsah retazca referencovaneho z s. Vytvoreny
                // retazec sa stane novym medzivysledkom behu metody.
                for (int i = 0; i < pocet; i++) {
                        vysledok = vysledok.concat(s);
                }

                // Vratime posledny medzivysledok
                return vysledok;
        }

        // To iste ako metoda duplikuj, akurat je implementovana pomocou "skratiek"
        public String duplikuj2(String s, int pocet) {
                if (s == null) {
                        return null;
                }

                String vysledok = "";
                for (int i = 0; i < pocet; i++) {
                        vysledok = vysledok + s;
                }

                return vysledok;
        }

        // To iste ako metoda duplikuj, akurat efektivne pomocou StringBuilder-a
        public String duplikuj3(String s, int pocet) {
                if (s == null) {
                        return null;
                }

                StringBuilder vysledok = new StringBuilder();
                for (int i = 0; i < pocet; i++) {
                        // Na koniec prilepime obsah z s.
                        vysledok.append(s);
                }

                // Poziadame objekt triedy StringBuilder, aby vytvoril objekt triedy String
                // podla svojho aktualneho obsahu.
                return vysledok.toString();
        }

        /**
         * Otoci retazec
         *
         * @param s
         *            referencia na retazec, podla ktoreho chceme vyrobit obrateny
         *            retazec
         * @return referencia na novovytvoreny retazec, ktoreho obsah je obrateny
         *         obsah zadaneho retazca
         */
        public String obratRetazec(String s) {
                // Specialne osetrime pripad, kedy je referencia na zadany retazec null
                if (s == null)
                        return null;

                // Referencia na medzivysledkovy retazec
                // String vysledok = ""; je to skratka pre
                // String vysledok = new String("");
                String vysledok = "";

                // Strategia: postupne budujeme vysledny retazec tak, ze nan prilepujeme
                // znaky retazca s od konca, t.j. zaciname indexom LENGTH-1 a koncime s
                // indexom 0
                for (int i = s.length() - 1; i >= 0; i--) {
                        // Vytvorime novy objekt triedy String prilepenim znaku na indexe i
                        // na koniec retazca referencovaneho z premennej vysledok.
                        // Referenciu na novovytvoreny retazec ulozime do premennej
                        // vysledok
                        vysledok = vysledok + s.charAt(i);
                }

                // Vratime vysledok
                return vysledok;
        }

        /**
         * Otoci retazec
         *
         * @param s
         *            referencia na retazec, podla ktoreho chceme vyrobit obrateny
         *            retazec
         * @return referencia na novovytvoreny retazec, ktoreho obsah je obrateny
         *         obsah zadaneho retazca
         */
        public String obratRetazec2(String s) {
                // Specialne osetrime pripad, kedy je referencia na zadany retazec null
                if (s == null)
                        return null;

                // Referencia na medzivysledkovy retazec
                // String vysledok = ""; je to skratka pre
                // String vysledok = new String("");
                String vysledok = "";
                // V kazdom kroku vytvorime novy retazec, ktory sa od predchadzajuceho
                // lisi tym, ze na zaciatok retazca pridame znak retazca s na indexe i
                for (int i = 0; i < s.length(); i++) {
                        vysledok = s.charAt(i) + vysledok;
                }

                // Vratime vysledok
                return vysledok;
        }
}

import sk.upjs.jpaz2.*;

public class Spustac {

        /**
         * @param args
         */
        public static void main(String[] args) {
                ObjectInspector oi = new ObjectInspector();

                // Vytvorime korytnacku - expertku na spracovanie retazcov
                Znakarka z = new Znakarka();
                // a nechame ju skumat ObjectInspector-om
                oi.inspect(z);

                // Vytvorime aj objekt - retazec
                String s = new String("Ahoj svet");
                // a nechame ju skumat ObjectInspector-om
                oi.inspect(s);

                // Maly experiment s tym, ze rovnaky obsah retazcov a rovnake referencie
                // su 2 rozne veci
                String s1 = new String("Ahoj");
                String s2 = new String("Ahoj");

                boolean rovnakeReferencie = (s1 == s2);
                boolean rovnakyObsah = (s1.equals(s2));

                System.out.println(rovnakeReferencie);
                System.out.println(rovnakyObsah);

                // Este ukazka toho, ako sa meni spravanie operatora + ak jeden z
                // operandov je referencia na retazec
                s1 = "Ahoj";
                String s3 = s1 + 10;
                System.out.println(s3);
        }
}

import java.awt.Color;
import java.awt.event.MouseEvent;

import sk.upjs.jpaz2.*;

public class MojaPlocha extends WinPane {

        // Instancna premenna, v ktorej si "trvalo" pamatame pocet bodiek, ktore sme
        // nakreslili
        private int pocetBodiek = 0;

        /**
         * Nakresli bodku
         *
         * @param x
         *            x-ova suradnica stredu bodky
         * @param y
         *            y-ova suradnica stredu bodky
         * @param c
         *            farba bodky
         */
        public void bodka(double x, double y, Color c) {
                // Vytvorime korytnacku na kreslenie do plochy
                Turtle bodkovac = new Turtle();
                // Pridame ju do tejto kresliacej plochy
                this.add(bodkovac);
                // Presunieme korytnacku na cielovu poziciu
                bodkovac.setPosition(x, y);
                // Zmenime farbu
                bodkovac.setFillColor(c);
                // Nakreslime bodku
                bodkovac.dot(10);

                // Zvysime pocet doposial nakreslenych bodiek
                this.pocetBodiek++;

                // Otocime korytnacku a vypiseme, o kolku bodku v poradi sa jedna
                bodkovac.turn(90);
                bodkovac.print("Bodka " + this.pocetBodiek);

                // Nakoniec korytnacku - kreslica "vyhodime" z kresliacej plochy
                this.remove(bodkovac);
        }

        /**
         * Vrati pocet doposial nakreslenych bodiek - toto je (nateraz) jediny
         * sposob, ako sa dostat k hodnote instancnej premennej
         */
        public int getPocetBodiek() {
                return this.pocetBodiek;
        }

        // Specialna metoda, ktora sa vykona vzdy, ked sa klikne do plochy
        @Override
        protected void onMouseClicked(int x, int y, MouseEvent detail) {
                this.bodka(x, y, Color.red);
        }
}

import sk.upjs.jpaz2.*;

public class Spustac {

        /**
         * @param args
         */
        public static void main(String[] args) {
                ObjectInspector oi = new ObjectInspector();
                MojaPlocha plocha = new OMojaPlocha();
                oi.inspect(plocha);
        }
}

import java.awt.Color;
import java.awt.event.MouseEvent;

import sk.upjs.jpaz2.*;

public class RetiazkovaPlocha extends WinPane {

        /**
         * x-ova suradnica naposledy nakreslenej bodky
         */
        private double polohaX;

        /**
         * y-ova suradnica naposledy nakreslenej bodky
         */
        private double polohaY;

        /**
         * farba, ktoru pouzivame na kreslenie bodiek - meni sa pri zacati kreslenia
         * novej retiazky
         */
        private Color farba = new Color(255, 0, 0);

        /**
         * indikuje, ci prave prebieha kreslenie retiazky
         */
        private boolean kreslimRetiazku = false;

        /**
         * Nakresli bodku zadanej farby
         */
        public void bodka(double x, double y, Color c) {
                Turtle k = new Turtle();
                this.add(k);
                k.setPosition(x, y);
                k.setFillColor(c);
                k.dot(10);
                this.remove(k);
        }

        @Override
        protected void onMouseMoved(int x, int y, MouseEvent detail) {
                // Bodku mozeme nakreslit iba vtedy, ked je zatlaceny klaves CTRL
                if (detail.isControlDown()) {
                        // Spocitame vzdialenost od predchadzajucej bodky
                        double dx = x - this.polohaX;
                        double dy = y - this.polohaY;
                        double vzdialenost = Math.sqrt(dx * dx + dy * dy);

                        // Ak je vzialenost vacsia ako 20 alebo je to prva bodka v retiazke,
                        // tak kreslime
                        if ((vzdialenost >= 20) || (kreslimRetiazku == false)) {
                                // Ak je to prva bodka v retiazke, tak "namiesame nahodnu farbu"
                                // a poznacime si, ze sme zacali kreslit retiazku
                                if (this.kreslimRetiazku == false) {
                                        this.farba = new Color((int) (Math.random() * 256),
                                                        (int) (Math.random() * 256),
                                                        (int) (Math.random() * 256));
                                        this.kreslimRetiazku = true;
                                }
                                // Nakreslime bodku a zapamatame si jej polohu
                                this.bodka(x, y, this.farba);
                                this.polohaX = x;
                                this.polohaY = y;
                        }
                } else {
                        // Ak sme sa pohli mysou bez zatlaceneho CTRL, tak si poznacime, ze
                        // retiazku nekreslime
                        this.kreslimRetiazku = false;
                }
        }

}