Есть два способа сделать это, но я тоже не рекомендую.
Подход первый: generics
В частности, рекурсивные (которые относятся к самому универсальному классу):
public class ClassA<R extends ClassA<R>> { // note the recursive nature
public ArrayList<String> v1 = new ArrayList<>();
@SuppressWarnings("unchecked")
protected R self() {
return (R) this;
}
public R addOnce(String s1) {
v1.add(s1);
return self();
}
}
Если вам не нравятся такие SuppressWarnings (и вам не следует! Они могут скрывать ошибки), вы можете обойти это, сделав abstract class AbstractClassA, с protected abstract R self() переопределением каждого подкласса.:
// AbstractClassA looks like ClassA above; it contains addOnce
class ClassA extends AbstractClassA<ClassA> {
@Override
public ClassA self() {
return this;
}
}
class ClassB extends AbstractClassA<ClassB> {
ClassB addTwice(String s2) {
...
return this;
}
}
Это означает, что в большинстве случаев вы будете использовать подстановочный знак AbstractClassA<?>.Помимо этого уродства, это становится волосатым, если вы попытаетесь сериализовать эти экземпляры.AbstractClassA.class возвращает Class<AbstractClassA>, , а не a Class<AbstractClassA<?>>, что может заставить вас делать больше непроверенных приведений .
Кроме того, подклассы AbstractClassA не наследуйте этот <R> тип, поэтому, если вы хотите определить новые методы, которые сохраняют шаблон (например, в ClassB), вам придется повторять шаблон с новым универсальным параметром в каждом,Я предполагаю, что вы пожалеете об этом.
Подход второй: переопределить каждый метод
Другой способ - вручную переопределить все методы в базовом классе.Когда вы переопределяете метод, вы можете вернуть его подкласс типа возврата исходного метода .Итак:
public class ClassA {
public ArrayList<String> v1 = new ArrayList<>();
public ClassA addOnce(String s1) {
v1.add(s1);
return this;
}
}
public class ClassB extends ClassA {
public ClassB addOnce(String s2) {
super.addOnce(s2);
return this; // same reference as in the super method, but now typed to ClassB
}
...
}
В этом методе нет скрытых ошибок, как в первом подходе.Это работает так же, как вы думаете, что будет.Это просто боль, и это означает, что каждый раз, когда вы добавляете метод в ClassA, вы должны также добавить этот метод в ClassB (и ClassC и т. Д.), Если хотите, чтобы все продолжало работать.Если у вас нет контроля над ClassB / C / и т. Д. (Например, если вы публикуете API), то это может создать проблему и заставить ваш API чувствовать себя недоделанным.
Подход третий: Сначала цепочка из более специфичных подклассов
На самом деле это не ответ на ваш вопрос, а скорее образец, который решает ту же проблему.Идея состоит в том, чтобы сохранить ClassA и ClassB такими же, какими они у вас есть, но всегда сначала вызывать методы ClassB:
new ClassB().addTwice("2").addOnce("1");
Этот подход работает хорошо, но он немного неудобен.В большинстве случаев люди думают о том, чтобы сначала установить вещи для базового класса, а затем установить специфичные для подкласса вещи на подклассы.Если у вас все в порядке с отменой этого и вы действительно хотите использовать эти цепочечные методы, возможно, я бы выбрал этот подход.Но мое реальное предложение:
Мое предложение: забудь об этом
Java просто плохо обрабатывает цепочки методов такого рода.Я бы посоветовал вам просто забыть все это и не пытаться бороться с языком в этом вопросе.Заставьте методы вернуть void и поместите каждый вызов в отдельную строку.Поработав с кодом, который попробовал первый и третий подходы, я обнаружил, что уродство вокруг него очень быстро стареет и, как правило, приносит больше боли, чем оно того стоит.(Я никогда не видел, чтобы второй подход работал, потому что это такая боль, что никто не хочет даже пробовать это. :))