Is it okay to use the instanceof operator to implement two parallel hierarchies of functions and arguments to those?

Question

Is it bad practice to use the instanceof operator in the following context?

public interface IWriter {
    public abstract void write(Dto dto);
}

public abstract class Dto {
    private long id;
    public void setId(long id) {this.id = id;}
    public long getId() {return id;}
}

public class DtoA extends Dto {
   ...
}

public class DtoB extends Dto {
   ...
}

public class MyWriterA implements IWriter {
   @Override
   public void writer(Dto dto) {
     if (!(dto instanceof DtoA))
        return;
     ...
   }
}

public class MyWriterB implements IWriter {
   @Override
   public void writer(Dto dto) {
     if (!(dto instanceof DtoB))
        return;
     ...
   }
}

There is a lot of myths about the use of that operator and I am not completely sure that what I am doing is not bunk.

I have a lot of different writer implementations which I want to combine in one interface. The problem is not every DTO is applicable for every writer. In my actual code there is a deep hierarchy of DTOs, which extend DtoA and DtoB, and either the hierarchy branch of DtoA or DtoB is applicable for a writer, but only in a few cases both.

Should I avoid using the abstract class Dto as argument for the abstract write(Dto dto) method?

EDIT: Please read the comments on the accepted answer.

Answer 1

Sometimes there's no getting around using instanceof - there is no need to feel shame.

Typing IWriter may help:

public interface IWriter<T extends Dto> {
    public abstract void write(T dto);
}

then

public class MyWriterA implements IWriter<DtoA> {
   @Override
   public void writer(DtoA dto) {
     // No need for instanceof, because it can't be anything else
     ...
   }
}

Perhaps a combination of such typing and Brian Agnew's worthy answer would do the trick.