Битовые поля C / C ++ по сравнению с побитовыми операторами для выделения битов, что быстрее, лучше, более переносимо?

Как разработчики Java, разрабатывающие определенные API, мы часто сталкиваемся с этой проблемой. Я повторил свои собственные сомнения, когда столкнулся с этим сообщением, но у меня есть подробное обходное решение:

// class name is awful for this example, but it will make more sense if you
//  read further
public interface MetaDataKey<T extends Serializable> extends Serializable
{
    T getValue();
}

public final class TypeSafeKeys
{
    static enum StringKeys implements MetaDataKey<String>
    {
        A1("key1");

        private final String value;

        StringKeys(String value) { this.value = value; }

        @Override
        public String getValue() { return value; }
    }

    static enum IntegerKeys implements MetaDataKey<Integer>
    {
        A2(0);

        private final Integer value;

        IntegerKeys (Integer value) { this.value = value; }

        @Override
        public Integer getValue() { return value; }
    }

    public static final MetaDataKey<String> A1 = StringKeys.A1;
    public static final MetaDataKey<Integer> A2 = IntegerKeys.A2;
}

. В этот момент вы получаете преимущество от истинного постоянного значения enum (и все преимущества, которые идут с этим), а также уникальная реализация interface, но у вас есть глобальная доступность, желаемая enum.

Ясно, что это добавляет многословие, что создает потенциал для ошибок копирования / вставки. Вы можете сделать enum s public и просто добавить дополнительный слой к их доступу.

Конструкции, которые имеют тенденцию использовать эти функции, как правило, страдают от хрупких реализаций equals, потому что они обычно связаны с другое уникальное значение, такое как имя, которое может быть невольно дублировано в кодовой базе для аналогичной, но другой цели. Используя enum s по всей доске, равенство - это халява, которая невосприимчива к такому хрупкому поведению.

. Основным недостатком такого, как система, помимо многословия, является идея преобразования вперед и назад между глобально уникальные ключи (например, маршалинг и JSON). Если они являются просто ключами, то их можно безопасно восстановить (продублировать) за счет потери памяти, но используя то, что было ранее слабостью - equals - в качестве преимущества.

обходной путь к этому, который обеспечивает уникальность глобальной реализации, загромождая его анонимным типом для глобального экземпляра:

public abstract class BasicMetaDataKey<T extends Serializable>
     implements MetaDataKey<T>
{
    private final T value;

    public BasicMetaDataKey(T value)
    {
        this.value = value;
    }

    @Override
    public T getValue()
    {
        return value;
    }

    // @Override equals
    // @Override hashCode
}

public final class TypeSafeKeys
{
    public static final MetaDataKey<String> A1 =
        new BasicMetaDataKey<String>("value") {};
    public static final MetaDataKey<Integer> A2 =
        new BasicMetaDataKey<Integer>(0) {};
}

Обратите внимание, что каждый экземпляр использует анонимную реализацию, но ничего не нужно для его реализации, поэтому {} пустые. Это и запутывает, и раздражает, но работает, если ссылки на экземпляры предпочтительнее, а помехи сведены к минимуму, хотя это может быть немного загадочно для менее опытных разработчиков Java, что затрудняет его поддержку.

Наконец, единственный способ обеспечить глобальную уникальность и переназначение - быть немного более творческим в том, что происходит. Наиболее распространенное использование для общедоступных интерфейсов, которые я видел, для котей MetaData, которые имеют тенденцию смешивать множество разных значений с разными типами (T в каждом ключе):

public interface MetaDataKey<T extends Serializable> extends Serializable
{
    Class<T> getType();
    String getName();
}

public final class TypeSafeKeys
{
    public static enum StringKeys implements MetaDataKey<String>
    {
        A1;

        @Override
        public Class<String> getType() { return String.class; }

        @Override
        public String getName()
        {
            return getDeclaringClass().getName() + "." + name();
        }
    }

    public static enum IntegerKeys implements MetaDataKey<Integer>
    {
        A2;

        @Override
        public Class<Integer> getType() { return Integer.class; }

        @Override
        public String getName()
        {
            return getDeclaringClass().getName() + "." + name();
        }
    }

    public static final MetaDataKey<String> A1 = StringKeys.A1;
    public static final MetaDataKey<Integer> A2 = IntegerKeys.A2;
}

Это обеспечивает такую ​​же гибкость, как и первый вариант, и обеспечивает механизм получения ссылки посредством отражения, если это становится необходимым позже, поэтому избегая необходимости в последующем. Он также избегает многих ошибок, связанных с ошибкой копирования / вставки, которые первый параметр предоставляет, поскольку он не будет компилироваться, если первый метод неверен, а второй метод не нужно изменять. Единственное замечание заключается в том, что вы должны убедиться, что enum s предназначены для использования таким образом public, чтобы избежать доступа к ошибкам доступа, поскольку они не имеют доступа к внутреннему enum; если вы не хотите, чтобы эти MetaDataKey проходили через маршалированный провод, то их можно было скрывать из внешних пакетов, чтобы их автоматически отменить (во время маршалинга, рефлексивно проверить, доступен ли enum, и если это не так, то игнорируйте ключ / значение). Нет ничего выигранного или потерянного, сделав его public, за исключением предоставления двух способов доступа к экземпляру, если поддерживаются более очевидные static ссылки (поскольку экземпляры enum просто так или иначе).

Я просто хочу, чтобы они сделали это так, чтобы enum s могли расширять объекты на Java. Может быть, в Java 9?

Окончательный вариант действительно не решает вашу потребность, поскольку вы просите значения, но я подозреваю, что это приближается к фактической цели.