Re: abstract classes and generic types
horos11@gmail.com wrote:
I'm trying to overcome the following problem. I'd like to have an
abstract class contain common functionality for subclasses, but I
don't want to be limited by the representations of them. For example:
abstract class a
Class names should begin with an upper-case letter, and comprise compound word
parts, each subsequent part also beginning with an upper-case letter. This
mixed-case convention is called "camel case". Thus, the class name should be "A".
{
String calculate() { return this.put(this.my_func()); }
Method and variable names other than of constants should begin with a
lower-case letter and thereafter be in camel case. Underscores should not be
in such names. Thus, "myFunc()" (although "Func" in a function name is
redundant and useless).
'class B extends A'
'mySet' (although "Set" in the name of a set is actually silly and somewhat
harmful to refactoring).
Integer my_func() { return (1); }
void put(Integer myint) { myset.put(myint); }
}
class c extends a
{
Set<Float> myset;
Float my_func() { return(1.0); }
void put(Float myfloat) { myset.put(myfloat); }
}
As it stands, if I put the return types, etc. [sic] in the abstract class it
gets exceedingly ugly because implementation details are seeping into
the abstract class and it would need to be updated with new function
signatures each time a new subclass is created. I need to find a way
to say that any given method is *purely* abstract, ie: that it will be
defined solely in the subclass.
Is there a way to do this, or am I pretty much stuck reimplementing
lots of functionality in each subclass?
Generics, along the lines Giovanni Azua showed you.
Giovanni Azua wrote:
How about:
public abstract class A<N extends Number> {
void calculate() { put(my_func()); }
abstract N my_func();
void put(N myN) { set.add(myN); }
private final Set<N> set = new HashSet<N>();
}
public class B extends A<Long> {
@Override
Long my_func() { return Long.valueOf(1); }
}
AFAIK you can't do A generic without ressorting to reflection to get hold of
the right constructor for the Number subclass.
I don't understand what you mean exactly. 'A' is generic as you show it here.
'my_func()' should be named in accordance with the naming conventions, and
meaningfully, say 'getValue()'. The methods should probably be 'public'.
(And, of course, the classes should belong to packages.)
--
Lew