Multiplikation bei Generics

[bRainLaG]

Nachdem ich mich ja erst über die Multiplikation innerhalb einer Liste bewandert habe, habe ich nun das Problem, das ich aufgrund dessen das mein Wert generisch gewählt ist, die Multiplikationszeile nicht funktioniert.
Hat da jemand ne Ahnung wie ich das verändern muss, damit das optimal funktioniert.

Node class:

public class LinkedList<T>  implements Iterator<T>, Serializable	{
	
	
	private class Node<T> {
		
		Node<T> next;
		T value;
		
		Node(){
			
		}
		Node(T value, Node<T> next){
			
			this.value = value;
			this.next = next;
		}
	}

und meine Fold Methode:

void fold (){
		
		Node ptr = head;
		Node next = ptr.next;
		
		double produkt = 1;
		for(;;){
		if (ptr != null) {
		  produkt = produkt * ptr.value;
		  ptr = next;
		}
		else System.out.print(produkt);
		}
	}

 

[faetzminator]

Am einfachsten sollte T noch von irgendwas ableiten, was eine Methode zur Verfügung stellt, welche die Daten als [c]double[/c] zurückgeben. Dazu kannst du T entweder von Number (Java Platform SE 6) ([c]doubleValue()[/c]) oder von einem eigenen Interface ableiten lassen. Der Codeausschnitt könnte dann z.B. [c]LinkedList<T extends Number> implements Iterator<T extends Number>[/c] und [c]Node<T extends Number>[/c] lauten.

 

[fastjack]

 produkt = produkt * ptr.value;

ptr.value ist vom Type T, d.h. Object.

Multiplikation funktioniert nicht mit Object. Ich würde versuchen die Funktion in fold irgendwie herauszulösen (abstrakt gestalten etc.), da fold denke ich generell eine Funktion auf die Elemente ausführen soll. Diese Funktion muss dann speziell implementiert werden.

 

[bRainLaG]

was wäre wenn ich mir irgendwie eine zusätzlichen Typ erschaffe zB V kann ich diesen, dann irgendwie von bestimmten Typen machen, also mehreren beispielsweise long double int?

 

[faetzminator]

Der Typ kann nicht primitiv sein, also muss er vom Typen Integer, Float, Double, ... sein. Und genau diese Typen erben vom von mir verlinkten Typen Number.

 

[fastjack]

Muß fold nicht eigentlich so sein, daß es eine Funktion auf die Elemente einer Liste abbildet. ? Also so : fold(Fucntion f) ?

 

[bRainLaG]

nein bei mir soll sie so funktionieren, das ich mit ihr das Produkt einer Liste ausgeben kann.

 

[Wladimir]

Ich würde für den fall eine statische Method einführen welche für Listen des specifischen Typs spezifische Operationen ausführt. Der Rest der LinkedList kann gleich bleiben, nur muss die Klasse Node noch auf static gesetzt werden.

	public static double fold(LinkedList<Double> list) {
		Node<Double> ptr = list.head;
		double produkt = 1;
		while (ptr != null) {
			produkt = produkt * ptr.value;
			ptr = ptr.next;
		}
		return produkt;
	}

 

[Landei]

Ich würde eine generische fold-Funktion schreiben, und ein passendes Operator-Objekt mitliefern:

    public interface BinaryOp<T>{
        T eval(T a, T b);
    } 

    //für allgemeine Number-Listen:
    public class NumberMultiplicator extends BinaryOp<Number> {
         public Number eval(Number a, Number b) { return a.doubleValue() * b.doubleValue(); }    
    }

    //oder besser das, wenn du schon eine Double-Liste hast:
    public class DoubleMultiplicator extends BinaryOp<Double> {
         public Double eval(Double a, Double b) { return a * b; }    
    }

    public static <T> T fold(LinkedList<? extends T> list, Op<T> op) {
        Node<T> ptr = list.head;
        T result = null;
        while (ptr != null) {
            result = (result == null) ? ptr.value : op.eval(result, ptr.value);
            ptr = ptr.next;
        }
        return result;
    }

   ...
   LinkedList<Double> list = ...
   Double product = fold(list, new DoubleMultiplicator());

 

[fastjack]

So kenn ich fold auch