Develop Reference

Only perform action for specific sub classes of objects [duplicate]

I have a collection of Animal objects.
My core code wants to treat all of these as Animals, all the same. Each Animal needs to be processed in some way. The nature of the processing depends on the sub-type of the Animal (bird, mammal, etc).
My code currently looks as follows.
public interface Animal {
public String getTaxonomyClass();
}
public abstract class Bird implements Animal {
#Override
public String getTaxonomyClass() {
return "aves";
}
// Specific to birds
public abstract float getWingspan();
}
public abstract class Mammal implements Animal {
#Override
public String getTaxonomyClass() {
return "mammalia";
}
// Specific to mammals
public abstract int getToothCount();
}
public interface AnimalProcessor {
public String getSupportedTaxonomyClass();
public void process(Animal a);
}
public class MammalProcessor implements AnimalProcessor {
#Override
public String getSupportedTaxonomyClass() {
return "mammalia";
}
#Override
public void process(Animal a) {
System.out.println("Tooth count is " + ((Mammal)a).getToothCount());
}
}
public class BirdProcessor implements AnimalProcessor {
#Override
public String getSupportedTaxonomyClass() {
return "aves";
}
#Override
public void process(Animal a) {
System.out.print("Wingspan is " + ((Bird)a).getWingspan());
}
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ZooKeeper {
Map<String, AnimalProcessor> registry = new HashMap<String, AnimalProcessor>();
public void registerProcessor(AnimalProcessor ap)
{
registry.put(ap.getSupportedTaxonomyClass(), ap);
}
public void processNewAnimals(List<Animal> newcomers)
{
for(Animal critter : newcomers)
{
String taxonomy = critter.getTaxonomyClass();
if(registry.containsKey(taxonomy))
{
// if I can process the animal, I will
AnimalProcessor ap = registry.get(taxonomy);
ap.process(critter);
}
}
}
}
import java.util.LinkedList;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
ZooKeeper keeper = new ZooKeeper();
keeper.registerProcessor(new MammalProcessor());
keeper.registerProcessor(new BirdProcessor());
List<Animal> animals = new LinkedList<Animal>();
animals.add(new Mammal() { // badger
#Override
public int getToothCount() {
return 40;
} }
);
animals.add(new Bird() { // condor
#Override
public float getWingspan() {
return 2.9f;
} }
);
keeper.processNewAnimals(animals);
}
}
Generally this is easy to understand and works nicely! I can add plug-in new processors and animal types at my leisure without changing the ZooKeeper class or any of the interfaces. You can imagine a more advanced main class, loading the Animals from a database, and processing them all in turn.
However, I worry about the downcasts inside the AnimalProcessor subclasses! This strikes me as something which should not be there, and may be a violation of OO principles. After all, at the moment I can pass a Bird to a MammalProcessor's process() method, and there will be a ClassCastException.
Can anyone suggest a design pattern to solve this? I looked at the Visitor pattern, but couldn't quite figure out how to apply it in this case! The key is to make the core code (ZooKeeper) treat all animals the same, and make it so that support for new Animals can be added trivially. Thanks!

I would suggest the following:
public interface Animal {
public AnimalProcessor<? extends Animal> getProcessor();
}
so each animal will return it's matching processor.
public interface AnimalProcessor<T extends Animal> {
public void process(T a);
}
so the processors will be typed with their matching type it's should process.
so the implantation will be like this:
public abstract class Bird implements Animal {
private BirdProcessor processor = new BirdProcessor();
public abstract float getWingspan();
#Override
public AnimalProcessor<Bird> getProcessor() {
return processor;
}
}
public class BirdProcessor implements AnimalProcessor<Bird> {
#Override
public void process(Bird b) {
System.out.print("Wingspan is " + b.getWingspan());
}
}

This is where generics work great.
First, you need to make AnimalProcessor generic:
public interface AnimalProcessor <T extends Animal> {
public String getSupportedTaxonomyClass();
public void process(T a);
}
Next, in your specific processors, you specify the generic type - eg for mammals:
public class MammalProcessor implements AnimalProcessor<Mammal> {
public String getSupportedTaxonomyClass() {
return "mammalia";
}
public void process(Mammal a) {
System.out.println("Tooth count is " + a.getToothCount());
}
}
Now, the process method only accepts Mammal objects, no birds here.

I suggest the following :
public interface Animal {
public String getTaxonomyClass();
public void process();
}
Now each animal class implementing Animal should implement its own processing logic.
For example :
public class Bird implements Animal {
public Bird(float wingSpan) {
this.wingSpan = wingSpan;
}
#Override
public String getTaxonomyClass() {
return "aves";
}
#Override
public void process() {
System.out.print("Wingspan is " + wingSpan);
}
// Specific to birds
private float wingspan;
}
Now you can have only one AnimalProcessor which processes as follows :
public void process(Animal a) {
a.process();
}

