Является ли Reflection недостатком, поскольку частные переменные не могут быть ограничены?

privateМодификатор используется для ограничения доступа извне класса, но с помощью отражения других классов может получить доступ частного метода и поля. Поэтому мне интересно, как мы можем ограничить доступность, если это является частью требования.

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

Чтобы процитировать Херб Саттер о правах доступа класса :

«Проблема здесь заключается в защите от Мерфи против защиты от Макиавелли ... то есть в защите от случайного неправильного использования (что язык делает очень хорошо) против защиты от преднамеренного злоупотребления (что фактически невозможно). В конце концов, если программист хочет достаточно сильно, чтобы подорвать систему, он найдет способ

Нет, это действительно важное преимущество. То, что какой-то разработчик не считал, что кому-то понадобится доступ к какой-то части внутреннего состояния, не означает, что ни один законный вариант использования никогда не появится В этих случаях использование Reflection для выполнения операции на объекте может быть последним средством. Я должен был использовать эту технику не раз.

Вы еще больше ограничиваете доступность, поднимаясь на еще один уровень: среду исполнения.

Не все языки имеют эту концепцию, но по крайней мере с Java вы можете использовать менеджер безопасности, который запрещает делать частные поля доступными. Вы можете вручную установить менеджер безопасности во время выполнения или добавить политику безопасности в файл JAR, который затем запечатывается, чтобы предотвратить изменение.

Дополнительная информация о том, как сделать это в Java: Безопасность отражений

О каком отражении ты говоришь?

Во многих системах отражения обходная инкапсуляция - это явная возможность, которую ваш код должен получить, и не имеет по умолчанию.

Если вас беспокоит инкапсуляция, простое решение состоит в том, чтобы просто не использовать систему отражения, которая не сохраняет ее.

В Python нет модификаторов доступа. Соглашение состоит в том, чтобы префикс подчеркивания методов и переменных, к которым не ожидается доступ из-за пределов класса. Это технически мешает вам получить доступ к этому полю из стороннего класса? Не за что; но если вы это сделаете, вы сами по себе, и вы рискуете что-то сломать, не имея возможности обвинить другой класс.

В C # существуют модификаторы доступа, но они все еще являются лишь соглашением, которое обеспечивается компилятором, но все же соглашением. Это означает, что технически можно по-прежнему обращаться к закрытым переменным и изменять их, либо с помощью Reflection, либо напрямую изменяя память (как это делают тренеры игр ). Последствия точно такие же: если переменные вашего класса изменяются с помощью Reflection из другого класса или с помощью вмешательства в память другого приложения, и это что-то нарушает в вашем классе, это не ваша ошибка.

Обратите внимание, что это, очевидно, создает проблемы безопасности, когда третьи лица могут получить доступ к вашим данным; что-то, что приводит к зашифрованным вариантам строки и аналогичным структурам данных. Но защита вашего кода от такого использования больше связана с ограничениями доступа ОС и уровня кода и не имеет ничего общего с отражением как таковым.