# Addition generischer Datentypen



## DerDenker (30. Jan 2008)

Hi Leute!


Ich hab ein Problem, undzwar habe ich folgende Methode:


```
List<E> action(List<E> l, E var){
        
          
        int i; // Laufindex
	final E konstante; // meine Konstante, die ich addieren will
	E puffer; // ein Zwischenspeicher
		
	for(i=0;i<l.size();i++){
        
		 puffer=l.get(i); // ich nehme mir das Listenelement an der Stelle i = laufindex
		 puffer=puffer+konstante; // und packe da die Konstante zu
		 
		 		
			
	                                 
                }
                return l;
	}
```

Ja, hast Dir gedacht sagt mir da der Compiler:


```
Operator + cannot be applied to E, E
```


Kann mir jemand sagen, wie ich denn nun generisch die einzelnen Listenelemente aufwerte mit der Konstanten? Irgendwie komme ich da leider nicht weiter und würde mich über Hilfe freuen!


Danke,
DerDenker


----------



## SlaterB (30. Jan 2008)

du weißt doch gar nicht was E ist, was soll das Programm machen, wenn als E JFrame übergeben wird?

wie willst du eine Konstante definieren, die in deinem Code übrigens noch fehlt?

das ganze macht keinen Sinn und geht daher korrekterweise auch nicht

das + kannst du überhaupt nur für primitive Datentypen und String verwenden,
erstere sind ganz schlecht auf Generics zu sprechen (wie auf alles objektorientierte),
letztere ist final, es kann keine Subklasse geben, Generics überflüssig


----------



## Leroy42 (30. Jan 2008)

DerDenker hat gesagt.:
			
		

> Kann mir jemand sagen, wie ich denn nun generisch die einzelnen Listenelemente aufwerte mit der Konstanten? Irgendwie komme ich da leider nicht weiter und würde mich über Hilfe freuen!



Was meinst du mit _aufwerten_?  :shock: 

Addieren (*+*) geht nur mit primitiven Datentypen oder Strings. Für alles andere
mußt du Methoden aufrufen.


----------



## DerDenker ist verwirrt :) (30. Jan 2008)

Hi!


```
List<E> action(List<E> l, final E konstante){
        
        // final = Schluesselwort wegen const.
        // E = generisch , var = uebergebener Wert
        
	/*
	 * Diese Klasse kann eine Konstante zu einer Liste
	 * addieren 
	 *     
	 */
	   
        int i;
	E puffer;
		
	for(i=0;i<l.size();i++){
        
		l.get(i)=l.get(i)+konstante;
                                 
                }
                return l;
	}
```

So hatte ich das erst gedacht, also direkt die Listenelemente zu holfen. Auch das funktioniert natürlich nicht, da das "+" zu primitiv ist. In diese Liste kommen erst mal nur Int Werte, dann Doubles rein. Ergo sollte sich doch eine x-beliebige Konstante zu diesen "addieren" lassen.
Mir ist nicht klar wie ich das realisiere...


----------



## DerDenker (30. Jan 2008)

Leroy42 hat gesagt.:
			
		

> DerDenker hat gesagt.:
> 
> 
> 
> ...




Okay... welche denn? Bzw... wie sollen die denn aussehen, wenn ich ohne + addieren soll? 
Sorry, wenn die Frage dumm ist, aber ohne "+" ist da nicht viel zu machen...


----------



## exi (30. Jan 2008)

Hallo,

was du 'E' nennst ist irgendetwas das von Oject() abgeleitet ist - mehr nicht. Der Interpreter weiß gar nicht, daß du darin Zahlen sehen willst. Also solltest du 'E' ausführlich als Klasse anlegen und mit allen gettern/settern und Methoden versehen die du brauchst.

```
public class E {
    int Inhalt=0;

    public E() {}
    public E(int eingabe) {Inhalt=eingabe}
    public int getInhalt() {return Inhalt;}
    public int addiere(int summand) {return Inhalt+summand;}
}
```

um dann im Programm mit


```
puffer=I.get(i);
    puffer = konstante.addiere(puffer);
```