Make you AnimalProcessor generic;
public interface AnimalProcessor<T extends Animal> {
public String getSupportedTaxonomyClass();
public void process(T a);
}
public class MammalProcessor implements AnimalProcessor<Mammal> {
#Override
public String getSupportedTaxonomyClass() {
return "mammalia";
}
#Override
public void process(Mammal a) {
System.out.println("Tooth count is " + a.getToothCount());
}
}

So you've got a class like this...
public abstract class Bird implements Animal {
#Override
public String getTaxonomyClass() {
return "aves";
}
// Specific to birds
public abstract float getWingspan();
}
All Birds will have a wingspan, even if the wingspan is 0. So, why don't you change the class to something like this...
public class Bird implements Animal {
float wingspan = 0.0f;
public Bird(float wingspan){
this.wingspan = wingspan;
}
#Override
public String getTaxonomyClass() {
return "aves";
}
// Specific to birds
public float getWingspan(){
return wingspan;
}
}
So, to create a new Bird, instead of doing this...
animals.add(new Bird() { // condor
#Override
public float getWingspan() {
return 2.9f;
} }
);
You would just do this...
animals.add(new Bird(2.9f)); // condor
This would seem to make the whole thing a lot simpler and nicer for your purposes. You would do a similar change for your Mammal class too.
Now, for the processing of animals... if all Animals are going to be processed, you could just implement process() in Bird rather than needing a separate BirdProcessor class. To do this, in Animal, declare a method public void process();. Your Bird would implement it like this...
public void process() {
System.out.print("Wingspan is " + getWingspan());
}
and you would change your AnimalProcessor to simply do this (note: no longer an interface)...
public class AnimalProcessor {
public void process(Animal a) {
a.process();
}
}
Your AnimalProcessor class would then be able to handle all Animals.
Alternatively, if you want to leave AnimalProcessor as it is, it would probably be good to change the following though, to avoid the ClassCastException (this code here is for the BirdProcessor)...
public void process(Animal a) {
if (a instanceof Bird){
System.out.print("Wingspan is " + ((Bird)a).getWingspan());
}
}
Is this kinda what you were looking for?

Your problem are methods such as
public abstract int getToothCount();
...aren't defined in Animal. Instead, they are defined in specific subclasses of Animal. This means you can't treat Animals generically since they are fundamentally different.
To overcome this, the one approach would be to create abstract methods for all these in the Animal class.
Bird might respond to getToothCount() with "0".
Since all animals could respond to getWingspan(), getTootCount(), etc, you would not have to perform any type-specific checking. If this isn't good enough, create abstract implementations of "boolean hasWings()", "boolean hasTeeth()" etc etc in Animal.
Now you could say, for some animal a:
if (a.hasWings()) System.out.println("My wingspan is "+a.getWingSpan());
which would work for any animal. Of course, each subclass of Animal would have to implement all the various methods.
Another option is to add non-abstract methods to Animal. These methods would supply default answers. For example, getWingSpan() would return 0, getToothCount() would return 0, etc. Shark would override getToothCount(). Eagle would override getWingSpan()...
Then your subclasses would only have to override (or even know about) methods related directly to them.

How can i prevent explicit casting if you want to use properties of the sub-type?

So the compiler complains when ever i do a explicit cast. I can prevent this by using a #SuppressWarnings annotation.
At this point i would have this annotation a lot in my code which lets me suspect that there is another way i'm just not aware of.
Lets have a look at this example
class CutePet
{
public void pet()
{
System.out.println( "The cute pet gets some pets" );
}
}
class Cat extends CutePet
{
public void letOutside()
{
System.out.println( "The cat goes outside" );
}
public void letInside()
{
System.out.println( "The cat comes inside" );
}
public void removeTick()
{
System.out.println( "The cat looses all ticks" );
}
}
class Dog extends CutePet
{
public void goForAWalk()
{
System.out.println( "The Dog goes for a walk" );
}
public void tellHimWhatHeIs()
{
System.out.println( "The Dog is a good boy" );
}
}
class caretaker
{
public void takeCare( CutePet pet )
{
if( pet instanceof Cat )
{
pet.pet();
((Cat)pet).letOutside();
((Cat)pet).letInside();
((Cat)pet).removeTick();
}
else if( pet instanceof Dog )
{
pet.pet();
((Dog)pet).goForAWalk();
((Dog)pet).tellHimWhatHeIs();
}
}
}
The Caretaker does not know what kind of Pet he will get in advance and he my has several pets of different kinds.
I tried to give the Cute pet class a getType() method which returns a enum. With this enum i can remove the "instanceof" but the cast is still there.
Am i missing something?

