Argh. "Cannot create class in system package." So I can't use the constructor
unless I'm in the package and I can't be in the package, and without the
constructor I can't create a subclass.

Part of the problem is that since this has to run under the cellular device
emulator, I don't have much control over the environment.

       Hugh

You can do this in some cases, but it is not generally a good idea.  As
you found, sometimes you can't do it at all.

To subclass any class you need access to a constructor.

If a constructor does not explicitly invoke a superclass constructor
then an invocation of super() is implicit.

It has to be a subclass of the class that the API uses.  But that class
probably isn't javax.microedition.lcdui.Graphics -- it's probably a
superclass of that class.  If it is, then it is certain that that class
has a protected constructor, or even a public one.

Remember that your subclass will not be doing anything directly -- it
can't, because it won't have anything of its own to paint _on_.  It must
wrap a system-provided Graphics, as I described in my last message.
Here's a schematic example for a simple API to which the principle can
be applied:

package wb.acme.products;

import wb.Coyote;

public abstract class Anvil {

    protected Anvil() {}

    public squashCoyote(Coyote c) {}
}

==

package wb.acme.products.fy2004;

public class AnimatedAnvil {
    AnimatedAnvil(int weight) {}

    public squashCoyote(Coyote c) {}

    public int getWeight() {}
}

==

package wb;

import wb.acme.products.Anvil;

public class RoadRunner {

    Coyote hunter;

    public void kickAnvil(Anvil a) {
        a.squashCoyote(hunter);
    }
}

===

Now suppose that an AcmeProductFactory provides a method that produces
Anvils.  In fact, the runtime class of these objects is
wb.acme.products.fy2004.AnimatedAnvil in the current version of the
factory.  Given an Anvil obtained in that way, you want to generate some
effect when its squashCoyote(Coyote) method is invoked (a log, a
fadeout, an epitaph...).  You cannot subclass
wb.acme.products.fy2004.AnimatedAnvil, but you don't need to -- you only
need to subclass wb.acme.products.Anvil, like so:

package mypackage;

import wb.acme.products.Anvil;
import wb.Coyote;

public class AugmentedAnvil extends Anvil {
    private final Anvil innerAnvil;

    public AugmentedAnvil(Anvil a) {
        innerAnvil = a;
    }

    public squashCoyote(Coyote c) {
        innerAnvil.squashCoyote(c);
        c.waveWhiteFlag();
    }
}

Given you can then construct an AugmentedAnvil as a wrapper around the
AnimatedAnvil at hand (without even needing to know its actual runtime
class), and you can pass it around in place of the AnimatedAnvil it
contains.  After it squashes a Coyote -- for which it will employ the
wrapped Anvil to do the real work -- it will cause that Coyote to wave a
white flag.

The same general programming idiom can very likely be applied to your
problem.

John Bollinger
jobollin@indiana.edu

Hello, Hugh Beyer !
You wrote:

There is a more drastic route you can take, but it requires more
work on your part. Basically you can create your own wrapper API
for it. It would look something like this:
- Create an interface which contains the method signatures for
all of the methods in Graphics.
- Create an implementation of that interface that contains a
reference to an instance of the real lcdui.Graphics type that is
passed into the constructor. Its implementations of the interface
methods simply calls the corresponding methods on the
lcdui.Graphics instance.
- You can then overrid that class to add any functionality you
wanted to perform in the subclass you were trying to create.
- You rewrite mostof your application to work with the interface
instead of the lcdui.Graphics class. Since they have the same
methods that mostly involves changing a few variable types.
- For methods like paint that take the actual lcdui.Graphics
instance, you wrap that in the class you created above that adds
your additional functionlity and that is what the rest of your
code uses.

This is certainly a lot of work, but it is doable.