如果要使用子类型的属性，如何防止显式转换？

Question

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?

Answer 1

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();
    }

}

Answer 2

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.

Answer 3

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");
   }
}