Предотвратяване на подкласове от добавяне на методи

Ако наистина не искате да правите това... един от начините би бил програмно да проверите в конструктора на абстрактния клас дали методите, дефинирани в класа, са тези, които са разрешени.

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public abstract class Base {

    private static final Set<String> allowedMethodNames = new HashSet<>(Arrays.asList("doThis", "wait", "wait", "wait", "equals", "toString", "hashCode", "getClass", "notify", "notifyAll"));

    public Base() {
        Set<String> allMethods = new HashSet<>();
        for (Method aMethod : getClass().getMethods()) {
            allMethods.add(aMethod.getName());
        }
        if (!allowedMethodNames.equals(allMethods)) {
            allMethods.removeAll(allowedMethodNames);
            throw new IllegalStateException("Following methods not allowed <" + allMethods + ">");
        }
    }

    public abstract void doThis();
}

public class Disallowed extends Base {

    @Override
    public void doThis() {
        System.out.println("dooooooo");
    }

    public void doSomethingElse() {
        System.out.println("not allowed");
    }

    public static void main(String[] args) {
            new Allowed().doThis();
        new Disallowed();
    }

}

public class Allowed extends Base {

    @Override
    public void doThis() {
        System.out.println("doing this");
    }


}

Когато някой се опитва да създаде екземпляр на „Disallowed“, това ще се провали. Въпреки това „new Allowed().doThis()“ ще работи добре.

По-изящен начин да направите това би бил да въведете персонализирана анотация + процесор за анотация и да направите същата проверка по време на компилацията.

Не можеш да го направиш. Само ако класовете са final, можете да гарантирате, че не може да бъде създаден подклас.

Можете също така да направите методи окончателни (дори в абстрактни класове), така че отмяната им да е забранена.

Най-добре е да създадете интерфейс с видими всички методи, които искате, и да принудите всички потребители на вашия API да имат достъп до обектите чрез този интерфейс. По този начин, дори ако реализациите добавят свои собствени неща, тези неща няма да бъдат видими.

Едно решение за това е да се внедри фабрика за връщане на конкретните класове; за "добавена сигурност", бихте могли да поставите всички реализации в същия пакет като тази фабрика и да направите пакета на конструкторите локален (но това често не е практично):

public final class MyFactory
{
    // ....
    public MyInterface getConcrete()
    {
        return new MyInterfaceImpl();
    }
    // etc etc -- getStones(), getTar(), getFeathers() and so on
}

Имайте предвид, че строителите могат да се използват и за това.

Няма такъв начин. Защо искате да наложите такъв стил на кодиране?

Ако наистина трябва да наложите такъв стил, можете да създадете "прилагане на правила", което проверява вашия класов път и сравнява методите на вашите абстрактни родителски класове с техните подкласове.

Това е Java, което означава гъвкавост. Така че java ви дава по-удобно използване на абстрактните методи и отмяната им от вашите подкласове. Също така човек трябва да има идея за добавяне на нови методи към тези подкласове. Дори Java не може да промени това. Ако това стане, тогава цялата Java общност се срива. Невъзможно е да предотвратите добавянето на методи към техните подкласове. Само вие можете да ги спрете да разширяват вашите класове и да заменят вашите методи.