объектно-ориентированная сумма элементов в матрице

interface Visitor {
    void visit(Item)
}

interface Visitable {
    void visit(Visitor);
}

class Item implements Visitable {
    public float v; // Знаю что плохо, но лень
    public void visit(Visitor v) { v.visit(this); }
}

class MatrixRow extends Vector<Item> implements Visitable  {
    public void visit(Visitor v) {
        Enumeration<Item> items = this.enumeration();
        while (items.hasMoreElements()) items.nextElement().visit(v);
    }
}

class Matrix extends Vector<MatrixRows> implements Visitable {
    public void visit(Visitor v) {
        Enumeration<MatrixRow> items = this.enumeration();
        while (items.hasMoreElements()) items.nextElement().visit(v);
    }
}

class SummaryVisitor implements Visitor {
    float s = 0;
    public void visit(Item i) { if (i!=null) s += i.v; }
    public void reset() { s = 0; }
    public float getsum() { return s; }
}
....
    Matrix m = ...;
    SummaryVisitor summarer = new SummaryVisitor();
    m.visit(summarer);
    System.out.println("Sum="+summarer);
...

SummaryVisitor summarer = new SummaryVisitor();
m.visit(summarer);

public enum InterfaceImplFactory {
    INSTANCE;
 
    private static class MatrixInterfaceImplHolder { 
            public static final MatrixInterfaceImpl INSTANCE = new MatrixInterfaceImpl();    
    }
 
    public static MatrixInterfaceImpl getMatrixInterfaceImpl() {
           return MatrixInterfaceImplHolder.INSTANCE;
    }

(defclass matrix ()
  ((data :reader data)))

(defmethod initialize-instance :after ((self matrix) &key
                                       (rows 1) (cols 1) (initial-element 0)
                                       (from #2A((0)) from-supplied-p))
  (setf (slot-value self 'data)
        (if from-supplied-p from
            (make-array `(,rows ,cols) :initial-element initial-element))))

(defmacro matrix-rows (matrix)
  `(first (array-dimensions (data ,matrix))))

(defmacro matrix-cols (matrix)
  `(second (array-dimensions (data ,matrix))))

(defmacro matrix-dimensions (matrix)
  `(array-dimensions (data ,matrix)))

(defmacro matrix-do ((row-index rows col-index cols) &body body)
  `(dotimes (,row-index ,rows)
     (dotimes (,col-index ,cols)
       ,@body)))

(defmacro matrix-reference (matrix row col)
  `(aref (data ,matrix) ,row ,col))

(defun matrix-ref (self row col)
  (matrix-reference self row col))

(defmacro matrix-tabulate ((matrix row-arg col-arg) &body body)
  `(progn
     (matrix-do (,row-arg (matrix-rows ,matrix) ,col-arg (matrix-cols ,matrix))
       (setf (matrix-ref ,matrix ,row-arg ,col-arg) ,@body))
     ,matrix))

(defun matrix-*-into (target left right)
  (if (and (equal (matrix-cols target) (matrix-cols right))
           (equal (matrix-rows target) (matrix-rows left)))
      (matrix-tabulate (target t-i t-j)
        (do ((i 0 (1+ i))
             (s 0 (+ s (* (matrix-ref left t-i i)
                          (matrix-ref right i t-j))))) 
            ((= i (matrix-cols left)) s)))        
      (error "Operation can not be performed")))