Is there a specific way to give a certain subclass some functions of the superclass?

The Problem

I'm trying to create an application where an object class can implement some operations from the total pool of available operations. The end goal is to not have any code duplication and to abide by the laws of OOP as much as possible.

In more detail, I'm trying to make a search engine using Lucene. Lucene
uses many indices. I've already implemented a simple structure where different index-objects inherit the methods of a parent class. The problem is that, whatever method is implemented in that parent class, it automatically becomes available for all subclasses to use. I want to give the option to the user to determine if he wants to do a phrase search, a term search or whatever else there is available for that specific index. The catch is, some indices shouldn't have the option to conduct phrase search, for example.

First Thoughts

I've thought of implementing something close to the Composite pattern,
as described by the GoF. I would implement the search operations (e.g. term search, phrase search) as primitive operations implementing some Component class and add these primitive objects later on to a Composite object. The Composite object will be implementing the same Component class as the primitives.

public abstract class Index {
    public Index(String indexPath) {
        // Constructor using the information provided by the subclass
    }

    public void phraseSearch(...) {
         // Do the operation
    }

    public void termSearch(...) {
        // Do the operation
    }

    public void categorySearch(...) {
        // Do the operation
    }
}

public class ReviewIndex extends Index {
    public ReviewIndex() {
        super("./review_index/");
    }
}

public class TipIndex extends  Index {
    public TipIndex() {
        super("./review_index/");
    }
}

Expected Outcome

The class ReviewIndex shouldn't be able to perform a categorySearch but be able to execute phraseSearch and termSearch. Respectively, the TipIndex class should be able to execute some of the parent class methods.

Final Thoughts

I know that in my solution there is no code duplication but there are useless methods being generated each time a new index object is created. Thank you all in advance!

P.S. If you think the Composite pattern is the way to go, in which way would you actually add the primitive objects to the composite class and in which would you invoke them when need be.