How can I use different subclass in different situation?

Question

I have a dilemma like this:

I have parent class MediaPlayer, then some subclass extends from it, let's say they are MediaPlayerSub1 MediaPlayerSub2 MediaPlayerSub3, all of they extend some differnt methods.

In my client, I want use different subclass in different situation, so I am faced with difficulties: when I use MediaPlayer I always need to judge which subclass it is, for example:

MediaPlayer mMediaPlayer = initPlayer()
// ... do some operation from MediaPlayer

// ... do operation from sub class
if (mMediaPlayer instanceof MediaPlayerSub1) {
    mMediaPlayer = (MediaPlayerSub1)mMediaPlayer;
    // ... do operation from MediaPlayerSub1
} else if (mMediaPlayer instanceof MediaPlayerSub2) {
    mMediaPlayer = (MediaPlayerSub2)mMediaPlayer;
    // ... do operation from MediaPlayerSub2
} else if (mMediaPlayer instanceof MediaPlayerSub3) {
    mMediaPlayer = (MediaPlayerSub3)mMediaPlayer;
    // ... do operation from MediaPlayerSub3
}

Do I have better choice to refactor the code to reduce the coupling?

you can use `factory pattern` here is the link (http://www.tutorialspoint.com/design_pattern/factory_pattern.htm) — Bhargav Modi, Dec 13 '14 at 04:28
Also, you'd be interested to read about [SOLID](http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29) and [design patterns](http://en.wikipedia.org/wiki/Design_Patterns) by the "Gang of Four". — Everv0id, Dec 13 '14 at 04:37
Learn about Interfaces while you're reading up on the factory pattern. — Tony Ennis, Dec 13 '14 at 04:38
It might help us to know what kinds of operations you're doing on each of the three types. — Fuhrmanator, Dec 15 '14 at 01:34

Paul Boddington · Accepted Answer · 2014-12-13T05:08:54.990

If you are the author of MediaPlayer you can just write an abstract method in MediaPlayer

abstract void action();

and override it in each of the subclasses, like this:

@Override
void action() {
   // do something
}

Then you just need to call mMediaPlayer.action().

If you are not the author of MediaPlayer you can do the same thing but using wrapper classes, like this

abstract class MediaPlayerWrapper {

    private final MediaPlayer mediaPlayer;

    MediaPlayerWrapper(MediaPlayer mediaPlayer) {
       this.mediaPlayer = mediaPlayer;
    }

    MediaPlayer getMediaPlayer() {
        return mediaPlayer;
    }

    abstract void action();
}

Then you create subclasses for each subclass of MediaPlayer. Like this:

final class MediaPlayerWrapper1 extends MediaPlayerWrapper {       

    MediaPlayerWrapper1(MediaPlayerSub1 mediaPlayer) {
        super(mediaPlayer);
    }

    @Override 
    public void action() {
        // do stuff with the MediaPlayer. You will need to call getMediaPlayer() first.
    }
}

Then you just need to use a MediaPlayerWrapper instead of a MediaPlayer.

sorry, I don't have the author of MediaPlayer. You know what? The `MediaPlayer` is in source of android — roger, Dec 13 '14 at 04:50
@roger then look at the 'wrapper' description above. He's using delegation instead of inheritance to work around this. — Tony Ennis, Dec 13 '14 at 14:18

score 0 · Answer 2 · answered Dec 13 '14 at 05:05

The solution is to refactor using famous FACTORY pattern.

Factory pattern in short is a creational pattern where you dynamically load classes based on Input. The client has no information whatsoever on the implementation or sub classes.

In your case , the code you posted above is client and ideally it should not be aware of subclasses. Rather it should be aware of a Factory class who is responsible to provide client with desired subclass.

public enum MediaType {
   MEDIA1  ,MEDIA2 , MEDIA3, NULL ;
}

public class MediaFactory {

     public static MediaPlayer getMediaInstance(MediaType mediaType) { 
          if( mediaType == MediaType.MEDIA1) return new MediaPlayerSub1(mediaType);
          if( mediaType == MediaType.MEDIA2) return new MediaPlayerSub2(mediaType);
          if( mediaType == MediaType.MEDIA3) return new MediaPlayerSub3(mediaType);  
          return new MediaPlayer();
    }
 }
  // client code
  MediaPlayer mediaPlayer = MediaFactory.getMediaInstance(MediaType.NULL); 
  MediaPlayer mediaPlayer = MediaFactory.getMediaInstance(MediaType.MEDIA1);
  MediaPlayer mediaPlayer = MediaFactory.getMediaInstance(MediaType.MEDIA2);
  MediaPlayer mediaPlayer = MediaFactory.getMediaInstance(MediaType.MEDIA3);

  if (mediaPlayer.getMediaType() ==MediaType.MEDIA1) // do mediaSub1 operations
  if (mediaPlayer.getMediaType() ==MediaType.MEDIA2) // do mediaSub2 operations
  if (mediaPlayer.getMediaType() ==MediaType.MEDIA3) // do mediaSub3 operations

You might seem round about way, but idea is client should not know about subclasses and its kind of loose coupling, making code more modular. Hope this answered your question.

This answer is decent until the last three lines. If the client code needs to know the type of the object returned by the factory, either more abstraction is needed or the factory design pattern isn't appropriate. — Tony Ennis, Dec 13 '14 at 14:16

How can I use different subclass in different situation?

2 Answers2