I have a class tree, with one base class and several subclasses. Some of them need to check the others to see if they are of a particular kind. I can do that by instantiating an object of the desired class and use obj.getClass(), but that is kind of roundabout and also leads to recursion and stack overflow.

I would like to do something like: String className = MyClass.getName(); but Processing claims "The function getName() does not exist." Why does it say that?

Quark: Thanks for the reply – but that's not quite what I wanted (and quite doable by using obj.getName(), which works fine on objects).

What I want to do is find/store the name of a class, without instantiating an object.

Ha ha, yes, I can see why you'd think that!

I guess I'm striving for more elegance than can be found in Processing.

Example of what I'm looking for, in pseudo-pseudocode (i.e., the way I would like it to work):
Code:

class Organism {
  Class food;
  Organism() {}
}
class Plant extends Organism {
  Plant() {}
}
class Animal extends Organism {
  Animal() {}
}
class Herbivore extends Animal {
  Herbivore() { food = Plant.getClass(); }
  boolean likesToEat(Organism o) {
    return (o.getClass()==food);
  }
}
class Carnivore extends Animal {
  Carnivore() { food = Herbivore.getClass(); }
  boolean likesToEat(Organism o) {
    return (o.getClass()==food);
  }
}
 

Quote:

It just feels redundant to add strings describing the type of class when the classes already have a type ...

But I guess I don't have much choice. Apparently there are limits to what you can do with static classes, variables and functions. I was almost there, but then a call to a non-static function from a static class isn't permitted, so I had to go with your suggestion and use strings for type identification.

Thanks for your help!

travholt wrote on Aug 25^th, 2009, 1:10pm:

Here is how to make it work: Code:

void setup()
{
  println("Creating world");
  Plant grass = new Plant(); println();
  Plant daisy = new Flower(); println();
  Animal cow = new Herbivore(); println();
  Animal lion = new Carnivore(); println();
  Animal pig = new Omnivore(); println();
  
  println();
  println(lion.likesToEat(cow));
  println(lion.likesToEat(pig));
  println(lion.likesToEat(grass));
  println(lion.likesToEat(daisy));
  println();
  println(cow.likesToEat(lion));
  println(cow.likesToEat(pig));
  println(cow.likesToEat(grass));
  println(cow.likesToEat(daisy));
  println();
  println(pig.likesToEat(lion));
  println(pig.likesToEat(cow));
  println(pig.likesToEat(grass));
  println(pig.likesToEat(daisy));
  println(pig.likesToEat(pig));
  
  println(pig.isLiving);
}

interface Eater {
  boolean likesToEat(Organism o);
}
abstract class Organism {
  boolean isLiving;
  Organism() { isLiving = true; print(this.getClass().getSimpleName() + " > Organism"); }
}
class Plant extends Organism {
  Plant() { print("-Plant"); }
}
class Flower extends Plant {
  Flower() { print("-Flower"); }
}
abstract class Animal extends Organism implements Eater {
  Animal() { print("-Animal"); }
}
class Herbivore extends Animal {
  Herbivore() { print("-Herbivore"); }
  boolean likesToEat(Organism o) {
    return o instanceof Plant;
  }
}
class Carnivore extends Animal {
  Carnivore() { print("-Carnivore"); }
  boolean likesToEat(Organism o) {
    return o instanceof Animal;
  }
}
class Omnivore extends Animal {
  Omnivore() { print("-Omnivore"); }
  boolean likesToEat(Organism o) {
    return o instanceof Animal || o instanceof Plant;
  }
}
 

The interface defines a common trait, the fact the organism can eat. Any class implementing this interface can eat. But you have to define it. That's where the information on what can eat what is stored, not in a field.
I made some classes abstract because they shouldn't be instanced (too generic). Plant should be abstract, but I took a shortcut here...

[EDIT] Added constructor trace to better see the cascading default constructor mechanism.