In java, use a different class depending on the operating system

It uses the factory design pattern. This pattern allows you to create instances of the same interface with a specific implementation but hiding the implementation and creating the objects based on certain parameters (if necessary).

For example, define an interface called Reproductor.java:

public interface Reproductor
{
  void reproducir(string archivo);
  void pausar();
  void cerrar();

}

So now based on the types of operating systems you would initially support, you create a class that implements the interface.

For Linux:

public ReproductorLinux implements Reproductor
{
  public void reproducir(string archivo)
  {
     // codigo para reproducir en el OS linux
  }

  public void pausar()
  {
     // codigo para  pausar en el OS linux
  }

  public void cerrar()
     // codigo para cerrar en el OS linux
  }
}

Windows:

public ReproductorWindows implements Reproductor
{
  public void reproducir(string archivo)
  {
     // codigo para reproducir en el OS Windows
  }

  public void pausar()
  {
     // codigo para  pausar en el OS Windows
  }

  public void cerrar()
     // codigo para cerrar en el OS Windows
  }
}

Android:

public ReproductorAndroid implements Reproductor
{
  public void reproducir(string archivo)
  {
     // codigo para reproducir en el OS Android
  }

  public void pausar()
  {
     // codigo para  pausar en el OS Android
  }

  public void cerrar()
     // codigo para cerrar en el OS Android
  }
}

Now you create another class that will be in charge of creating a specific instance according to the operating system:

public class ReproductorFactory
{
  public static Reproductor crearReproductor()
  {
        if(esWindow)
        {
            return new ReproductorWindows();
        }
        else if(esAndroid)
        {
            return new ReproductorAndroid();
        }
        else if(esLinux)
        {
            return new ReproductorLinux();
        }

        else{
            throw new Exception("Este sistema operativo no es soportado");
        }
  }
}

So the use is the simplest. You just call the method ReproductorFactory.crearReproductor()whenever you need the player:

Reproductor reproductor = ReproductorFactory.crearReproducto();
reproductor.reproducir("c:/sonido.mp3");

Note the non-existence of if. And if one day you were to support another OS, you would just have to add the implement of it and add it to the method crearReproductor()and that's it, you won't have to make any more modifications to your entire program besides that.

Object-oriented programming provides you with a very useful tool in these cases called "polymorphism" .

For your case, you have a class called reproducirthat will have certain common methods like empezar, parar, pausa, getNumCancion, getPosicion, etc:

class reproducir {
  private boolean reproduciendo;
  private int posicion, cancion;

  public reproducir() {
    /* Constructor inicializando parámetros comunes */
    reproduciendo = false;
    posicion = 0;
    cancion = 0;
  }

  public void empezar() {
    /* Actualización común de registros internos o estado de
      reproducción */
    reproduciendo = true;
    /* ... */
  }

  public void parar() {
    /* Actualización común de registros internos o estado de
      reproducción */
    posicion = 0;
    reproduciendo = false;
    /* ... */
  }

  public void pausa() {
    /* Actualización común de registros internos o estado de
      reproducción */
    reproduciendo = false;
    /* ... */
  }

  public void pausa() {
    /* Actualización común de registros internos o estado de
      reproducción */
    reproduciendo = true;
    /* ... */
  }

  public int getNumCancion() {
    return cancion;
  }

  public int getPosicion() {
    return posicion;
  }
}

Now all you have to do is create the platform-dependent implementations.

Android example:

class reproducirAndroid extends reproducir {
  public reproducirAndroid() {
    /* Llamamos al constructor padre */
    super();
  }

  @Override
  public void empezar() {
    /* Llamamos a la implementación común de comienzo */
    super.empezar();
    /* Implementamos aquí el método en android */
  }

  @Override
  public void parar() {
    /* Llamamos a la implementación común de parada */
    super.parar();
    /* Implementamos aquí el método en android */
  }

  @Override
  public void pausa() {
    /* Llamamos a la implementación común de pausa */
    super.pausa();
    /* Implementamos aquí el método en android */
  }

  /* No es necesario implementar getNumCancion ni getPosicion */
}

JavaSE example:

class reproducirJava extends reproducir {
  public reproducirJava() {
    /* Llamamos al constructor padre */
    super();
  }

  @Override
  public void empezar() {
    /* Llamamos a la implementación común de comienzo */
    super.empezar();
    /* Implementamos aquí el método en java se */
  }

  @Override
  public void parar() {
    /* Llamamos a la implementación común de parada */
    super.parar();
    /* Implementamos aquí el método en java se */
  }

  @Override
  public void pausa() {
    /* Llamamos a la implementación común de pausa */
    super.pausa();
    /* Implementamos aquí el método en java se */
  }

  /* No es necesario implementar getNumCancion ni getPosicion */
}

You only have to manage which instance to actually create:

reproducir getInstance() {
  if (esandroid()) {
    return new reproducirAndroid();
  } else {
    return new reproducirJava();
  }
}

reproducirThat returned instance will be able to do empezar, pararand pausadepending on each platform without having to repeat conditions ifwithin your code over and over again, and furthermore, you won't have to repeat in each implementation common code like getNumCancionor getPosicionor common parts of the playback state in empezar, pararand pausa.