Re: How to specify an undetermined Object (Generic) as parameter in method() ?

Gianni Galore wrote:


markspace wrote:


That's a really good question. It's all about what you want to assert about
the type relationships. If there's no constraint that the base type of the
returned set match the 'inparm1' (should be 'inParm1', or better, 'in1'). then
'Object' is fine.

I'm confused by the use of 'AAA'. Is that meant as a type parameter or a
type? If the former, it should be 'A'. If the latter, it should be 'Aaa'.
I'm going to assume the former and presume that someone who knows the OP's
intent will correct me if necessary. Also, hopefully the OP will have read by
now the helpful links posted upthread:


If you want to constrain the type of 'in1' to match the base type of the
returned set, and assuming a generic method rather than a generic class, you
want something like this :

  public <A> Set <A> doSomething( A anA, Set <Beech> someBeeches )


If there were, you could assert it with generics, something like:

  public <A> Set <A> doSomething( A anA, Set <? extends A> someBeeches )

or whatever the type relationship is.

/* Foo
  */
package com.lewscanon.foo;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

/** Foo.
  */
public class Foo
{
     public static void main( String [] args )
     {
         new Foo().runFoo();
     }

     private final Random rand = new Random();

     /**
      * Run Foo.
      */
     public void runFoo()
     {
         Set <Beech> someBeeches = new HashSet <Beech> ();
         for ( int ix = 0, mx = rand.nextInt(17); ix < mx; ++ix )
         {
             someBeeches.add( new Beech(ix) );
         }

         Set <Beech> somethings = doSomething( someBeeches );

         System.out.println( "someBeeches "+ someBeeches
             +"\n somethings "+ somethings );
     }

     /**
      * Do something!
      * @param <A> first type.
      * @param <B> extending type.
      * @param someBeeches Set to convert.
      * @return Set as converted.
      */
     public <A, B extends A> Set <A> doSomething( Set <B> someBeeches )
     {
         Set <A> rets = new HashSet <A> ();
         for( B beech : someBeeches )
         {
             rets.add( beech );
         }
         return rets;
     }

}

class Beech
{
     private final int marker;

     /**
      * Constructor.
      * @param mark int marker value.
      */
      Beech( int mark )
     {
         marker = mark;
     }

     /**
      * Get marker.
      * @return int marker.
      */
     public int getMarker() { return marker; }

     @Override
     public boolean equals( Object obj )
     {
         return obj != null && getClass().equals( obj.getClass() )
             && this.marker == ((Beech) obj).marker;
     }

     @Override
     public int hashCode()
     {
         return marker;
     }

     @Override
     public String toString()
     {
         return String.valueOf( marker );
     }

}

--
Lew
Ceci n'est pas une pipe.