zuzugreifen. 
Bei Bedarf, und je nachdem was denn I für Dinger beinhaltet, mußt du natürlich noch casten oder dir die Zahl sonstwie geben lassen. Also mit (int)I.get(i), oder mit ((Integer)(I.get(i)).intValue() falls I Integer-Werte enthält zugreifen.
Falls du aber ein intuitiveres Überschreiben des Operators '+' haben möchtest, dann mußt du schon die Sprache wechseln. In C++ ginge auch das.

tschüs
exi


----------



## Marco13 (30. Jan 2008)

Ein anderer Ansatz wäre sowas wie

```
interface Addable
{
    void add(Addable other);
}

class Blablub implements Addable
{
    int value; 

    public void add(Blablub other) { this.value += other.value; }
}

List<E extends Addable> action(List<E> l, E var)
{ 
    ...
        listElement.add(konstante);
}
```


----------



## Denker (30. Jan 2008)

Hi!

In diesem Falle, es wäre so schön einfach, würde ich Integer-Werte addieren, und E von einem generischen Typ in einen primitiven wandeln. 
E ist bei mir hier... (ich habs auch doof beschreiben) gewollt generisch. 

Das muss so sein, damit ich double, ints, Strings in diese Liste<E> fügen kann. 

Sinn ist es gerade, dass diese Liste<E> eine Liste nicht nur Integer-Liste ist, sondern eben auch als Template für eine Double Liste. Das widerspräche dann aber E() hier.
E da als Integer zu definieren... da muss ich für Double doch wieder von vorne anfangen?



```
public static void main(String[] args) {
        List<Integer> l = new LinkedList<Integer>();
        l.add(new Integer(0));
        l.add(new Integer(1));
        l.add(new Integer(2));
        l.add(new Integer(3));
        l.add(new Integer(4));
        
	       
	Map<Integer> mi = new Map<Integer>();
        System.out.print("Inhalt der Integer-Liste:");
        
	l = mi.map(l,oi);
        
	System.out.println();
```

In dieser Main Klasse erzeuge ich Liste l.

Und ich gebe sie aus:


```
import java.util.*;

public class Map<E>{

  
    public List<E> map(List<E> l, Output<E> oi){
            List<E> NewMap = oi.action(l);
            return NewMap;
    }
}
```

Die Rückgabe, die in System.out.println gelangt ist nicht anderen Types.

Jetzt habe ich lediglich vor auf jedes Listenelement die Konstante 2 zu addieren. 

Es kann doch nicht sein, dass der Compiler nicht weiss, dass in der Liste Integer Werte sind... Trotz dessen, dass es eine List<E> sollte man da doch eine Addition durchführen können 

Komische Kiste...


----------



## Wildcard (30. Jan 2008)

Man kann auch keine Integers oder Doubles addieren.


----------



## Leroy42 (30. Jan 2008)

Wildcard hat gesagt.:
			
		

> Man kann auch keine Integers oder Doubles addieren.



Doch! Mit Auto_boxing_/_unboxing_

 :bae:


----------



## SlaterB (30. Jan 2008)

du wirst nicht drumherum kommen, für Integer und Double usw. Wrapperklassen zu erstellen,
sowas nach Art von Addable von Marco13 aber auch 'public class E' geht in die Richtung,
nur eben mehrfach für Double, Integer usw.,
kleine Klassen, die nur add() + vielleicht noch createKonstante() definieren müssen,
und die dann alle mit deiner generischen action()-Operation arbeiten können


----------



## Denker (30. Jan 2008)

Okay Danke... dann weiß ich, dass ich da leider nicht drumherum komme... denn das hab ich die ganze Zeit versucht.


Dankeschön!


----------



## Marco13 (31. Jan 2008)

Naja, wenn du dort Integer, Double und String reinstecken willst, wäre ein anderer Ansatz vielleicht besser: Ein Adder. (Ähnlich eingesetzt wie ein Comparator - ggf. mal Web- oder Forensuche starten).

Dann hättest du sowas wie

```
abstract class Adder<Type>
{
    abstract Type add(Type a, Type b);
}

class IntegerAdder extends Adder<Integer>
{
   Integer add(Integer a, Integer b) 
   {
       int ia = a.intValue();
       int ib = b.intValue();
       return new Integer(ia + ib);
   }
}

List<E> action(List<E> l, E var, Adder<E> adder)
{
    ...
        listElement = adder.add(listElement, konstante);
}


// Aufruf
List<Integer> list = action(list, someInteger, new IntegerAdder());
```
(nur schnell hingeschrieben, um die Idee zu verdeutlichen)


----------

