Автоматическое преобразование типов в Java?

Ответ короткий: это возможно с перегрузкой в ​​C++, но нет способа сделать это в Java.

Вы можете перегрузить свои методы, например:

public void doSomething(FooSet data) {
    /* .. */
}

public void doSomething(BarSet data) {
    doSomething(barTOfoo(data));
}

Вы можете сделать и то, и другое вместе:

(1) Напишите методы-оболочки, которые выполняют преобразование в фоновом режиме.

(2) Если ваши объекты имеют правильный hashCode переопределенный метод, методы-оболочки могут управлять очень простым и быстрым кешем, который вы можете создать самостоятельно с помощью простой Map реализации и, возможно, синхронизации (если вы вообще используете объекты одновременно).

Это избавит вас от постоянного преобразования между двумя типами и, возможно, от проблем с производительностью. Даже если вы пойдете против кеширования, я бы все же рекомендовал (как сказали другие авторы) использовать методы упаковки. Это, по крайней мере, сэкономит вам много ненужного набора текста.

Удачи.

Перегрузка работает противоположным образом, вы объявляете два метода в объекте-получателе:

public void doSomething(FooSet data)
{
    /* .. */
}

public void doSomething(BarSet data)
{
    doSomething(barToFoo(data));
}

затем благодаря динамической привязке (википедия) правильный метод выбирается во время выполнения.

Конечно, перегрузка в Java ограничивается объектным уровнем (поскольку вызовы ограничены экземплярами или объявлениями классов), но это работает точно так же.

В вашем случае вы можете попробовать расширить класс также, если он находится во внешней библиотеке, поскольку это java, вы должны быть в состоянии это сделать и добавить метод или с помощью reflection (руководство по Java), чтобы добавить метод динамически.

Автоматическое преобразование типов не поддерживается (вам нужен неявные преобразования типов для этого).

Но вы можете попробовать использовать тип Variant в качестве соединительной коробки для переключения между типами:

/** Given a BarSet, returns a FooSet */
public Function<BarSet, FooSet> barTofoo = new Function<BarSet, FooSet>() {
    @Override public FooSet apply(BarSet input) { /* ... */ }
}

/** Given a FooSet, returns a BarSet */
public Function<FooSet, BarSet> fooToBar = new Function<FooSet, BarSet>() {
    @Override public BarSet apply(FooSet input) { /* ... */ }
}

/** Create a type conversion context in which both of these conversions are registered */
TypeConversionContext fooBarConversionContext = MatchingTypeConversionContext.builder()
    .register(FooSet.class, BarSet.class, fooToBar)
    .register(BarSet.class, FooSet.class, barToFoo)
    .build();

/** Put a FooSet into a Variant, bound to our type conversion context */
FooSet fooSet = new FooSet();
Variant data = Variant.of(fooSet).in(fooBarConversionContext);

/** Pull a BarSet out of the Variant */
public void doSomething(Variant data) {
    Preconditions.checkArgument(data.isConvertibleTo(BarSet.class);
    BarSet barSet = data.as(BarSet.class);
    // ...
}

Java был создан с учетом видимости. Каждый программист должен уметь прочитать всего одну строку и понять, что там происходит. Вот почему у него нет перегрузки операторов, вот почему у него нет никакого автоматического преобразования пользовательского типа. Итак, если вы не напишите свои собственные оболочки для одной из библиотек, которые будут принимать типы из другой библиотеки и явно преобразовывать их, вам не повезло.