If this were a real world problem, the caretaker would recognize which kind of pet he has based on the pet's appearance. While "instance of" is one way of looking at it, you might want to consider overloading the takeCare method directly with the subtypes as required. For example:
class Caretaker {
public void takeCare(Cat pet) {
pet.pet();
pet.letOutside();
pet.letInside();
pet.removeTick();
}
public void takeCare(Dog pet) {
pet.pet();
pet.goForAWalk();
pet.tellHimWhatHeIs();
}
}
in other words, the caretaker knows what to do (has methods already in place) for the kind of pet he receives.
EDIT
In response to some of the comments, yes, the original example shifts the problem further up. If you have an array or a list of generic pets then you still have to figure out what kinds of pets you have to give them to the caretaker. Conceptually it seems strange that the pet should be able to pet itself, take itself for a walk, etc. (these methods are part of the pet class when it should be the caretaker doing these actions ON the pet).
I've since rewritten the code with a full working example below with a Job class that has a perform method. This method will return the appropriate job based on the type of animal the caretaker has. The caretaker can then perform the job on the pet in question. See below.
Doing things this way avoids instanceof. While it is debatable how good/bad instanceof actually is, where possible it should be the object itself to tell me what it needs, otherwise the whole polymorphism concept can get pretty hairy pretty quick.
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
Caretaker caretaker = new Caretaker();
Arrays.asList(
new Cat("Cat1"),
new Cat("Cat2"),
new Dog("Dog1")
).forEach(caretaker::takeCare);
}
interface CutePet {
String whoAmI();
Job whatINeed();
}
abstract static class NamedCutePet implements CutePet {
private final String name;
public NamedCutePet(String name) {
this.name = name;
}
public String whoAmI() {
return this.name;
}
}
static class Cat extends NamedCutePet {
public Cat(String name) {
super(name);
}
#Override
public Job whatINeed() {
return new CatJob(this);
}
}
static class Dog extends NamedCutePet {
public Dog(String name) {
super(name);
}
#Override
public Job whatINeed() {
return new DogJob(this);
}
}
static class Caretaker {
void takeCare(CutePet pet) {
pet.whatINeed().perform();
}
}
static abstract class BaseJob implements Job {
void pet(CutePet pet) {
System.out.println(String.format("The cute pet %s gets some pets", pet.whoAmI()));
}
}
static class DogJob extends BaseJob {
private final Dog dog;
public DogJob(Dog dog) {
this.dog = dog;
}
#Override
public void perform() {
pet(dog);
takeDogFarAWalk(dog);
tellHimWhatHeIs(dog);
}
private void takeDogFarAWalk(Dog dog) {
System.out.println(String.format("The dog %s goes for a walk", dog.whoAmI()));
}
private void tellHimWhatHeIs(Dog dog) {
System.out.println(String.format("The dog %s is a good boy", dog.whoAmI()));
}
}
static class CatJob extends BaseJob {
private final Cat cat;
public CatJob(Cat cat) {
this.cat = cat;
}
#Override
public void perform() {
pet(cat);
letOutside(cat);
letInside(cat);
removeTick(cat);
}
private void letOutside(Cat cat) {
System.out.println(String.format("The cat %s goes outside", cat.whoAmI()));
}
private void letInside(Cat cat) {
System.out.println(String.format("The cat %s comes inside", cat.whoAmI()));
}
private void removeTick(Cat cat) {
System.out.println(String.format("The cat %s loses all ticks", cat.whoAmI()));
}
}
interface Job {
void perform();
}
}

Let's make it clear: you can't call subclass specific methods without typecasting to subclass type.
Now, let me suggest an alternate way. Define a method takeCare() in the superclass and let the subclasses implement it by calling several specific methods specific to subclasses. Then from CareTaker#takeCare(), call only takeCare() method without typecasting.
Several other alternate approaches can be used to solve the situation.

