package externesPackage;

import zoohandlung.*;

public class ExterneMainKlasse {

    public static void main(String[] args) {
        Laufen[] tiere = new Laufen[2]; // neues Array für zwei Objekte vom Typ Laufen erstellen

        Papagei p = new Papagei("Ara", 1.3, "Hallo", 40);
        p.setAnzahlBeine(2);

        Loewe leo = new Loewe("Leo", 115);
        leo.setAnzahlBeine(4);

        tiere[0] = p; // p und leo im Array speichern
        tiere[1] = leo;

        int summe = 0; // in Summe steht am Ende die Gesamtzahl der Beine

        for (int i = 0; i < tiere.length; i++) {
            summe += tiere[i].getAnzahlBeine(); // Jetzt geht alles!
        }
        System.out.println(summe);
    }
}
Java

package MySinglyLinkedList1;

import zoohandlung.Tier; // damit der Wert des Inhalts festgelegt werden kann

public class Knoten {

    Tier inhalt;
    Knoten nachfolger;
}
Java

Knoten ersterKnoten = null;
Knoten letzterKnoten = null;

public void add(Tier t) {
    Knoten k = new Knoten(); (1)
    k.inhalt = t; (2)
    if (ersterKnoten == null) { //erstes Element (3)
        ersterKnoten = k;
        letzterKnoten = k;
    } else {
        letzterKnoten.nachfolger = k; (4)
        letzterKnoten = k; (5)
    }
}

package externalPackage;

import MySinglyLinkedList1.MyLinkedList;
import zoohandlung.*;

public class Main1 {

    public static void main(String[] args) {
        MyLinkedList mll = new MyLinkedList(); (1)
        for (int i = 0; i < 10; i++) {
            Loewe l = new Loewe("Leo" + i, Math.random()); (2)
            mll.add(l); (3)
        }
        mll.printAll(); (4)
    }
}

import zoohandlung.Tier; // damit der Wert des Inhalts festgelegt werden kann

public class Knoten {

    Tier inhalt;
    Knoten nachfolger;
}
Java

package MySinglyLinkedList1;

import zoohandlung.Tier; // damit der Wert des Inhalts festgelegt werden kann

public class Knoten {

    Tier inhalt;
    Knoten nachfolger;
}
Java

public void add(Tier t) {
    ...
}

package MySinglyLinkedList2;

public class Knoten {

    Object inhalt;
    Knoten nachfolger;
}
Java

Knoten<String> k = new Knoten<>();

public class MyLinkedList<T> {

    Knoten<T> ersterKnoten = null;
    Knoten<T> letzterKnoten = null;

    public void add(T t) {
        Knoten<T> k = new Knoten<>();
        ...
    }

    public void printAll() {
        Knoten<T> aktuellerKnoten = ersterKnoten;
        ...
    }
}
Java

public static void main(String[] args) {
    MyLinkedList<Tier> mll = new MyLinkedList<>();
    for (int i = 0; i < 10; i++) {
        Loewe l = new Loewe("Leo" + i, Math.random());
        mll.add(l);
    }
    mll.printAll();
}
Java

MyLinkedList<String> mll = new MyLinkedList<>();

String[] text=new String[]{"bla","blubb","blobb"};

for (String t:text){
    System.out.println(t);
}
Java

for (int i = 0; i < text.length; i++){
    System.out.println(text[i]);
}
Java

MyLinkedList<Tier> mll = new MyLinkedList<>();
for (int i = 0; i < 10; i++) {
    Loewe l = new Loewe("Leo" + i, Math.random());
    mll.add(l);
}

for (Tier t : mll) { // das wäre schön!
    System.out.println(t);
}
Java

public class MyLinkedList<T> implements Iterable<T> {

    ...

    @Override
    public Iterator<T> iterator() {
        ...
    }
}
Java

public class MyLinkedList<T> implements Iterator<T>, Iterable<T> {

    ...

    public boolean hasNext() {
        ...
    }

    public T next() {
        ...
    }

    public Iterator<T> iterator() {
        return this;
    }
}
Java

public boolean hasNext() {
    boolean rueckgabe = aktuellerKnoten != null;
    if (rueckgabe == false) {
        aktuellerKnoten = ersterKnoten;
    }
    return rueckgabe;
}
Java

package MySinglyLinkedList4;

import java.util.Iterator;

public class MyLinkedList<T> implements Iterator<T>, Iterable<T> {

    Knoten<T> ersterKnoten = null;
    Knoten<T> letzterKnoten = null;
    Knoten<T> aktuellerKnoten = null;

    public void add(T t) {
        Knoten<T> k = new Knoten<>();
        k.inhalt = t;
        k.inhalt = t;
        if (ersterKnoten == null) { //erstes Element
            ersterKnoten = k;
            letzterKnoten = k;
            aktuellerKnoten = k;
        } else {
            letzterKnoten.nachfolger = k;
            letzterKnoten = k;
        }
    }

    @Override
    public boolean hasNext() {
        boolean rueckgabe = aktuellerKnoten != null;
        if (rueckgabe == false) {
            aktuellerKnoten = ersterKnoten;
        }
        return rueckgabe;
    }

    @Override
    public T next() {
        T rueckgabe = aktuellerKnoten.inhalt;
        aktuellerKnoten = aktuellerKnoten.nachfolger;
        return rueckgabe;
    }

    @Override
    public Iterator<T> iterator() {
        return this;
    }
}
Java

MyLinkedList<Tier> mll = new MyLinkedList<>();
for (int i = 0; i < 10; i++) {
    Loewe l = new Loewe("Leo" + i, Math.random());
    mll.add(l);
}

for (Tier t : mll) {
    if (t instanceof Laufen) {
        System.out.println(((Laufen) t).getAnzahlBeine());
    }
}
Java