generische Klasse als Parameter einer generischen Klasse

[Gast_Claudia]

Hallo Java-Fans und Nicht-Fans =)
Derzeit beschäftige ich mich mit generischen Klassen, komme damit auch ganz gut klar, aber trotzdem habe ich ein kleines Problemchen, bei dem ihr mir vielleicht helfen könnt:

public class Range<T> {
	private T start;
	private T end;
	
	public Range(T start, T end) {
		this.start = start;
		this.end = start;
	}
	
	public T end() {
		return this.end;
	}
	
	public T start() {
		return this.start;
	}
}

Ich möchte, dass diese Klasse nur numerische Typen ("<T extends Number>") und Typen von sich selbst aufnehmen kann. Kleines Beispiel: eine Strecke fängt bei mindestens 0 und maximal 1 an und endet bei 6.

Range r = new Range(new Range(0,1),6);
System.out.println("minimaler Start: " + r.start().start());
System.out.println("maximaler Start: " + r.start().end());
System.out.println("Ende: " + r.start().start());

weitere mögliche Szenarien:
die einfachste Anforderung:
Start = 0;
Ende = 1;

Start beginnt frühestens bei 4, spätestens bei 9 usw...):
Start =
- Start = 4
- Ende = 9
Ende =
- Start = 18
- Ende = 22

diese Typen sollen "unendlich" ineinander verschachtelbar sein.
Hat wer eine Idee?

 

[Grasstampfer]

man kann - meines wissens - nicht eine ODER bedingung definieren.... d.h. du kannst entweder definieren, dass es dein Parameter Number ist bzw dass vom Typ Range is bzw vom Typ Number UND Range.

aber nicht dass es vom Typ Number oder vom Typ Range ist....

wie sollte es auch - damit ist ja waehrend des compilierens nicht klar um welchen Typ es sich handelt....

 

[Marco13]

Hmja, wie Grasstampfer schon gesagt hat, so ein "oder" ist schwierig - vor allem hat man ja ein Problem, weil man nie weiß, was man bekommt:
??? s = range.start(); // Ist das, was man bekommt, ein Range oder eine Number?

Also, bei deinem Beispielcode hattest du ja die Typparameter weggelassen. Wenn man da eine "unendlich" tiefe Verschachtelung braucht, dann braucht man ja auch "unendlich" viele Typparameter :autsch: Wie häßlich das wird, sieht man schon an diesem kleinen Beispiel ... das dem, was du vorhattest zwar relativ nahe kommt, aber trotzdem schon SEHR fragwürdig ist - ein Range IST eigentlich keine Number!... :?

class RangeTest
{
    public static void main(String args[])
    {
        Range<Range<Integer, Integer>, Integer> r = new Range<Range<Integer, Integer>, Integer>(new Range<Integer, Integer>(0,1),6);
        System.out.println("minimaler Start: " + r.start().start());
        System.out.println("maximaler Start: " + r.start().end());
        System.out.println("Ende: " + r.end());
    }
}


class Range<T extends Number, U extends Number> extends Number
{
   private T start;
   private U end;

   public Range(T start, U end)
   {
      this.start = start;
      this.end = end;
   }

   public T start()
   {
      return this.start;
   }

   public U end()
   {
      return this.end;
   }


    public byte byteValue()
    {
        return start.byteValue();
    }

    public double doubleValue()
    {
        return start.doubleValue();
    }

    public float floatValue()
    {
        return start.floatValue();
    }

    public int intValue()
    {
        return start.intValue();
    }

    public long longValue()
    {
        return start.longValue();
    }

    public short shortValue()
    {
        return start.shortValue();
    }
}

Eine andere Möglichkeit wäre, dass Ranges immer nur andere Ranges enthalten, aber dann muss man irgendwie testen können, ob ein Range "leer" ist (d.h. eine Zahl enthält...) Auch nicht so toll... :?

class RangeTest
{
    public static void main(String args[])
    {
        Range<Integer> r = new Range<Integer>(new Range<Integer>(0,1),new Range<Integer>(6));
        System.out.println("minimaler Start: " + r.start().start());
        System.out.println("maximaler Start: " + r.start().end());
        System.out.println("Ende: " + r.end());
    }
}


class Range<T extends Number>
{
   private Range<T> start;
   private Range<T> end;
   private T value;

   private boolean empty = false;

   public Range(T startValue, T endValue)
   {
      this.start = new Range<T>(startValue);
      this.end = new Range<T>(endValue);
   }

   public Range(Range<T> start, Range<T> end)
   {
      this.start = start;
      this.end = end;
   }

   public Range(T value)
   {
      this.value = value;
      empty = true;
   }

   public Range<T> start()
   {
      return this.start;
   }

   public Range<T> end()
   {
      return this.end;
   }

   public T value()
   {
      return value;
   }

   public boolean isEmpty()
   {
       return empty;
   }

   public String toString()
   {
       if (empty)
       {
           return value.toString();
       }
       else
       {
           return "["+start.toString()+","+end.toString()+"]";
       }
   }

}

Je nachdem, was du später mit diesen Ranges machen willst, solltest du dir vielleicht was anderes überlegen... oder mal genauer beschreiben, was da rauskommen soll....

Aber vielleicht hat noch jemand eine geschicktere Idee....

 

[Gast_Claudia]

Tja, was soll eigentlich rauskommen... eben ein flexibler generischer Typ
Aber du hast Recht, man kann ja dann nie genau sagen WAS nun das Return ist - das macht ein Compile schonmal unmöglich.

Wenn mans sich anschaulich macht, dann entspräche der Code etwa einem selbst geformten variablen Baum, der nur aus numerischen Früchten und Ästen besteht.
jeder Ast kann sich theoretisch unendlich aufzweigen, hat aber an den Enden immer eine Frucht
dieser Baum soll so einfach wie nur möglich auswertbar sein.

Das wäre dann eine Klasse für alles...
praktische Verwendung hätte ich jetzt nicht, aber eine interessante Überlegung ists denk ich allemal.

 

[Grasstampfer]

dann würde ich eher eine typische verkette Liste nehmen um dann nicht, wie schon beschrieben in sachen wie

Range<Range<Range<Range<Range<Range<Range<Range<Range<Range<Range>>>>>>>>> // oder wieviele auch immer

zu kommen.

 

[Marco13]

Wenn du von einem "Baum" redest, wäre das eher wir das zweite Beispiel, was ich gepostet hatte.... das IST ja ein Baum, dessen Knoten "Range"-Objekte sind. Die Blätter dieses Baumes sind die "leeren Ranges", und nur die können (sollten) eine Value enthalten. Ggf. kann man sich dann auch Methoden schreiben, die das Traversieren übernehmen, womit die Abfragen auf "isEmpty" weitgehend wegfallen...

class Range<T extends Number>
{
   private Range<T> start;
   private Range<T> end;
   private T value;

  ...

   public T getMin()
   {
        if (start == nul && end == null)
        {
            return value;
        }
        return start.getMin();
    }

  ...
}

Wie gesagt, kommt halt alles auf den Anwendungsbereich an...