Re: Extracting Class names in Abstract classes with Generics.
Hemal Pandya wrote:
Ian Wilson wrote:
I have this working:
[....]
class Zap extends Foo<Apple> {
fooFun(new Apple());
// I want my Audit log to say "Apple had ..."
Far as I can tell it already says that. Can you post actual code sample
that compiles and runs? Please use System.out.println in place of
Audit.
See below for SSCCE (60 lines, short enough I hope)
Perhaps you don't want to have to pass the Apple to fooFun and still
have it print Apple? That would not work, I think. It has to do with
Type Erasure, about which you can R in T M, Java Language Spec
actually. The best you can do is to accept a Class object in your
constructor, but that is error prone.
Now that I've pondered what you and Daniel have said, I suspect that
Erasure really prevents me doing what I want in Foo's constructor.
On reflection, I seem to be spending too much effort worrying about
writing lots of "o.getClass().getSimpleName()" instead of "eName" :-)
I also try to keep statements to one line and dislike it when I have to
split them across multiple lines. However there's a limit to the amount
of effort I'll put into avoiding this.
I doubt there's much of an efficiency gain either but I first learned
programming with Fortran and it was drilled into me that I should avoid
calling functions more often than strictly necessary. Old habits are
hard to break.
I think the best I can do is declare String className in abstract class
Foo and then assign it in my concrete subclasses Zap and Zog. In reality
I have dozens of such subclasses.
-------------------------------------8<------------------------
public class GenericErasureProblem {
public static void main(String[] args) {
Zap zap = new Zap();
Zog zog = new Zog();
}
}
abstract class Foo<E> {
String className;
Foo() {
// below is WRONG, says "Zap" or "Zog", want "Apple" or "Brick".
eName = this.getClass().getName();
}
void fooFun(E o) {
System.out.println("FooFunned a "+eName);
// below works but I wanted to avoid having this in every method
// System.out.println(
// "FooFunned a "+o.getClass().getSimpleName());
}
void fooFiz(E o) {
System.out.println("FooFizzed a "+eName);
}
void fooFar(E o) {
System.out.println("FooFarred a "+eName);
}
void fooFie(E o) {
System.out.println("FooFied a "+eName);
}
}
class Apple {
String colour;
Apple(String colour) {
this.colour = colour;
}
}
class Brick {
int weight;
Brick(int weight) {
this.weight = weight;
}
}
class Zap extends Foo<Apple> {
Zap() {
Apple apple = new Apple("Red");
fooFun(apple);
fooFar(apple);
}
}
class Zog extends Foo<Brick> {
Zog() {
Brick brick = new Brick(12);
fooFun(brick);
fooFiz(brick);
fooFie(brick);
}
}
-------------------------------------8<------------------------
P.P.S. My AuditLog.memo() call is actually used like this ...
void fooFar(E o) {
AuditLog.memo("objectname", "action", o.toString());
}
Maybe I can change this to pass o and then maybe I can hide
o.getClass().getSimpleName in AuditLog.memo() somehow.