Hemal Pandya wrote:

See below for SSCCE (60 lines, short enough I hope)

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.