我有一个抽象类A，定义了一些抽象方法。这意味着，为了使类可以实例化，所有的抽象方法都必须被实现。
我希望所有的子类都实现一个带有两个整数参数的构造函数。
声明一个构造函数会破坏我的目的，因为我想在子类中定义构造函数，而且我不知道任何关于实现的信息。此外，我不能将构造函数声明为抽象的。
有没有办法做到这一点？
我想要的示例：
假设我正在定义一个矩阵类的API。在我的问题中，矩阵的尺寸不能更改。
为了创建一个矩阵，我需要提供其大小。
因此，我希望所有的实现者都提供带有大小参数的构造函数。这个构造函数是由问题引起的，而不是由实现问题引起的。实现可以随便做任何事情，只要所有方法的语义保持不变。
假设我想在我的抽象类中提供一个invert()方法的基本实现。这个方法将创建一个新的矩阵，尺寸与this相反。更具体地说，正如在抽象类中定义的那样，它将使用一个带有两个整数参数的构造函数创建一个与this相同的类的新实例。由于它不知道将要使用的实例，它将使用反射（getDefinedConstructor），而我希望有一种方法来保证我会得到它，并且对于实现来说是有意义的。
interface MyClassFactory
{
MyClass newInstance(int x, int y);
}
那么您的MyClass的每个具体子类也需要一个工厂，该工厂知道如何根据两个整数构建实例。虽然不是特别方便，但仍然需要构建工厂实例本身。那么，这里的真实情况是什么呢？
FixedSizeMatrix 声明一个无参构造函数，它看起来像这样 public FixedSizeMatrix() { super(10, 10); }，就像 Jon 所说的那样。API 更多关注的是方法（如何使用对象）而不是构造函数（如何构建对象）。 - matt babstract class RequiresConstructor
{
RequiresConstructor( int x, int y ) throws NoSuchMethodException
{
super();
System.out.println( this.getClass().getName() ) ;
this.getClass(). getConstructor ( int.class , int.class ) ;
}
public static void main( String[] args ) throws NoSuchMethodException
{
Good good = new Good ( 0, 0 );
OK ok = new OK ();
Bad bad = new Bad ();
}
}
class Good extends RequiresConstructor
{
public Good( int x, int y ) throws NoSuchMethodException
{
super( x, y ) ;
}
}
class OK extends RequiresConstructor
{
public OK( int x, int y ) throws NoSuchMethodException
{
super( x, y ) ;
throw new NoSuchMethodException() ;
}
public OK() throws NoSuchMethodException
{
super( 0, 0 ) ;
}
}
class Bad extends RequiresConstructor
{
public Bad() throws NoSuchMethodException
{
super( 0, 0 ) ;
}
}
import java.lang.reflect.Constructor;
public abstract class Gaga {
public Gaga() {
boolean found = false;
try {
Constructor<?>[] constructors = getClass().getConstructors();
for (Constructor<?> c : constructors) {
if (c.getParameterTypes().length==2) {
Class<?> class0 = c.getParameterTypes()[0];
Class<?> class1 = c.getParameterTypes()[1];
if ( (class0.getName().equals("int") || class0.isAssignableFrom(Integer.class))
&& (class1.getName().equals("int") || class1.isAssignableFrom(Integer.class)) )
found = true;
}
}
} catch (SecurityException e)
{
found = false;
}
if (!found)
throw new RuntimeException("Each subclass of Gaga has to implement a constructor with two integers as parameter.");
//...
}
}
还有一个测试类：
public class Test {
private class Gaga1 extends Gaga {
public Gaga1() { this(0, 0); }
public Gaga1(int x, Integer y) { }
}
private class Gaga2 extends Gaga {
}
public static void main(String[] args)
{
new Gaga1();
new Gaga1(1, 5);
new Gaga2();
System.exit(0);
}
}
public abstract class SupperClass {
protected Foo foo;
//primary constructor
public SupperClass(Foo foo) {
this.foo = foo;
}
private SupperClass(){
//with this private constructor, the subclass forced to implement primary constructor
}
}
子类：public class SubClass extends JLLayer {
public SubClass(Foo foo) {
super(foo);
}
}
@SupportedAnnotationTypes("pl.selvin.constructorsconstraints.apt.ConstructorConstraint")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class ConstructorConstraintProcessor extends AbstractProcessor {
private static final TypeVisitor<Boolean, ArrayList<String>> constraintArgsVisitor =
new SimpleTypeVisitor7<Boolean, ArrayList<String>>() {
public Boolean visitExecutable(ExecutableType t, ArrayList<String> args) {
final List<? extends TypeMirror> types = t.getParameterTypes();
if (args.size() != types.size()) {
return false;
}
for (int i = 0; i < args.size(); i++) {
if (!args.get(i).equals(types.get(i).toString()))
return false;
}
return true;
}
};
@Override
public Set<String> getSupportedOptions() {
final HashSet<String> ret = new HashSet<>();
ret.add("org.gradle.annotation.processing.aggregating");
return ret;
}
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
for (final TypeElement type : annotations) {
processConstructorConstraintClasses(env, type);
}
return true;
}
private void processConstructorConstraintClasses(final RoundEnvironment env, final TypeElement type) {
final Element constructorConstraintElement = processingEnv.getElementUtils().getTypeElement(ConstructorConstraint.class.getName());
final TypeMirror constructorConstraintType = constructorConstraintElement.asType();
final HashMap<String, ArrayList<String>> constructorConstraints = new HashMap<>();
final ArrayList<Element> elements = new ArrayList<>();
for (final Element element : env.getElementsAnnotatedWith(type)) {
elements.add(element);
for (AnnotationMirror am : element.getAnnotationMirrors()) {
if (am.getAnnotationType().equals(constructorConstraintType)) {
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : am.getElementValues().entrySet()) {
if ("arguments".equals(entry.getKey().getSimpleName().toString()) && entry.getValue() instanceof Attribute.Array) {
final Attribute.Array array = (Attribute.Array) entry.getValue();
for (final Attribute a : array.values) {
final String className = element.toString();
final ArrayList<String> arguments;
if(constructorConstraints.containsKey(className)) {
arguments = constructorConstraints.get(className);
} else {
arguments = new ArrayList<>();
constructorConstraints.put(className, arguments);
}
arguments.add(a.getValue().toString());
}
}
}
break;
}
}
}
for (Element element : elements) {
final TypeMirror derived = element.asType();
for (String className : constructorConstraints.keySet()) {
final TypeMirror baseType = processingEnv.getElementUtils().getTypeElement(className).asType();
if(derived.equals(baseType)) {
continue;
}
if(processingEnv.getTypeUtils().isAssignable(derived, baseType)) {
processClass(element, constructorConstraints.get(className));
}
}
}
}
private void processClass(Element element, ArrayList<String> arguments) {
if (!doesClassContainConstructorWithConstraint(element, arguments)) {
final String needs;
if (arguments == null || arguments.size() == 0) {
needs = "a No-Args Constructor";
} else {
needs = "a Contrcutor with arguments(" + String.join(", ", arguments) + ")";
}
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Class " + element + " needs " + needs);
}
}
private boolean doesClassContainConstructorWithConstraint(Element element, ArrayList<String> arguments) {
for (final Element subElement : element.getEnclosedElements()) {
if (subElement.getKind() == ElementKind.CONSTRUCTOR && subElement.getModifiers().contains(Modifier.PUBLIC)) {
final TypeMirror mirror = subElement.asType();
if (mirror.accept(constraintArgsVisitor, arguments))
return true;
}
}
return false;
}
}
像泛型类一样
class Whatever<T>{
Whatever(T arg) {}
}
多个构造函数
它不是增量的
public class QueryProviders {
private final ArrayList<AbstractQueryProvider> providers = new ArrayList<>();
@SafeVarargs
public QueryProviders(SomeClass arg1, ...OtherArgs... ,
Class<? extends AbstractQueryProvider>... providerClasses) {
try {
for (Class<? extends AbstractQueryProvider> providerClass : providerClasses) {
final Constructor<? extends AbstractQueryProvider> ctor = providerClass.getConstructor(SomeClass arg1, ...OtherArgs...);
providers.add(ctor.newInstance(arg1, ...OtherArgs...));
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
和班级
public abstract class AbstractQueryProvider {
public AbstractQueryProvider(SomeClass arg1, ...OtherArgs...) {
}
}
和使用
QueryProviders providers = new QueryProviders(SomeClass arg1, ...OtherArgs...,
Backup.class,
GoodsPrices.class, ...OtherDerived...);
其中Backup和GoodsPrices是从AbstractQueryProvider派生出来的。
当我忘记这样的构造函数时，我需要在编译时出现错误（换句话说，“强制一个构造函数”）
因此，使用APT处理器，您将拥有以下类：
@ConstructorConstraint(SomeClass.class, ...)
public abstract class AbstractQueryProvider {
public AbstractQueryProvider(SomeClass arg1, ...) {
}
}
@Inherited
@Documented
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface ConstructorConstraint {
Class<?>[] arguments() default {};
}
让抽象类拥有一个抽象方法，该方法需要传入您想要的参数。例如：
public abstract void setSize(int rows,int columns);
免责声明：
标题中的问题是“如何强制要求在我的抽象类的所有子类中定义构造函数”，我想回答这个问题，而不是讨论OP的真实需求。
答案是：
您可以选择APT处理器
例如，我想使用以下内容：
public class QueryProviders {
private final ArrayList<AbstractQueryProvider> providers = new ArrayList<>();
@SafeVarargs
public QueryProviders(SomeClass arg1, ...OtherArgs... ,
Class<? extends AbstractQueryProvider>... providerClasses) {
try {
for (Class<? extends AbstractQueryProvider> providerClass : providerClasses) {
final Constructor<? extends AbstractQueryProvider> ctor = providerClass.getConstructor(SomeClass arg1, ...OtherArgs...);
providers.add(ctor.newInstance(arg1, ...OtherArgs...));
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
和类
public abstract class AbstractQueryProvider {
public AbstractQueryProvider(SomeClass arg1, ...OtherArgs...) {
}
}
和使用
QueryProviders providers = new QueryProviders(SomeClass arg1, ...OtherArgs...,
Backup.class,
GoodsPrices.class, ...OtherDerived...);
其中Backup和GoodsPrices是从AbstractQueryProvider派生的。
当我忘记这样的构造函数时，我需要编译时错误（换句话说，“强制构造函数”）
因此，使用APT处理器，您将拥有以下类：
@ConstructorConstraint(SomeClass.class, ...)
public abstract class AbstractQueryProvider {
public AbstractQueryProvider(SomeClass arg1, ...) {
}
}
（包:“pl.selvin.constructorsconstraints.apt”） 带有以下注释：
@Inherited
@Documented
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface ConstructorConstraint {
Class<?>[] arguments() default {};
}
像这样的处理器：
@SupportedAnnotationTypes("pl.selvin.constructorsconstraints.apt.ConstructorConstraint")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class ConstructorConstraintProcessor extends AbstractProcessor {
private static final TypeVisitor<Boolean, ArrayList<String>> constraintArgsVisitor =
new SimpleTypeVisitor7<Boolean, ArrayList<String>>() {
public Boolean visitExecutable(ExecutableType t, ArrayList<String> args) {
final List<? extends TypeMirror> types = t.getParameterTypes();
if (args.size() != types.size()) {
return false;
}
for (int i = 0; i < args.size(); i++) {
if (!args.get(i).equals(types.get(i).toString()))
return false;
}
return true;
}
};
@Override
public Set<String> getSupportedOptions() {
final HashSet<String> ret = new HashSet<>();
ret.add("org.gradle.annotation.processing.aggregating");
return ret;
}
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
for (final TypeElement type : annotations) {
processConstructorConstraintClasses(env, type);
}
return true;
}
private void processConstructorConstraintClasses(final RoundEnvironment env, final TypeElement type) {
final Element constructorConstraintElement = processingEnv.getElementUtils().getTypeElement(ConstructorConstraint.class.getName());
final TypeMirror constructorConstraintType = constructorConstraintElement.asType();
final HashMap<String, ArrayList<String>> constructorConstraints = new HashMap<>();
final ArrayList<Element> elements = new ArrayList<>();
for (final Element element : env.getElementsAnnotatedWith(type)) {
elements.add(element);
for (AnnotationMirror am : element.getAnnotationMirrors()) {
if (am.getAnnotationType().equals(constructorConstraintType)) {
for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry : am.getElementValues().entrySet()) {
if ("arguments".equals(entry.getKey().getSimpleName().toString()) && entry.getValue() instanceof Attribute.Array) {
final Attribute.Array array = (Attribute.Array) entry.getValue();
for (final Attribute a : array.values) {
final String className = element.toString();
final ArrayList<String> arguments;
if(constructorConstraints.containsKey(className)) {
arguments = constructorConstraints.get(className);
} else {
arguments = new ArrayList<>();
constructorConstraints.put(className, arguments);
}
arguments.add(a.getValue().toString());
}
}
}
break;
}
}
}
for (Element element : elements) {
final TypeMirror derived = element.asType();
for (String className : constructorConstraints.keySet()) {
final TypeMirror baseType = processingEnv.getElementUtils().getTypeElement(className).asType();
if(derived.equals(baseType)) {
continue;
}
if(processingEnv.getTypeUtils().isAssignable(derived, baseType)) {
processClass(element, constructorConstraints.get(className));
}
}
}
}
private void processClass(Element element, ArrayList<String> arguments) {
if (!doesClassContainConstructorWithConstraint(element, arguments)) {
final String needs;
if (arguments == null || arguments.size() == 0) {
needs = "a No-Args Constructor";
} else {
needs = "a Contrcutor with arguments(" + String.join(", ", arguments) + ")";
}
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Class " + element + " needs " + needs);
}
}
private boolean doesClassContainConstructorWithConstraint(Element element, ArrayList<String> arguments) {
for (final Element subElement : element.getEnclosedElements()) {
if (subElement.getKind() == ElementKind.CONSTRUCTOR && subElement.getModifiers().contains(Modifier.PUBLIC)) {
final TypeMirror mirror = subElement.asType();
if (mirror.accept(constraintArgsVisitor, arguments))
return true;
}
}
return false;
}
}
优点：
缺点：
泛型类，例如
class Whatever<T>{
Whatever(T arg) {}
}
多个构造函数
它不是增量的
visitExecutable以检查不是t.getParameterTypes().isEmpty()而是如果给定类的参数（您可能可以将其传递给注释）...它将在编译时工作。 - Selvin