Visitor pattern with multiple visit implementations

I need to do various operation over a Composition pattern. I vas these implementation of the Visitor Pattern with the Composite Pattern.

Interface:

public interface Visitor {
    void visit(DayPart dayPart);
    void visit(DayParting dayParting);
    void visit(TimePart timePart);
}

The visitor method in the Composite Class:

public void accept(Visitor visitor) {
        visitor.visit(this);
        Iterator<AbstractComposite> itr = iterator();
        Parting children;
        while (itr.hasNext()) {
            children = (Parting) itr.next();
            children.accept(visitor);
        }
    }

The visitor method over the leaf:

@Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

The visitor Class implementation:

public class myVisitor implements Visitor {
    @Override
    public void visit(DayPart dayPart) {
        //do something (or not)
    }

    @Override
    public void visit(DayParting dayParting){
        // do something (or not)
    }

    @Override
    public void visit(TimePart timePart){
        //do something (or not)
    }
}

The problem is that i need do various operations over the Composition and with this design i need to do a new class for every "visit" what i need to do and this is pretty impractical.

So, i was thinking do something like this (i put generic names) with inners classes.

public abstract class VisitorImpl implements Visitor {
    //Hook methods
    @Override
    public void visit(Composite composite) {
        //hok method
    }

    @Override
    public void visit(Composite2  composite2) {
        //hook method
    }

    @Override
    public void visit(Leaf leaf) {
        //hook method
    }

    public static Visitor ParticularVisitor(){
        return new ParticularVisitor();
    }
    private static class ParticularVisitor extends VisitorImpl {
        @Override
        public void visit(Composite composite) {
            //do something real.
        }
        @Override
        public void visit(Composite2 composite2) {
            //do something real.
        }

        @Override
        public void visit(Leaf leaf) {
            //do something real.
        }
    }
    private static class ParticularVisitor_2 extends VisitorImpl {
        public ParticularVisitor_2(){
        }
        @Override
        public void visit(Leaf leaf){
            //Just do something with this
        }
    }
}

Is this a good solution to my problem? any improve?