상속을 고려해 설계하고 문서화하라. 그러지 않았다면 상속을 금지하라

/**
     * {@inheritDoc}
     *
     * @implSpec
     * This implementation iterates over the collection looking for the
     * specified element.  If it finds the element, it removes the element
     * from the collection using the iterator's remove method.
     *
     * <p>Note that this implementation throws an
     * {@code UnsupportedOperationException} if the iterator returned by this
     * collection's iterator method does not implement the {@code remove}
     * method and this collection contains the specified object.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     */
    public boolean remove(Object o) {
        Iterator<E> it = iterator();
        ...

/** Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive. Shifts any succeeding elements to the left (reduces their index). This call shortens the list by (toIndex - fromIndex) elements. (If toIndex==fromIndex, this operation has no effect.)
This method is called by the clear operation on this list and its subLists. Overriding this method to take advantage of the internals of the list implementation can substantially improve the performance of the clear operation on this list and its subLists.
Params:
fromIndex – index of first element to be removed toIndex – index after last element to be removed
Implementation Requirements:
This implementation gets a list iterator positioned before fromIndex, and repeatedly calls ListIterator.next followed by ListIterator.remove until the entire range has been removed. Note: if ListIterator.remove requires linear time, this implementation requires quadratic time.
**/

protected void removeRange(int fromIndex, int toIndex) {
        ListIterator<E> it = listIterator(fromIndex);
        for (int i=0, n=toIndex-fromIndex; i<n; i++) {
            it.next();
            it.remove();
        }
    }
}

public class Super{

    // 생성자가 재정의 가능한 메서드 호출
    public Super(){
       overrideMe();
    }

    public void overrideMe(){

    }
}

public final class Sub extends Super {
    
    // 초기화 되지 않은 final 필드를 생성자에서 초기화
    private final Instant instant;
    
    Sub() {
       instant = Instant.now();
    }

    // 상위 클래스의 생성자 호출
    @Override 
    public void overrideMe(){
        System.out.println(instant);
    }
}

public class NonePrivate {

    public nonePrivate() {
    }
    
    public void overrideMe() {
        System.out.println("override");
    }
    
    public void do() {
        overrideMe();
    }
}   

public class BetterPrivate {

    public BetterPrivate() {
    }

    public void overrideMe() {
        helper();
    }

    private void helper() {
        System.out.println("override");
    }

    public void do() {
        helper();
    }
}