java: inheritance questions about overriding methods

Is it good practice to have a no use argument in the method in parent class?

It depends. If the API design anticipates that subclasses will need the parameter even though the base class doesn't, and you want to ensure that the parameter version of the method can be called through a parent-typed reference:

Parent instance = new Subclass();
Feature f = instance.getFeature("foo");

...then you have to include the parameter in the parent class signature even though you don't use it in the implementation. You might also have the no-parameter version which always provides the non-parameter functionality:

class Parent {
    public Feature getFeature() { // Maybe you'd want this, maybe not
        return defaultFeature;
    }
    public Feature getFeature(String name) {
        return this.getFeature();
    }
}
class Subclass extends Parent {
    @Override
    public Feature getFeature(String name) {
        return /*...*/;
    }
}

But if you anticipate that subclass instances will only be used with subclass-typed references:

Subclass instance = new Subclass();
// ^^---------- note
Feature f = instance.getFeature("foo");

...then there's no reason for the parent class's getFeature to have it. Subclasses can add it as an overload:

class Parent {
    public Feature getFeature() {
        return defaultFeature;
    }
}
class Subclass extends Parent {
    public Feature getFeature(String name) {
        return /*...*/;
    }
}

It just means that Parent-typed references will be limited to the no-parameters feature of getFeature.

Actual you override and it is a misleading approach as the client of the classes will have to pass a String while this is used only in the child class :

child.getFeature("makeSenseArg");
parent.getFeature("notUsedArg");

You should overload the getFeature() method in the child class:

//in parent class:
getFeature(){
    return defaultFeature;
}

//in child class:
getFeature(String name){
    return new Feature(name);
}

You would not benefit any longer of the polymophism but it should probably not be an issue as these are two distinct behaviors.
Merging them in a single method signature is maybe not the best thing to do.

Note that if you really need to rely on overriding, you could annotate the parameter with @javax.annotation.Nullable.
It makes the API clearer for the class clients and in addition code analysis tools such as Sonar takes also these annotations into consideration.
This would give :

// parent class
Feature getFeature(@Nullable String name){
    return defaultFeature;
}

Besides, if for the overrided method, the parameter is mandatory, you could even specify the "reverse" annotation (@javax.validation.constraints.NotNulll) :

//child class
Feature getFeature(@NotNulll String name){
    return new Feature(name);
}

Clients would call them :

child.getFeature("makeSenseArg");
parent.getFeature(null);