Generics ... help ! ?

[jay vas]

Hi I have a question that has been stumping for about 5 hours !

I want to extend a generic, abstract class...
I cant figure out how to do so, however, in such a
way that the inherited method has a strongly typed
parameter. Ive made an example that can be tested pasted
easily into eclipse

class MyExample
{
static abstract class GenericAbstract <A extends Object>
{
public abstract void doSomething(A a);
}

static class A { }
static class B extends A { }

/** Why cant I simply extend the generic abstract by
* concretely declaring B ? Also - why is it that
doSomething does not override properly ? Isnt that
the point of generics - to allow dynamic definition
of types ? If so - it should let me override by extension.
*
*/
static class ClassThatWontCompile <B> extends GenericAbstract
{
public void doSomething(B b)
{


}

}
}

[Garrett Rowe]

I don't have a compiler where I am now, but I believe this syntax should work:

public class GenericAbstract<T>
{
   public abstract void doSomething(T tee);
}

public class Extension<X> extends GenericAbstract<X>
{
   @Override
   public void doSomething(X ex)
   {
   }
}

[Paul Clapham]

Try this:

 static class ClassThatMightCompile extends GenericAbstract<B> {
  public void doSomething(B b) {
    ....
  }
}

[Henry Wong]

Since Generics are core to Java -- not an external API... moving this to Java in General (Intermediate).

Henry

[Naseem Khan]

Originally posted by jay vas:
Hi I have a question that has been stumping for about 5 hours !

I want to extend a generic, abstract class...
I cant figure out how to do so, however, in such a
way that the inherited method has a strongly typed
parameter. Ive made an example that can be tested pasted
easily into eclipse

class MyExample
{
static abstract class GenericAbstract <A extends Object>
{
public abstract void doSomething(A a);
}

static class A { }
static class B extends A { }

/** Why cant I simply extend the generic abstract by
* concretely declaring B ? Also - why is it that
doSomething does not override properly ? Isnt that
the point of generics - to allow dynamic definition
of types ? If so - it should let me override by extension.
*
*/
static class ClassThatWontCompile <B> extends GenericAbstract
{
public void doSomething(B b)
{


}

}
}

I think you are just mixing the type parameter used in the declaration of GenericAbstract and ClassThatWontCompile with class A and B respectively.

Your declaration of GenericAbstract is :

static abstract class GenericAbstract <A extends Object> {...}

Here A is not the nested class A. Rather its just a type parameter.

Similary in the declaration of ClassThatWontCompile:

static class ClassThatWontCompile <B> extends GenericAbstract{..}

Type parameter B is not the nested class B. Rather agaian its a type parameter. You can use anything here X or Y etc.

When you actually use your class, then you need to provide the type argument, which is in your case nested class A and B.


Is this you are looking for?

class MyExample{
 
static class A { }
static class B extends A { }
 
abstract static class GenericAbstract <X extends A> {
public abstract void doSomething(X a);
}
 
static class ClassWillCompile extends GenericAbstract<B> {
public void doSomething(B b){
 
}
}
}

Naseem

[jay vas]

Thanks ! I figured it out right before you guys left.

Generics are awesome once you finally figure them out.

I know alot of people complain that they are overwhelming and wordy, but
in the age of high power IDEs, wordyness is not a big deal - because its still faster than tracking down an unsafe cast.