Softwaredesign: Beispiel: Iterator zum Implementieren von default-Methoden für Container

abstract public class ContainerDefaults
    implements Container {
 
    public boolean isEmpty() {
        return card() == 0;
    }
 
    public int card() {
        int res = 0;
        Enumeration i = elements();
 
        while (i.hasMoreElements()) {
            Object e = i.nextElement();
 
            ++res;
        }
        return res;
    }
 
    public int sum() {
        int res = 0;
        Enumeration i = elements();
 
        while (i.hasMoreElements()) {
            Object e = i.nextElement();
 
            res += ((Integer)e).intValue();
        }
        return res;
    }
 
    public Object maximum() {
        Comparable res = null;
        Enumeration i = elements();
 
        while (i.hasMoreElements()) {
            Object e = i.nextElement();
 
            if (res == null || res.compareTo(e) < 0)
                res = (Comparable)e;
        }
        return res;
    }
}

Ein konkreter Container mit nur einer noch zu implementierenden Methode und einer Aufzählungsklasse

import java.util.NoSuchElementException;
 
public class Array
    extends ContainerDefaults {
 
    protected Object [] a;
 
    public Array(Object [] a) {
        this.a = a;
    }
 
    public Enumeration elements() {
        return
            new ArrayEnumeration(this);
    }
 
    // ----------------------------------------
 
    static
    private
    class ArrayEnumeration implements Enumeration {
      Array arr;
      int i = 0;
        
      public ArrayEnumeration(Array arr) {
        this.arr = arr;
      }
      
      public boolean hasMoreElements() {
        return i < arr.a.length;
      }
 
      public Object nextElement() {
        if (! hasMoreElements())
          throw new NoSuchElementException();
 
        return arr.a[i++];
      }
    } // end ArrayEnumeration
}

Ein konkreter Container mit zwei verschiedenen Aufz�hlungsklassen

import java.util.NoSuchElementException;
 
public class Array2
    extends ContainerDefaults {
 
    protected Object [] a;
 
    public Array2(Object [] a) {
        this.a = a;
    }
 
    public Enumeration elements() {
        return
            new ArrayEnumeration();
    }
 
    public Enumeration reverseElements() {
        return
            new ReverseArrayEnumeration();
    }
 
    // ----------------------------------------
 
    // note: nested class to access field a in Array2
 
    private
    class ArrayEnumeration implements Enumeration {
      int i = 0;
        
      public boolean hasMoreElements() {
        return i < a.length;
      }
 
      public Object nextElement() {
        if (! hasMoreElements())
          throw new NoSuchElementException();
 
        return a[i++];
      }
    }
 
    // ----------------------------------------
 
    private
    class ReverseArrayEnumeration implements Enumeration {
      int i = a.length;
        
      public boolean hasMoreElements() {
        return i > 0;
      }
 
      public Object nextElement() {
        if (! hasMoreElements())
          throw new NoSuchElementException();
 
        return a[--i];
      }
    }
}

Fragen

	Wieviele Methoden werden bei einem Aufruf von sum aufgerufen?
	Wieviele Hilfsobjekte werden bei einem Aufruf von sum erzeugt?
	Wieviele Hilfsobjekte werden bei einem Aufruf von maximum erzeugt?
	Kann die Schnittstelle Enumeration vereinfacht werden?
	Kann mit dieser Strategie auch eine allgemeine toString-Methode für Container implementiert werden?
	Wie würde eine Enumeration-Klasse für einen binären Baum zu implementieren sein?
	Was muss allgemein bei rekursiven Strukturen in einer Enumeration-Klasse verwaltet werden?
	Sind geschachtelte Schleifen mit mehreren Iteratoren über den gleichen Container möglich?
	Wenn ja, welche Regeln müssen für die Implementierung der Aufzählungen eingehalten werden?
	Wie fällt ein Vergleich mit dem Strategie-Ansatz aus?

Beispiel: Iterator zum Implementieren von default-Methoden für Container

Eine (unvollständige) Schnittstelle für Container

Eine Schnittstelle für eine Aufzählung

Eine abstrakte Klasse mit vielen default-Implementierungen

Ein konkreter Container mit nur einer noch zu implementierenden Methode und einer Aufzählungsklasse

Ein konkreter Container mit zwei verschiedenen Aufz�hlungsklassen

Fragen