Wachsen mit dem Buch "Java ist auch eine Insel"

Diskutiere Wachsen mit dem Buch "Java ist auch eine Insel" im Codeschnipsel u. Projekte Forum; Ich mache gerade das Buch "Grundkurs: Programmieren in Java" durch und bin von einer Aufgabe ebenso sehr begeistert (wenn ich mich das Thema...

  1. Javinner
    Javinner Mitglied
    Ich mache gerade das Buch "Grundkurs: Programmieren in Java" durch und bin von einer Aufgabe ebenso sehr begeistert (wenn ich mich das Thema verstanden habe, dann poste ich es natürlich hier), weil eben dort ebenso eine
    abstrakte Klasse in ein Interface als Mehtode programmiert wurde, welche wiederum von einigen Klassen implementiert wird usw. Diese Bandbreite an Möglichkeiten eben sprengt regelmäßig mein Vorstellungsvermögen und offenbart neue Wege, in welchen ich mich hier und da verirre, sprich: BOOM! :D
     
  2. SchwarzWeiß
    SchwarzWeiß Mitglied
    Das ist kein Interface sondern eine ganz normale Methode, die ein Interface als Rückgabewert hat, oder verstehe ich gerade was falsch?
     
  3. Flown
    Flown Administrator Mitarbeiter
    Das ist eine normale Methode die als Rückgabewert das Interface garanitert und mehr schon nicht. Was hier bei der abstrakten Klasse gemacht wird, ist eine anonyme Klasse zu erstellen. Im Gegenzug zu meinem Beispiel oben wo ich AddOperation erstellt habe, habe ich dieser Klasse keinen Namen gegeben, da ich es nicht direkt ansprechen möchte, sondern nur die Funktionalität benötige.
    Was zurückgegeben wird ist: eine Instanz einer anonymen Klasse -> die von einer abstrakten Klasse erbt -> die ein Interface impelementiert.

    Somit ist der Methodenkontrakt ein Interface zu liefern erfüllt.
    Genau so ist es.
     
  4. Javinner
    Javinner Mitglied
    Habe mich in die innere und anonyme Klassen etwas eingelesen und paar Aufgaben gemacht.
    So richtig werde ich nicht schlau daraus. Aus dem Buch geht hervor:
    Wie alltäglich sind die inneren und anonymen Klassen? Was sagt ihr als Profis?
     
  5. mrBrown
    mrBrown Bekanntes Mitglied
    Anonyme seit Java 8 mit Lambdas und Methodenreferenzen kaum noch, davor grad für Event-Handling ziemlich häufig (keine Ahnung warum dafür innere Klassen genannt werden, hab ich dafür nie verwendet...) ;)

    Innere Klassen durchaus noch - eben dann wenn es sinnvoll ist, zB für Elemente in Containern, zB bei Maps die Einträge, bei verknüpften Listen die Elemente. Beschränkt sich dann im Normalfall auf eine innere Klasse pro äußerer, mehr würde ich auch vermeiden
     
  6. Javinner
    Javinner Mitglied
    OK, Lambdas ist ein Zukunftsthema, da weiß ich noch nichts.
    Was die inneren und äußeren Klassen anbetrifft, so verstehe ich den Sinn (noch) nicht richtig. Ich poste mal die Aufgaben, die ich gemacht habe.
    Innere Klasse: Main (open)

    Code (Java):
    package innereklassen;

    public class InnereKlassen
    {

        /**
         * Main-Methode. Erzeugt ein Zahlenfeld der Laenge 10 und gibt die Zahlen
         * aus.
         */

        public static void main(String[] args)
        {
            Aufzaehlung zahlen = new Aufzaehlung(10);
            for (Folge f = zahlen.folge(); f.elementeVerfuegbar();) {
                System.out.println(f.naechstesElement());
            }
        }

    }

    Innere Klasse: Interface: Folge (open)

    Code (Java):
    package innereklassen;

    /**
    * Erzeuge eine Folge, die den Inhalt repraesentiert.
    */

    public interface Folge
    {

        /**
         * Feld von Zufallszahlen
         *
         * @return true wenn Arraylaenge {@code zahlen} groesser null;
         */

        boolean elementeVerfuegbar();

        /**
         * Liefert das naechste Element zurueck
         * @return das naechste Element von {@code zahlen}
         */

        Object naechstesElement();
    }

    Innere Klasse: Klasse: Aufzaehlung (open)

    Code (Java):
    package innereklassen;

    /**
    * Diese Klasse erzeugt eine Reihe von Zufallszahlen, die man in Form einer
    * Folge durchlaufen kann.
    */

    class Aufzaehlung
    {

        /**
         * Feld von Zufallszahlen
         */

        private final double[] zahlen;

        /**
         * Konstruktor. Erzeugt ein Objekt mit n Zufallszahlen
         *
         * @param n Array {@code zahlen} Laenge
         */

         Aufzaehlung(int n)
        {
            zahlen = new double[n];
            for (int i = 0; i < zahlen.length; i++) {
                zahlen[i] = Math.random();
            }
        }

        /**
         * Gibt die Anzahl der gespeicherten Zahlen aus
         *
         * @return {@code zahlen} Laenge
         */

        protected int length()
        {
            return this.zahlen.length;
        }

        /**
         * Gibt die i-te Zufallszahl zurueck
         *
         * @param i gesuchte Zahl
         * @return {@code zahlen} Zahl {@code i} im Array
         */

        protected double getZahl(int i)
        {
            return zahlen[i];
        }

        private class AneinanderReihung implements Folge
        {

            private int zaehler;

            /**
             * Zeigt an, ob es noch mehr Elemente gibt
             */

            @Override
            public boolean elementeVerfuegbar()
            {
                return zaehler < zahlen.length;
            }

            /**
             * Gibt das naechste Element zurueck und erhoeht den Zaehler.
             */

            @Override
            public Object naechstesElement()
            {
                Double d = zahlen[zaehler];
                zaehler++;
                return d;
            }

        }

        /**
         * Erzeuge eine Folge, die den Inhalt repraesentiert.
         * @return {@code AneinanderReihung}
         */

        protected Folge folge()
        {
            return new AneinanderReihung();
        }

    }

    Anonyme Klasse: Main (open)

    Code (Java):

    package anonymeklasse;


    public class AnonymeKlasse
    {

       
        public static void main(String[] args)
        {
            Aufzaehlung zahlen = new Aufzaehlung(10);
            for(Folge f = zahlen.folge(); f.elementeVerfuegbar(); )
            {
                System.out.println(f.naechstesElement());
            }
        }
    }

    Anonyme Klasse: Interface: Folge (open)

    Code (Java):
    package anonymeklasse;

    public interface Folge
    {

        /**
         * Zeigt an, ob es noch mehr Elemente gibt
         *
         * @return true wenn groesser Null
         */

        boolean elementeVerfuegbar();

        /**
         * Gibt das naechste Element zurueck und erhoeht den Zaehler
         * @return naechstes Object von {@code zahlen}
         */

        Object naechstesElement();
    }

    Anonyme Klasse: Klasse: Aufzaehlung (open)

    Code (Java):
    package anonymeklasse;

    /**
    * Diese Klasse erzeugt eine Reihe von Zufallszahlen, die man in Form einer
    * Folge durchlaufen kann.
    */

    public class Aufzaehlung
    {

        /**
         * Feld von Zufallszahlen
         */

        private final double[] zahlen;

        /**
         * Konstruktor. Erzeugt ein Objekt mit n Zufallszahlen
         *
         * @param n {@code zahlen} Laenge
         */

        public Aufzaehlung(int n)
        {
            zahlen = new double[n];
            for (int i = 0; i < zahlen.length; i++) {
                zahlen[i] = Math.random();
            }
        }

        /**
         * Gibt die Anzahl der gespeicherten Zahlen aus
         *
         * @return aktuelle Laenge von {@code zahlen}
         */

        protected int length()
        {
            return zahlen.length;
        }

        /**
         * Gibt die i-te Zufallszahl zurueck
         *
         * @param i Zahl i im {@code zahlen} Array
         * @return Zahl i
         */

        protected double getZahl(int i)
        {
            return zahlen[i];
        }

        /**
         * Erzeuge eine Folge, die den Inhalt repraesentiert.
         *
         * @return
         */

        protected Folge folge()
        {
            return new Folge()
            {
                /**
                 * Ein Zaehler zeigt an, bei welchem Element wir sind
                 */

                private int zaehler;

                /**
                 * Zeigt an, ob es noch mehr Elemente gibt
                 */

                @Override
                public boolean elementeVerfuegbar()
                {
                    return zaehler < zahlen.length;
                }

                /**
                 * Gibt das naechste Element zurueck und erhoeht den Zaehler
                 */

                @Override
                public Object naechstesElement()
                {
                    Double d = zahlen[zaehler];
                    zaehler++;
                    return d;
                }
            };
        }
    }
     
     
Die Seite wird geladen...

Wachsen mit dem Buch "Java ist auch eine Insel" - Ähnliche Themen

Byte Array wachsen lassen
Byte Array wachsen lassen im Forum Java Basics - Anfänger-Themen
FormLayout dynamisch wachsend
FormLayout dynamisch wachsend im Forum AWT, Swing, JavaFX & SWT
Hilfe bei mitwachsenden Textboxen.
Hilfe bei mitwachsenden Textboxen. im Forum Für Verirrte - Fragen zu JavaScript
letzte Zeile aus wachsender Textdatei auslesen
letzte Zeile aus wachsender Textdatei auslesen im Forum Java Basics - Anfänger-Themen
Mitwachsende JTextArea+ JPanel
Mitwachsende JTextArea+ JPanel im Forum AWT, Swing, JavaFX & SWT
Thema: Wachsen mit dem Buch "Java ist auch eine Insel"