Forcer la surcharge d'une méthode

Bonjour à tous

J'ai une classe java qui comporte des méthodes avec un comportement de base.

Je veux spécialiser cette classe et je souhaite forcer la surcharge (même si cela n'est pas utile) des méthodes de la classe de base, ceci dans le but d'être sur de ne pas en oublier une.

la méthode abstract ne fonctionne pas car j'ai du code dans la méthode de base
je n'ai pas trouvé d'annotation pour exiger une surcharge.

Quel serait la meilleur solution pour gérer ce problème.

Merci d'avance

C'est bien abstract, mais en fournissant le code de la classe de base, dans d'autres méthodes que les méthodes dont tu veux forcer la redéfinition. (Qui du coup, sera une première définition et pas tellement une redéfinition, même si tant qu'à faire il faut utiliser l'annotation @Override.)

(Et ça s'appelle redéfinir, pas surcharger. La surcharge, c'est quand on fait des méthodes qui ont le même nom, et donc qui prennent des paramètres différents sinon c'est évidemment refusé, et qui n'ont pas d'autre lien que le fait d'avoir le même nom.)

Bonjour thelvin

Merci pour ta réponse.

J'ai trouvé une solution par un test unitaire en attendant de trouver mieux (peut être en créant ma propre annotation du type RetentionPolicy.SOURCE, mais je galère sur cette techno).

Voici ma solution
J'ai créé une interface qui va contenir toutes les méthodes dont je veux être sur qu'elles vont être redéfinies

mon test va donc récupérer cette liste des méthodes dans cette interface et va vérifier qu'elles sont bien redéfinies dans les classes que j'ai écrit.
Voici donc le code de mon test unitaire qui test la classe abstraite et une classe dérivée de la classe abstraite.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
package orb.bpy.test;
 
import static org.junit.Assert.assertNull;
 
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
 
import org.bpy.test.AbstractClass;
import org.bpy.test.FinalClass;
import org.bpy.test.NeededInterface;
import org.junit.Test;
 
public class CheckInterface {
 
	@Test
	public void checkInterfaceInFinalClass() {
		Method[] methodsToOverride = NeededInterface.class.getDeclaredMethods();
		Method[] declaredMethods = FinalClass.class.getDeclaredMethods();
 
		for (Method methodToOverride : methodsToOverride) {
			String message = checkExistingMethod(methodToOverride, declaredMethods);
			assertNull("Error in " + FinalClass.class.getSimpleName(), message);
		}
	}
 
	@Test
	public void checkInterfaceInAsbtarctClass() {
		Method[] methodsToOverride = NeededInterface.class.getDeclaredMethods();
		Method[] declaredMethods = AbstractClass.class.getDeclaredMethods();
 
		for (Method methodToOverride : methodsToOverride) {
			String message = checkExistingMethod(methodToOverride, declaredMethods);
			assertNull("Error in " + AbstractClass.class.getSimpleName(), message);
		}
	}
 
	private String checkExistingMethod(Method methodToOverride, Method[] declaredMethods) {
		boolean methodFound = false;
 
		for (Method declaredMethod : declaredMethods) {
			if (methodToOverride.getName().equals(declaredMethod.getName()) && 
				methodToOverride.getParameterCount() == declaredMethod.getParameterCount() ) {
 
				Parameter[] neededParameters = methodToOverride.getParameters();
				Parameter[] checkedParameters = declaredMethod.getParameters();
 
				boolean checkParameters = checkParameters(neededParameters,checkedParameters); 
				if (checkParameters) {
					methodFound = true;
				}
			}
		}
 
		if (methodFound) {
			return null;
		} else {
			StringBuilder strBuilder = new StringBuilder("Can't found method: ");
			strBuilder.append(methodToOverride.toString());
			return strBuilder.toString();
		}
	}
 
	private boolean checkParameters(Parameter[] neededParameters, Parameter[] checkedParameters) {
		boolean state = true;
		for (int i=0 ;i<neededParameters.length ; i++) {
			Parameter neededParameter = neededParameters[i];
			Parameter checkedParameter = checkedParameters[i];
 
			if (!neededParameter.getType().equals(checkedParameter.getType())) {
				state = false;
			}
		}
		return state;
	}
}

Oui non mais, a priori c'est stupide. Si c'était utile de faire tout ça, Java le ferait pour toi. Mais ça sert à rien, il faut juste que tes méthodes soient abstract (ou viennent d'une interface et ne soient pas implémentée, ça marche aussi, oui).

Pourquoi tu insistes à faire autrement ? Tu ne veux pas apprendre Java ?