Почему является Java безопасным важным кодированием?
Похоже, вы не конвертируете переменную, созданную с помощью read.csv(), в объект emg. В документации приведен следующий пример:
x <- rnorm(10000, 0, 1)
emg1 <- emg(x, samplingrate=1000, units="mV", data.name="")
summary(emg1)
EMG Object
Total number of samples: 10000
Number of channels: 1
Duration (seconds): 10
Samplingrate (Hertz): 1000
Channel information:
Units: mV
plot(emg1, main="Simulated EMG")
Что дает: 
Основываясь на прикрепленном изображении в вашем вопросе, я думаю, вы должны сделать что-то похожее с emg2 <- emg(MyEMGdata151517$X8, samplingrate=1000, units="mV", data.name="")
7 ответов
Программирование затруднено.
Если вы определяете строгие API, которые не раскрывают переменные, которые не должны быть открыты (мы любим называть это инкапсуляцией ) , вы помогаете пользователям своих API и тем самым упрощаете программирование. Это считается хорошей вещью.
Причины заключаются не в первую очередь в «безопасности», а в сохранении секретов в секрете, а в ясности, простоте и понятности.
В качестве бонуса гораздо проще заставить вещи работать. правильно, если вы знаете, что пользователь API не меняет "ваши" переменные за вашей спиной, конечно.
Это «безопасный» означает, что внутренняя работа класса скрыта от того, кто его использует.
Термин «безопасный» не используется, поскольку в слове «защита сервера» подразумевается факт что пользователю одного класса не нужно беспокоиться о том, как класс будет выполнять задачу, которую он хочет.
Возьмем ваш пример:
Открытие переменных класса позволит пользователю вашего класса узнать об их существовании, что вам не нужно, например: вы просто нажимаете кнопку, чтобы включить свет, вам не нужно сейчас, когда внутри есть медь или ватер, необходимый для выполнения этой задачи.
Java - это язык объектно-ориентированного программирования , и одной из ключевых концепций объектно-ориентированного программирования является инкапсуляция .
Идея за инкапсуляцией стоит «спрятать» детали реализации, такие как внутренние переменные, которые хранят состояние объекта и внутренние механизмы, такие как алгоритмы, и предоставляют только интерфейс, который другие объекты могут использовать для выполнения функций с объектом.
Используя эту концепцию, хотелось бы скрыть внутренние состояния, используя частные переменные, чтобы другие объекты не влияли напрямую на внутренние состояния. В Java обычно используются геттеры и сеттеры (например, getColor и setColor ) для работы с объектами.
Кроме того, инкапсуляция также может повысить надежность кода.
Например, ограничивая доступ к внутренним состояниям, можно было бы выполнить некоторые проверки работоспособности перед изменением объекта.
В качестве убедительного примера предположим, что существует объект Score , который должен иметь значение процентов между 0 и 100 . Предоставляя метод setPercent (int) , который проверяет, находится ли указанное значение в допустимом диапазоне, он предотвратит перевод объекта Score в недопустимое состояние.
Итак. , можно предотвратить попытки прямого управления внутренним состоянием, написав такой оператор, как score.percent = 150 ,
Здесь есть две проблемы ,
Во-первых, при объявлении переменных как защищенных или закрытых, они не станут частью вашего общедоступного API. Другие классы могут зависеть от вашего класса в будущем, и важно, чтобы вы могли изменять как можно больше, если хотите включить новые функции, повысить производительность и т. Д. Если все ваши значения являются общедоступными, то все ваши внутренние ценности и механизмы публичны. Их изменение может привести к поломке других классов, которые зависят от вашего.
Во-вторых, при открытии переменных он позволяет другим классам изменять ваши значения. Если они изменят ваши внутренние значения, это может сломать вашу программу и вызвать странное неожиданное поведение. Если вы создаете систему, которая полагается на точную производительность одного из ваших классов, а внутренние значения изменяются, вы больше не можете полагаться на эту систему. Создание подклассов усложняет задачу. Ваша система может полагаться на класс определенного типа для выполнения ожидаемых действий. Создавая подклассы, можно создать новый класс, который выглядит того же типа, но не выполняет ожидаемых действий.
Например, если у вас есть квадрат класса с защищенной функцией getArea (), вы ожидаете получить площадь квадрата. Однако можно создать новый класс, который расширяет квадрат, например, прямоугольник класса расширяет квадрат. Теперь прямоугольник может переопределять getArea (), но он по-прежнему имеет тип square, что может сломать что-то, что зависит от этой функции square.
просто представьте, если ваш объект имеет внутреннее свойство, которое не является закрытым (скрытым), и ваш код, обращающийся к этому свойству, выполняется в многопоточной среде, поэтому N потоков начнут обращаться к нему одновременно, 5 потоки хотели бы изменить это свойство, 4 на чтение. Невозможно убедиться, что все будет работать аккуратно, ни один поток не будет знать, какие данные он хранит в данный момент, и не изменил ли он успешно свойство этого объекта.
Вам нужно будет запрограммировать специальный фрагмент кода, который будет отвечать за синхронный доступ, и все же это не будет гарантировать, что ваш код будет работать правильно, поскольку вам все равно придется проверять остальные 680 классов в вашей программе, чтобы получить доступ к этому свойству, чтобы не доступ к нему напрямую.
Короче говоря, у вас огромная проблема, а отладка - это кошмар, так как вы не знаете, когда данные были изменены, какой поток это сделал, откуда это произошло и т. д.
Только один сценарий того, что происходит, если вы не инкапсулируете ...
Хорошая вещь ваш код работает на 1% быстрее, меньше нагрузка на стек, вы, вероятно, достигли незначительного прироста производительности, за что придется платить периодическими сбоями системы и небольшими шансами на успешную отладку.
Просто чтобы добавить к тому, что уже сказали другие: некоторые из этих функций можно также просто рассматривать как способ заявить о намерении. Если я делаю член закрытым , я делаю «невозможным» доступ к нему других (это возможно, но это не относится к делу), но, что более важно, я говорю пользователям, что это деталь реализации, на что они не должны полагаться.
Термин «безопасное кодирование» относится к созданию программного обеспечения, которое явно пытается избежать уязвимостей безопасности, будь то C, Java, Ruby, язык ассемблера или что-то еще. Возможно, наиболее важной частью этого после выбора безопасной языковой системы является соблюдение хороших практик программирования. Если программа неясна, то у вас мало шансов на то, что она заслуживает доверия.
Для Java есть два важных руководства:
- Руководство по безопасному кодированию для языка программирования Java, версия 2.0. Обновлено два года назад и нуждается в обновлении.
- Стандарт безопасного кодирования CERT Sun Microsystems для Java. Новая вики, поддерживаемая как CERT, так и Sun, может быть обновлена всем, что вы считаете важным. Это гораздо более широкий взгляд, чем руководящие принципы Sun. Например, рекомендации Sun на самом деле не касаются целочисленного переполнения, потому что все границы массива проверяются, но вики делают это, потому что это все еще может вызывать программные ошибки.
В Java есть два различных режима безопасного кодирования.
В одном вы имеют дело с кодом, который может не иметь всех привилегий, которые есть у вашего кода. Например, если вы пишете библиотеку или подписываете код, вам нужно это делать. Злонамеренный код не должен использовать ваши разрешения непреднамеренным образом. Это сложно!
Чаще всего вы имеете дело с программами, имеющими дело только с ненадежными данными. Например, веб-серверы (подумайте о внедрении XSS и SQL) и программы настольных приложений, работающие с ненадежными файлами (обычно проблема заключается в коде C, имеющем переполнение буфера - подлинный C ++ лучше). В некоторых ситуациях отказ в обслуживании (DoS) может стать серьезной проблемой.
Существует некоторое совпадение. Например, интерпретаторы работают с разрешениями кода интерпретатора и могут быть довольно «мощными».