Here is how you would do it with interfaces and reflection. Note that only the interface methods are called for each pet type. It could also be extended to call other methods.
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class PetProblem {
public static void main(String[] args) {
Caretaker caretaker = new Caretaker();
Dog dog = new Dog();
caretaker.takeCare(dog);
System.out.println("\nNow do it for the cat\n");
Cat cat = new Cat();
caretaker.takeCare(cat);
}
}
interface CuteCat {
void letOutside();
void letInside();
void removeTick();
}
interface CuteDog {
void goForAWalk();
void tellHimWhatHeIs();
}
interface CutePet {
default void pet() {
System.out.println("The cute pet gets some pets");
}
}
class Cat implements CutePet, CuteCat {
public void letOutside() {
System.out.println("The cat goes outside");
}
public void letInside() {
System.out.println("The cat comes inside");
}
public void removeTick() {
System.out.println("The cat looses all ticks");
}
}
class Dog implements CutePet, CuteDog {
public void goForAWalk() {
System.out.println("The Dog goes for a walk");
}
public void tellHimWhatHeIs() {
System.out.println("The Dog is a good boy");
}
}
class Caretaker {
public void takeCare(Object pet) {
Class<?>[] ifss = pet.getClass().getInterfaces();
for (Class<?> ifs : ifss) {
Method[] methods = ifs.getDeclaredMethods();
for (Method m : methods) {
try {
m.invoke(pet);
}
catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
}
Note however, that using interfaces and having a method so named that it can be used for all pets is easier. Here is an example. Since both dogs and cats need to eat, a common method feedMe() can be implemented for each.
public class AnimalShelter {
public static void main(String[] args) {
Caretaker caretaker = new Caretaker();
Dog dog = new Dog();
Cat cat = new Cat();
caretaker.feedThePets(dog);
caretaker.feedThePets(cat);
}
}
interface SupperTime {
void feedMe();
}
class Caretaker {
public void feedThePets(SupperTime pet) {
pet.feedMe();
}
}
class Dog implements SupperTime {
public void feedMe() {
System.out.println("Oh boy, Kibbles n' Bits");
}
}
class Cat implements SupperTime {
public void feedMe() {
System.out.println("Yum. Purina Cat Chow");
}
}

Java advanced Enum with an abstract method and used for branching

I'm new to java and came across some advanced Enum code in my organization.
I am familiar with enums defined as follows: public enum someList { VALUE1, VALUE2, ..}
But in the advanced enum that I came across, a lot more seems to be going on..
/**
* Defines ways to compare records in {#link ApplicationStatus} to see if they
* are the same.
*/
public enum SourceStatusComparisonType
{
CONTEXT_KEY
{
#Override
public boolean compareKeys(SourceStatus source, ApplicationStatus status)
{
return source.getContextKey() == status.getSourceContextId();
}
},
DATE
{
#Override
public boolean compareKeys(SourceStatus source, ApplicationStatus status)
{
return source.getCobDate().equals(status.getCobDate());
}
};
public abstract boolean compareKeys(SourceStatus source,
ApplicationStatus status);
}
Could someone enlighten me on what's going on with the abstract method that's being overridden and overloaded. I don't understand what's going on in the above. I was told this is being used to abstract away if/else blocks from the code that uses it. But I'm not sure I understand.
Thank you in advance.

Each enum constants can be optionally followed by a class body, as specified in JLS §8.9.
The optional class body of an enum constant implicitly defines an anonymous class declaration (§15.9.5) that extends the immediately enclosing enum type. The class body is governed by the usual rules of anonymous classes; in particular it cannot contain any constructors.
So, it is like creating an abstract class SourceStatusComparisonType, with an abstract method - compareKeys(). You create 2 instances of that class:
CONTEXT_KEY = new SourceStatusComparisonType() {
#Override
public void compareKeys() { .. }
};
DATE = new SourceStatusComparisonType() {
#Override
public void compareKeys() { .. }
};
And override the abstract method for each instances. You can't have any instance, without having an implementation of that method.
Similarly, all the enum constants, must provide an implementation of the abstract method in it's respective anonymous class body. Else, you can't have that method as abstract. You have to provide a body, which will be used by default for the enum constants, that don't provide that method implementation:
public enum SourceStatusComparisonType
{
CONTEXT_KEY
{
#Override
public boolean compareKeys(SourceStatus source, ApplicationStatus status)
{
return source.getContextKey() == status.getSourceContextId();
}
},
DATE
{
#Override
public boolean compareKeys(SourceStatus source, ApplicationStatus status)
{
return source.getCobDate().equals(status.getCobDate());
}
},
DEFAULT;
public boolean compareKeys(SourceStatus source,
ApplicationStatus status) {
// return somedefaultvalue;
}
}
So, for the first 2 constants, when you invoke compareKeys method, their specific implementation will be used, and for DEFAULT, the method defined outside will be used.

Enum type can have body like abstract methods and all enum constants should implement those abstract methods.
Look at the JSL here http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.9.2 and go to the section Example 8.9.2-4. Enum Constants with Class Bodies.
You even can implement an ENUM with an interface rather having a abstract method in it. Something like public enum SourceStatusComparisonType implements StatusComparable.

First thing you need to know about Enum in Java is that they are classes, think of them as classes. As such all the object oriented design/programming concepts you have learned apply to them.
Imagine a universe of your making, in which only 3 creatures exists, a Cat and Cow and a dog. One implementation would be
public abstract class Animal
{
private final String name;
public Animal(String name) {
this.name = name;
}
public abstract String sayHello(Animal other);
}
public class Cat extends Animal
{
public Cat(String name) {
super(name);
}
#Override
public String sayHello(Animal other) {
System.out.println(this.name + " says Meow!!! to " + other.name);
}
}
public class Cow extends Animal
{
public Cow(String name) {
super(name);
}
#Override
public String sayHello(Animal other) {
System.out.println(this.name + " says Moo!!! to " + other.name);
}
}
public class Dog extends Animal
{
public Dog(String name) {
super(name);
}
#Override
public String sayHello(Animal other) {
System.out.println(this.name + " says Woof!!! to " + other.name);
}
}
public Universe {
public List<Animal> animals;
public Universe(List<Animal> animals) {
this.animals = animals;
}
public void run() {
for (Animal animal : animals) {
for (Animal other : animals) {
if (other != animal) {
animal.sayHello(other);
}
}
}
}
}
You are satisfied with your universe and deploy it in production. Only to find, another malicious developer has introduced a new creature to your universe, a zombie
public class Zombie extends Animal
{
public Zombie(String name) {
super(name);
}
public String sayHello(Animal other) {
System.out.println(this.name + " says Arrggggg!!! to " + other.name);
eat(other);
}
private void eat(Animal other) {
System.out.println("nomm nomm " + other.name);
}
}
Zombies in the guise of saying hello eat all the animals they run into. Pretty soon there will be no Cats, Dogs and Cows left. You decide to deploy version 2 of your universe to prevent this and guard against zombies
public Universe2 {
public List<Animal> animals;
public Universe(List<Animal> animals) {
this.animals = animals;
}
public void run() {
for (Animal animal : animals) {
for (Animal other : animals) {
if (other != animal) {
if (!(animal instanceof Zombie))
animal.sayHello(other);
}
}
}
}
}
You are happy now, but you notice the cat populations decreasing, turns out cats and dogs are no longer friends, the zombies have infected their brains, you deploy version 3 of the universe.
public Universe3 {
public List<Animal> animals;
public Universe(List<Animal> animals) {
this.animals = animals;
}
public void run() {
for (Animal animal : animals) {
for (Animal other : animals) {
if (other != animal) {
if (!(animal instanceof Zombie) && !((animal instanceof Cat) && (animal instanceof Dog)))
animal.sayHello(other);
}
}
}
}
}
In this version, there are no zombies. Cats and Dogs say hello to Cows but not each other. The universe is in equilibrium but you have a nagging feeling that not everything is right with the world. You sleep on it and come to the realization that you are open to attack similar to the zombie ones, you decide to lock down the universe and implement a rewrite to start from scratch and eliminate the zombie epidemic entirely. Except you like friendly zombies that say hello.
public Enum Animal {
Cat {
#Override
public String sayHello(Animal other) {
System.out.println(this.name + " says Meow!!! to " + other.name);
}
},
Cow {
#Override
public String sayHello(Animal other) {
System.out.println(this.name + " says Moo!!! to " + other.name);
}
},
Dog {
#Override
public String sayHello(Animal other) {
System.out.println(this.name + " says Woof!!! to " + other.name);
}
},
Zombie {
#Override
public String sayHello(Animal other) {
System.out.println(this.name + " says Argggg!!! to " + other.name);
}
};
private String name;
public Animal(String name) {
this.name.
}
public String sayHello(Animal other);
}
public PerfectUniverse {
public List<Animal> animals;
public Universe(List<Animal> animals) {
this.animals = animals;
}
public void run() {
for (Animal animal : animals) {
for (Animal other : animals) {
if (other != animal) {
animal.sayHello(other);
}
}
}
}
}
You have eliminated the conditional if's using inheritance but locking down the extensibility by using an enumeration. You can do the same using classes, restricting access to Animal outside the package and making the derived types final. This of the enum Cat as an instance of Cat extending Animal. The derived types with overridden method avoid the need for instanceof checks with if conditionals.

What is the correct pattern for processing a subclass in a type-specific way?

I have a collection of Animal objects.
My core code wants to treat all of these as Animals, all the same. Each Animal needs to be processed in some way. The nature of the processing depends on the sub-type of the Animal (bird, mammal, etc).
My code currently looks as follows.
public interface Animal {
public String getTaxonomyClass();
}
public abstract class Bird implements Animal {
#Override
public String getTaxonomyClass() {
return "aves";
}
// Specific to birds
public abstract float getWingspan();
}
public abstract class Mammal implements Animal {
#Override
public String getTaxonomyClass() {
return "mammalia";
}
// Specific to mammals
public abstract int getToothCount();
}
public interface AnimalProcessor {
public String getSupportedTaxonomyClass();
public void process(Animal a);
}
public class MammalProcessor implements AnimalProcessor {
#Override
public String getSupportedTaxonomyClass() {
return "mammalia";
}
#Override
public void process(Animal a) {
System.out.println("Tooth count is " + ((Mammal)a).getToothCount());
}
}
public class BirdProcessor implements AnimalProcessor {
#Override
public String getSupportedTaxonomyClass() {
return "aves";
}
#Override
public void process(Animal a) {
System.out.print("Wingspan is " + ((Bird)a).getWingspan());
}
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ZooKeeper {
Map<String, AnimalProcessor> registry = new HashMap<String, AnimalProcessor>();
public void registerProcessor(AnimalProcessor ap)
{
registry.put(ap.getSupportedTaxonomyClass(), ap);
}
public void processNewAnimals(List<Animal> newcomers)
{
for(Animal critter : newcomers)
{
String taxonomy = critter.getTaxonomyClass();
if(registry.containsKey(taxonomy))
{
// if I can process the animal, I will
AnimalProcessor ap = registry.get(taxonomy);
ap.process(critter);
}
}
}
}
import java.util.LinkedList;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
ZooKeeper keeper = new ZooKeeper();
keeper.registerProcessor(new MammalProcessor());
keeper.registerProcessor(new BirdProcessor());
List<Animal> animals = new LinkedList<Animal>();
animals.add(new Mammal() { // badger
#Override
public int getToothCount() {
return 40;
} }
);
animals.add(new Bird() { // condor
#Override
public float getWingspan() {
return 2.9f;
} }
);
keeper.processNewAnimals(animals);
}
}
Generally this is easy to understand and works nicely! I can add plug-in new processors and animal types at my leisure without changing the ZooKeeper class or any of the interfaces. You can imagine a more advanced main class, loading the Animals from a database, and processing them all in turn.
However, I worry about the downcasts inside the AnimalProcessor subclasses! This strikes me as something which should not be there, and may be a violation of OO principles. After all, at the moment I can pass a Bird to a MammalProcessor's process() method, and there will be a ClassCastException.
Can anyone suggest a design pattern to solve this? I looked at the Visitor pattern, but couldn't quite figure out how to apply it in this case! The key is to make the core code (ZooKeeper) treat all animals the same, and make it so that support for new Animals can be added trivially. Thanks!

I would suggest the following:
public interface Animal {
public AnimalProcessor<? extends Animal> getProcessor();
}
so each animal will return it's matching processor.
public interface AnimalProcessor<T extends Animal> {
public void process(T a);
}
so the processors will be typed with their matching type it's should process.
so the implantation will be like this:
public abstract class Bird implements Animal {
private BirdProcessor processor = new BirdProcessor();
public abstract float getWingspan();
#Override
public AnimalProcessor<Bird> getProcessor() {
return processor;
}
}
public class BirdProcessor implements AnimalProcessor<Bird> {
#Override
public void process(Bird b) {
System.out.print("Wingspan is " + b.getWingspan());
}
}

This is where generics work great.
First, you need to make AnimalProcessor generic:
public interface AnimalProcessor <T extends Animal> {
public String getSupportedTaxonomyClass();
public void process(T a);
}
Next, in your specific processors, you specify the generic type - eg for mammals:
public class MammalProcessor implements AnimalProcessor<Mammal> {
public String getSupportedTaxonomyClass() {
return "mammalia";
}
public void process(Mammal a) {
System.out.println("Tooth count is " + a.getToothCount());
}
}
Now, the process method only accepts Mammal objects, no birds here.

I suggest the following :
public interface Animal {
public String getTaxonomyClass();
public void process();
}
Now each animal class implementing Animal should implement its own processing logic.
For example :
public class Bird implements Animal {
public Bird(float wingSpan) {
this.wingSpan = wingSpan;
}
#Override
public String getTaxonomyClass() {
return "aves";
}
#Override
public void process() {
System.out.print("Wingspan is " + wingSpan);
}
// Specific to birds
private float wingspan;
}
Now you can have only one AnimalProcessor which processes as follows :
public void process(Animal a) {
a.process();
}

Make you AnimalProcessor generic;
public interface AnimalProcessor<T extends Animal> {
public String getSupportedTaxonomyClass();
public void process(T a);
}
public class MammalProcessor implements AnimalProcessor<Mammal> {
#Override
public String getSupportedTaxonomyClass() {
return "mammalia";
}
#Override
public void process(Mammal a) {
System.out.println("Tooth count is " + a.getToothCount());
}
}

So you've got a class like this...
public abstract class Bird implements Animal {
#Override
public String getTaxonomyClass() {
return "aves";
}
// Specific to birds
public abstract float getWingspan();
}
All Birds will have a wingspan, even if the wingspan is 0. So, why don't you change the class to something like this...
public class Bird implements Animal {
float wingspan = 0.0f;
public Bird(float wingspan){
this.wingspan = wingspan;
}
#Override
public String getTaxonomyClass() {
return "aves";
}
// Specific to birds
public float getWingspan(){
return wingspan;
}
}
So, to create a new Bird, instead of doing this...
animals.add(new Bird() { // condor
#Override
public float getWingspan() {
return 2.9f;
} }
);
You would just do this...
animals.add(new Bird(2.9f)); // condor
This would seem to make the whole thing a lot simpler and nicer for your purposes. You would do a similar change for your Mammal class too.
Now, for the processing of animals... if all Animals are going to be processed, you could just implement process() in Bird rather than needing a separate BirdProcessor class. To do this, in Animal, declare a method public void process();. Your Bird would implement it like this...
public void process() {
System.out.print("Wingspan is " + getWingspan());
}
and you would change your AnimalProcessor to simply do this (note: no longer an interface)...
public class AnimalProcessor {
public void process(Animal a) {
a.process();
}
}
Your AnimalProcessor class would then be able to handle all Animals.
Alternatively, if you want to leave AnimalProcessor as it is, it would probably be good to change the following though, to avoid the ClassCastException (this code here is for the BirdProcessor)...
public void process(Animal a) {
if (a instanceof Bird){
System.out.print("Wingspan is " + ((Bird)a).getWingspan());
}
}
Is this kinda what you were looking for?

Your problem are methods such as
public abstract int getToothCount();
...aren't defined in Animal. Instead, they are defined in specific subclasses of Animal. This means you can't treat Animals generically since they are fundamentally different.
To overcome this, the one approach would be to create abstract methods for all these in the Animal class.
Bird might respond to getToothCount() with "0".
Since all animals could respond to getWingspan(), getTootCount(), etc, you would not have to perform any type-specific checking. If this isn't good enough, create abstract implementations of "boolean hasWings()", "boolean hasTeeth()" etc etc in Animal.
Now you could say, for some animal a:
if (a.hasWings()) System.out.println("My wingspan is "+a.getWingSpan());
which would work for any animal. Of course, each subclass of Animal would have to implement all the various methods.
Another option is to add non-abstract methods to Animal. These methods would supply default answers. For example, getWingSpan() would return 0, getToothCount() would return 0, etc. Shark would override getToothCount(). Eagle would override getWingSpan()...
Then your subclasses would only have to override (or even know about) methods related directly to them.

what will be OODesign for the following

I was asked to finish this test in one of my interview and they wanted me to create classes intereface following all the right practices. I couldn't clear the interview but I sure am interested how you all experts out there would handle this.
Create an OODesign for the following scenario
There is a zoo, its has some animals.
Following are the animals which live in the zoo
Lion
Tiger
Bear
Each animal has enerygy level
Every animal speaks, eats, play
by defalut when animal eat they gain +8 energy level
by default when animal play they loose -5 energy level
by defalut when animal speak they loose -1
By default each animal speak "Grrr..."
By default every animal when they play they say "I am loving it"
Only bear can dance but when bear dance he says "Look MA' I am dancing"
Following are the foods available for animals
Grain, Steak and salmon
When soundOff() method gets called on Zoo
every animal speak
When Tiger speaks it says "ROARR..."
When Lion speaks he says "Don't you dare ask me"

I would structure Zoo to contain a collection of the Animal base class to start with:
class Zoo {
private Collection<Animal> animals;
...
public void soundOff() {
Iterator<Animal> i = animals.iterator();
while( i.hasNext() )
i.next().speak();
}
then the Animal base class has the common methods/properties: speak, eat, play, energy level; also allow for the animal to reject food they don't like in the eat() method:
abstract class Animal {
private int energyLevel;
private String playMessage;
private String speakMessage;
...
public Animal(String speakMessage, String playMessage) {
this.speakMessage = speakMessage;
this.playMessage = playMessage;
}
public Animal() {
this( "Grrr...", "I am loving it" );
}
...
public abstract void eat( Food f ) throws IllegalArgumentException;
public void play() {
System.out.println( playMessage );
energyLevel += 8;
}
public void speak() {
System.out.println( speakMessage );
energyLevel -= 1;
}
..
}
then you can have specialized classes -- like DancerAnimal:
abstract class DancerAnimal extends Animal {
private String danceMessage;
public DancerAnimal(String speakMessage, String playMessage, String danceMessage) {
super( speakMessage, playMessage );
this.danceMessage = danceMessage;
}
public DancerAnimal( String danceMessage ) {
super();
this.danceMessage = danceMessage;
}
public void dance() {
System.out.println( danceMessage );
}
...
}
based on this you can implement Bear:
class Bear extends DanceAnimal {
public Bear() {
super( "Look MA' I am dancing" );
}
...
}
Lion and Tiger would just extend Animal base class and Food would probably be an enum.
My 2 cents on it.
Bear in mind that the above doesn't handle concurrency -- so one thread calling dance while the other calls play will corrupt the energyLevel -- but you can simply add a Lock around this.

class AnimalZoo {
public int energyLevel=0;
public String defaultVoice = "Grrr";
public String sing = "I am lovinig t";
public static void main(String [] args) {
Tiger t = new Tiger();
Lion l = new Lion();
Bear b = new Bear();
AnimalZoo az = new AnimalZoo();
az.soundOff();
}
public void soundOff() {
t.speak();
l.speak();
b.speak();
}
public void eat {
energyLevel+=8;
}
public void play{
energyLevel-=5;
}
public void speak {
energyLevel-=1;
}
}
}
class Lion extends AnimalZoo {
defaultVoice = "Don't you dare ask me";
System.out.printnln(defaultVoice);
}
class Tiger extends AnimalZoo {
public void speak {
defaultVoice = "ROARR";
System.out.println(defaultVoice);
}
}
class Bear extends AnimalZoo {
public void dance() {
System.out.println("Look MA' I am dancing");
}

Not all what you're looking for but something like this would help you to figure it out, d
eclare an animal class with all the properties and behavior common to all of them, then declare all the classes that define properties and behavior for each animal that extends the base class:
abstract class Animal
{
private int energyLevel;
public Animal(int eLevel)
{
setEnergyLevel(eLevel);
}
public void setEnergyLevel(int eLevel)
{
this.energyLevel = eLevel;
if(energyLevel <= 0)
{
energyLevel = 0;
}
}
public void speak()
{
System.out.println("grr...");
setEnergyLevel(energyLevel - 1);
}
public void eat()
{
setEnergyLevel(energyLevel + 8);
}
public void play()
{
System.out.println("I'm loving it...");
setEnergyLevel(energyLevel - 5);
}
}
class Lion extends Animal
{
public Lion(int energy)
{
super(energy);
}
}
class Bear extends Animal
{
public Bear(int energy)
{
super(energy);
}
public void dance()
{
System.out.println("I am dancing...");
}
}
class Tiger extends Animal
{
public Tiger(int energy)
{
super(energy);
}
}

Try the following code:
public abstract class Animal {
int energyLevel = ZooAnimalConstants.DEFAULT_ENERGY;
String speakMessage;
String playMessage;
public Animal(int energy) {
this.setEnergyLevel(energy);
speakMessage="Grr...";
playMessage="I am loving it";
}
public void setEnergyLevel(int energy) {
if (energy < 0) {
this.energyLevel = ZooAnimalConstants.DEFAULT_ENERGY;
} else {
this.energyLevel = energy;
}
}
public void speak() {
System.out.println("speak message : "+speakMessage);
this.setEnergyLevel(this.energyLevel - ZooAnimalConstants.MINUS_SPEAK_ENERGY);
}
public void eat() {
this.setEnergyLevel(this.energyLevel + ZooAnimalConstants.ADD_EAT_ENERGY);
}
public void play() {
System.out.println("play message : "+playMessage);
this.setEnergyLevel(this.energyLevel - ZooAnimalConstants.MINUS_PLAY_ENERGY);
}
public int getEnergyLevel()
{
return this.energyLevel;
}
}
Dance Behaviour:
public interface DanceBehaviour {
public abstract void dance();
}
public class Bear extends Animal implements DanceBehaviour{
public Bear() {
super(ZooAnimalConstants.BEAR_DEFAULT_ENERGY);
}
public void dance()
{
System.out.println("Look MA' I am dancing");
}
#Override
public String toString() {
// TODO Auto-generated method stub
return "Bear";
}
}
public class Tiger extends Animal {
public Tiger() {
super(ZooAnimalConstants.TIGER_DEFAULT_ENERGY);
super.speakMessage = "ROARR ..";
}
#Override
public String toString() {
// TODO Auto-generated method stub
return "Tiger";
}
}
public class Lion extends Animal {
public Lion() {
super(ZooAnimalConstants.LION_DEFAULT_ENERGY);
this.speakMessage = "Don't you dare ask me";
}
#Override
public String toString() {
// TODO Auto-generated method stub
return "Lion";
}
}
import java.util.ArrayList;
public class Zoo {
ArrayList<Animal> listAnimal;
public Zoo()
{
listAnimal= new ArrayList<Animal>();
}
public void addAnimal(Animal animal)
{
if(null != listAnimal && null != animal)
{
listAnimal.add(animal);
}
}
public void soundOff()
{
for(Animal animal : listAnimal)
{
animal.speak();
}
}
public void printAnimalEnergyReport()
{
for(Animal animal : listAnimal)
{
System.out.println("Energy Level for : "+animal.toString() + " : "+animal.energyLevel);
}
}
}
public interface ZooAnimalConstants {
int DEFAULT_ENERGY=0;
int ADD_EAT_ENERGY = 8;
int MINUS_SPEAK_ENERGY = 1;
int MINUS_PLAY_ENERGY = 5;
int TIGER_DEFAULT_ENERGY=5;
int LION_DEFAULT_ENERGY=6;
int BEAR_DEFAULT_ENERGY=4;
}
public class ZooDemoMain {
public static void main (String args[])
{
Zoo myZoo = new Zoo();
Animal tiger = new Tiger();
Animal bear = new Bear();
Animal lion = new Lion();
myZoo.addAnimal(tiger);
myZoo.addAnimal(lion);
myZoo.addAnimal(bear);
myZoo.soundOff();
myZoo.printAnimalEnergyReport();
bear.setEnergyLevel(0);
if(bear.getEnergyLevel() == 0)
{
bear.eat();
myZoo.printAnimalEnergyReport();
}
}
}