oops ... forgot that Java doesn't allow abstract static methods ...
you'd have to make getType() and listObjects() non-static

I'll try to explain a little better:

There are different types of objects that can be instantiated from data held
in a DB and you can alter these objects via a web interface.

1: I want to click a link saying "list objects of type x" or "list objects
of type y" which lists the (descriptive) names all of the type x objects in
the DB on a web page.
2: I can select an an individual object from the list which will display a
detailed description of this particular object's fields and allow me to
alter them, the changes to be persisted back to the DB.

These object types are in an inheritance tree all extending a single
abstract base object as I've described below with abstract class A and
subclasses B and C.

It's where to put the method that performs step 1 above I've trouble with.
It's the same implementation for all the subclasses i.e. get the descriptive
names of the objects from the DB where the type is "x", "y" etc. (x or y is
just a DB field that identifies the type of the object and hence how to
build it from the data in the DB, different fields required etc.)

So, as it's the same implementation except, for a "type" parameter, I want
to put this listObjects method in the base class, but the base class
shouldn't need to know the type parameter for every subclass, that should be
encapsulated in each subclass.

That's OK if I want to use this.getType() in the base class method but this
should not be an instance method! It should be a static method as it
pertains to all instances of the class. I should also only have 1 copy of
the type param in each subclass as it too should be a static variable.

Hope that's clearer (but I'm not convinced it is!)

What about using Class:

abstract class A{
/** all objects of all types */
private static Vector allObjects=new Vector();
/** constructor keeps track of all created objects */
public A(){ allObjects.add(this); }
/** Approach 1: filter allObjects for class c */
public static void listObjects(Class c){
 Vector result=new Vector();
 for(int i=0;i<allObjects.size();i++){
  Object o=allObjects.get(i);
  if(c.isInstance(o)) result.add(o);
 }
 return result;
}
/** Approach 2: filter allObjects for this object type */
public void listObjects(){
 Vector result=new Vector();
 for(int i=0;i<allObjects.size();i++){
  Object o=allObjects.get(i);
  if(getClass().isInstance(o)) result.add(o);
 }
 return result;
}
}

class B extends A{}
class C extends A{}

then use
 A.listObjects(B.class);
or even
 B b=new B();
 b.listObjects();
etc.

The alternative method, which would use your TYPE member, would
involve class A to define an abstract method getType() which is
overridden in B and C, and returns your TYPE value. In the
listObjects() method, you could compare the results with the parameter
of the method.