Q:

Using superclass "protected final" methods to keep common code for subclasses

As a (pedantic) beginner Java programmer I would like to know, is it a good practice to move a common block of code that all subclasses use to a separate protected (final) method in parent class? Tasks like filling lists with common values, or common filtering algorithms, etc...
Is it good to also use protected static methods?
class A {
    protected final List<String> getVariants() {...}
    protected final List<String> filterResults(List<String> variants) {...}
}

class B extends A {
    public List<String> doSomethingUsefull() {
        List<String> commonVariants = getVariants();
        ...
        return filterResults(commonVariants);
    }
}

class C extends A {
    public void doSomethingUsefull() {
        List<String> commonVariants = getVariants();
        ...
        return filterResults(commonVariants);
    }

    public void doMoreUsefullThings() {
        List<String> commonVariants = getVariants();
        ...
        return filterResults(commonVariants);
    }
}

A:

If you're a Java beginner, and you are thinking about these sorts of things, then now is a good time to read Chapter 4 "Classes and Interfaces" in a book called "Effective Java." The information there will be more thorough and nuanced than answers that you get here.
Here's one way to think about mixing the final, protected, and static keywords:

OO purists will advise you to avoid static because it breaks the OO paradigm.
Of course, using the final keyword prevents subclasses from overriding a method as well. In this respect, the outcome is the same as with static.
final should be used more often, and it's a good idea to use it along with protected. See Item 17 in "Effective Java".
protected and static are not used together very often. You'd be mixing an OO construct with a construct that breaks normal OO behavior, so the combination is odd.

A:

It seems reasonable to me - although you might want to make A abstract as well. Also consider using composition instead - could B and C contain an A instead of subclassing it?

