5

Я видел некоторые дискуссии в StackOverflow об этой теме, но я не вижу что-то, что помогло мне понять следующий пункт:

я происхожу из C++ фона и в последнее время Я начал изучать Java. В C++, когда защищен , используется только подкласс, который может получить доступ к члену (аналог поля в Java).

В C++ есть также классы «друг», которые могут иметь доступ к частным/защищенным камерам класса, которые дают «дружбу». Это немного похоже на модификатор поля «package» в Java (модификатор поля по умолчанию), за исключением того, что в C++ дружба дает доступ ко всем закрытым членам, но в Java доступ из классов в одном пакете специфичен для поля класса,

Что я не могу понять, предполагая, что хочу предоставить доступ только к подклассам, это то, что я могу сделать на C++, объявив членов, защищенных в классе, который не «дает» дружеские отношения.

Но на Java я не знаю, как это сделать, поскольку с помощью «защищенного» модификатора поля - я также предоставляю доступ ко всем классам в пакете. Единственный способ, которым я нахожу это, - объявить защищенное поле и изолировать класс в своем пакете.

Отсюда я заключаю, что группировка классов в один пакет должна выполняться на основе «дружбы» между классами. Действительно ли это является ведущим фактором при группировании пакетов?

Еще одна вещь, которую я не понимаю, В Java, предполагая, что у меня есть два поля в классе A: b, c. Я хочу дать B доступ к b, но не к, и я хочу дать C доступ к c, но не b. и к «Миру» я хочу b, c, чтобы скрыть. Как это можно сделать? Я предполагаю, что B, C должны быть в том же пакете, что и A. , но путем объявления b, c с пакетом модификатором Я разрешаю B, C доступ как к b, так и к. Есть ли способ в Java, чтобы это сделать?

Надежда для некоторого объяснения этого вопроса

11

Лучший вопрос, если менее полезным для вас будет более узким и конкретным. Общий вопрос «все о конфиденциальности в Java и C++ и о том, как они отличаются», более чем слишком широк. Можете ли вы задать более конкретный вопрос о более конкретной проблеме? - Yakk 04 мар. 15 2015-03-04 16:38:58

• 4 ответа

Сортировка:

Активность

2

В C++, когда используется защита, только подкласс может получить доступ к элементу (аналог поля в Java).

Спецификаторы доступа также предназначены для функций-членов/методов, а не только для переменных-членов.

В C++ есть также «друг» классы, которые могут иметь доступ к частным/защищаемому mambers класса, что дает «дружбу». Этот немного похож на модификатор поля «package» в Java (по умолчанию модификатор поля), за исключением того, что в C++ дружба дает доступ ко всем частным членам, но в Java доступ из классов в том же пакете специфичен для поле класса.

Существует не только friend классы, но и функции.

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

То, что я не мог понять, если предположить, что я хочу, чтобы предоставить доступ только к подклассам, это то, что я могу сделать в C++, объявив пользователей защищенных в классе, который не «дает» дружба.

Но в Java, я не знаю, как я могу это сделать,

Ответ: Вы не можете.

так как с помощью «защищенного» модификатора поля - я также предоставляю доступ к всем классам в пакете.

Единственный способ, которым я нахожу, это объявить защищенное поле и иметь класс, изолированный в его пакете.

Технически, да. Но это создает другие проблемы. Ваш класс больше не сможет получить доступ к частным частям пакета своего предыдущего пакета. Допустим, ваш BaseClass был в com.example.one . Вы переместите его на com.example.two . Теперь он больше не сможет получить доступ к другим пакетам-частным классам com.example.one .

Действительно ли это является ведущим фактором при группировании пакетов?

Да, Java спроектирован таким образом. Вы можете попробовать бороться с правилами языка , но это проигрышная битва на любом языке программирования.

Еще одна вещь, которую я не понимаю, в Java, предполагая, что у меня есть два поля в классе A: b, c. Я хочу дать B доступ к b, но не к, и я хочу предоставить C доступ к c, но не b. и в «Мир» я хочу b, c , чтобы скрыть. Как это можно сделать?

Это не может быть сделано чистым способом (чистым я имею в виду: без каких-либо взломов, которые потребуют от вас проверки стека вызовов во время выполнения и исключения исключений).

Если вы обеспокоены этим сценарием, поскольку вы разрабатываете публичный API, низкотехнологичное решение, которое обычно прекрасно работает, - это создать один или несколько пакетов *.internal и четко документировать тот факт, что они не должны использоваться в клиентский код.

1

Это довольно куча вопросов вместе...

Но в Java, я не знаю, как я могу это сделать, так как в силу используя «защищенный» модификатор поля - я также предоставляю доступ ко всем классам в пакете.

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

Единственный способ, которым я нахожу это, - объявить защищенное поле и изолировать его в своем пакете.

Это технически правильно, хотя это будет мало использовать. Упаковка классов предназначена для группировки связанных классов, где «родственные» означает «классы, которые выполняют конкретное отношение», т. Е. Они принадлежат одному и тому же варианту использования, принадлежат к одному и тому же архитектурному уровню, находятся в одной и той же сущности, и т.д.

Отсюда я заключаю, что группировка классов в один пакет должна выполняться на основе «дружбы» между классами. Действительно ли это является ведущим фактором при группировании пакетов?

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

Для вашего A, B и C классов, например, с атрибутами:

Я думаю, B, C должно быть как в том же пакете, А. а объявляющего б, с модификатором упаковки I пусть В, C доступ как к b, так и к. Есть ли способ в Java сделать это?

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

0

Короткий ответ: нет никакого способа сделать это.

Если вы беспокоитесь о вторжении от клиентов инъекционного класса в пакете, чтобы получить несанкционированный доступ, вы можете перемещать чувствительный код в отдельном пакете, и сделать пакет запечатанного в банке вы доставить его в: http://docs.oracle.com/javase/tutorial/deployment/jar/sealman.html

1

Неявно предполагается, что все классы в пакете «знают» друг друга (потому что они были написаны одним и тем же лицом/компанией/организацией). Таким образом, они либо не получают доступа к полям protected , либо, если они это делают, они знают, как это сделать должным образом.

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

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

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

Конечно, вы можете придумать сложный протокол обмена токенами, чтобы сделать это поле доступным только для экземпляров B/C, но это было бы замечательным накладным расходами, а другой объект все равно может использовать отражение, чтобы получить доступ ко всем частным членов, если вы не отключите его с помощью политик безопасности, что обычно не так, но опять же, политики безопасности в конечном итоге решаются владельцем JVM.

Итак, в конечном итоге предпочтительный способ сделать то, что вы говорите на Java, - либо поместить их в один и тот же пакет, либо написать B и C как внутренние классы A, чтобы они могли напрямую обращаться к закрытым членам A и подвергать их их производным классам.

Public class A { public static abstract class B { protected Whatever getWhatever(A a) { return a.b; } protected void setWhatever(A a, Whatever value) { a.b = value; } } public static abstract class C { protected Whatever getWhatever(A a) { return a.c; } protected void setWhatever(A a, Whatever value) { a.c = value; } } private Whatever b; private Whatever c; }

еще раз, вы всегда считаете, что классы в одном пакете никогда не сделают ничего плохого.

Язык Java предоставляет множество модификаторов, разделенных на следующие категории:

• модификатор доступа
• Модификатор Non-доступа

Модификатор используется для определения класса, метода или переменной, как правило, на переднем крае заявления. Через следующий пример для иллюстрации:

Public class className { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String arguments) { // 方法体 }

Модификатор контроля доступа

Java, вы можете использовать символы контроля доступа для защиты доступа к классам, переменных, методов и конструкторов. Java поддерживает четыре различных прав доступа.

По умолчанию, также известный как значение по умолчанию, видимый в том же самом пакете, не используют какие - либо модификатор.

Частный, чтобы указан частный модификатор, видимый в пределах того же класса.

Есть, для того, чтобы указать общий модификатор, видимый для всех классов.

Защищенный, в защищенный модификатор определяет, что для всех классов и подклассов в пределах того же пакета видимой.

Модификатор доступа по умолчанию - не использовать какие-либо ключевые слова

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

Заявление в следующем примере, переменные и методы не могут использовать любой модификатор.

String version = "1.5.1"; boolean processOrder() { return true; }

Частный доступ модификатор -private

Частный модификатор доступа, является самым жестким уровень доступа, он объявлен как частных методов, переменных, и принадлежит к классу конструктора могут быть доступны только, а классы и интерфейсы не могут быть объявлены закрытыми.

Переменные, объявленные в качестве частного типа доступа могут быть доступны только за пределами класса через класс метода общественного геттерного.

Модификатор Частный доступ используется в основном для класса защиты деталей реализации и данных за классом.

Следующие классы используют частный модификатор доступа:

Public class Logger { private String format; public String getFormat() { return this.format; } public void setFormat(String format) { this.format = format; } }

Пример, переменный формат класса Logger является частной переменной, так что другие классы не могут непосредственно получить и установить значение переменной. Для того, чтобы иметь возможность работать с другой переменной класса определяет два открытых метода: GetFormat () (формат возвращаемого значения) и SetFormat (String) (настройка формата)

Открытый доступ модификатор -публичный

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

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

Следующие функции используют контроль доступа общественности:

Public static void main(String arguments) { // ... }

Метод главной Java программы () должен быть установлен в общественных местах, в противном случае, Java интерпретатор не сможет запустить класс.

Защищенные модификаторы доступа охраняемыми

Объявлена ​​как защищенные переменные, методы и конструкторы в том же пакете может быть любой другой тип доступа, и могут быть доступны в различных пакетах подклассов.

Защищенный модификатор доступа не могут быть изменены классы и интерфейсы, методы и переменные-члены могут быть объявлены как защищенные, но переменные и методы-члены интерфейсов не могут быть объявлены защищенными.

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

Следующий родительский класс использует защищенный модификатор доступа, подклассов переопределить метод openSpeaker () родительского класса.

Class AudioPlayer { protected boolean openSpeaker(Speaker sp) { // 实现细节 } } class StreamingAudioPlayer { boolean openSpeaker(Speaker sp) { // 实现细节 } }

Если метод openSpeaker () объявлен как частный, то в дополнение к классу AudioPlayer не может получить доступ к методу. Если openSpeaker () объявлена ​​как публичная, то все классы имеют возможность доступа к методу. Если мы хотим, чтобы сделать процесс видимым для подклассов класса, то метод объявлен как защищенный.

Контроль доступа и наследование

Обратите внимание на следующие методы унаследовали правила:

Родительский класс объявлен как публичные методы в подклассе также должен быть публичным.

Класс Родитель объявлен как защищенный метод в подклассе или объявлены как защищенные, либо объявлены публично. Вы не можете быть объявлены закрытыми.

Родительский класс объявлен как частный метод не может быть унаследован.

Модификатор Non-доступа

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

статический модификатор используется для создания методов класса и переменные класса.

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

Абстрактный модификатор используется для создания абстрактных классов и абстрактных методов.

Синхронное и летучие модификаторы, в основном для потоков программирования.

Статический модификатор

Статические переменные:

Статическая используется ключевое слово, чтобы объявить статические переменные, не зависящие от объекта, независимо от того, сколько объектов экземпляра класса, это только одна копия статической переменной. Статические переменные также известны как переменные класса. Локальные переменные не могут быть объявлены как статические переменные.

Статические методы:

Статический ключевое слово используется для объявления объект не зависит от статического метода. Статические методы не могут использовать не статический класс переменных. Статический метод, чтобы получить данные из списка параметров, а затем рассчитать данные.

Доступ к переменным класса и методы могут быть использованы непосредственно classname.variablename и classname.methodname доступа.

В следующем примере, статический модификатор используется для создания методов класса и переменные класса.

Public class InstanceCounter { private static int numInstances = 0; protected static int getCount() { return numInstances; } private static void addInstance() { numInstances++; } InstanceCounter() { InstanceCounter.addInstance(); } public static void main(String arguments) { System.out.println("Starting with " + InstanceCounter.getCount() + " instances"); for (int i = 0; i < 500; ++i){ new InstanceCounter(); } System.out.println("Created " + InstanceCounter.getCount() + " instances"); } }

Примеры приведенных выше результатов операции редактирования следующим образом:

Started with 0 instances Created 500 instances

Окончательный классификатор

Конечные переменные:

Окончательные переменные могут быть явно инициализированы и инициализируется только один раз. Справочник объявляется как конечные объекты не могут указывать на другой объект. Но конечная цель, где данные могут быть изменены. Это конечная ссылка на объект не может быть изменен, но значение которого может быть изменено.

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

Public class Test{ final int value = 10; // 下面是声明常量的实例 public static final int BOXWIDTH = 6; static final String TITLE = "Manager"; public void changeValue(){ value = 12; //将输出一个错误 } }

Окончательный метод

Методы конечный класс наследуются подклассами, но не может изменять подклассы.

Основная цель метода заключается в том, чтобы предотвратить окончательное заявление этого метода изменяется.

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

Public class Test{ public final void changeName(){ // 方法体 } }

Окончательная категория

Конечные классы не могут быть унаследованы, ни один класс может наследовать любой из характеристик конечного класса.

Public final class Test { // 类体 }

Абстрактный модификатор

Абстрактный класс:

Абстрактный класс не может быть использован для создания экземпляра объекта, единственной целью заявления является абстрактным классом для будущего расширения этого класса.

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

Абстрактный класс может содержать абстрактные методы и не абстрактные методы.

Abstract class Caravan{ private double price; private String model; private String year; public abstract void goFast(); //抽象方法 public abstract void changeColor(); }

Абстрактный метод

Ни один метод не является абстрактным реализация метода, конкретная реализация метода предоставляемых подклассов. Абстрактные методы не могут быть объявлены в качестве окончательного и строгим.

Любой подкласс наследует абстрактный класс должен реализовать все абстрактные методы родительского класса, если подкласс не является абстрактным классом.

Если класс содержит ряд абстрактных методов, класс должен быть объявлен как абстрактный класс. Абстрактный класс не может содержать абстрактные методы.

Абстрактный объявление метода заканчивается точкой с запятой, например: общественный абстрактный образец ();

Public abstract class SuperClass{ abstract void m(); //抽象方法 } class SubClass extends SuperClass{ //实现抽象方法 void m(){ ......... } }

Синхронное модификатор

Метод Синхронное ключевое слово, чтобы объявить то же время только один доступ нить. Синхронное модификатор может быть применен к четырем модификаторов доступа.

Public synchronized void showDetails(){ ....... }

Переходный модификатор

Сериализованная объект содержит модифицированные переходными переменными экземпляра виртуальной машины Java (JVM), чтобы пропустить эту конкретную переменную.

Модификатор включен в определение переменных заявления для предварительной обработки классов типов данных и переменных.

Public transient int limit = 55; // will not persist public int b; // will persist

Летучие Модификаторы

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

Public class MyRunnable implements Runnable { private volatile boolean active; public void run() { active = true; while (active) // 第一行 { // 代码 } } public void stop() { active = false; // 第二行 } }

При нормальных обстоятельствах, поток вызывает метод () Run (в Runnable открытом потоке) в другом потоке вызовов остановить () метод. Если активное значение в первой строке буфера используется, во втором ряду , когда активный цикл ложна не останавливается.

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

Которые Вы добавляете при инициализации для изменения значений. Язык Java имеет широкий спектр модификаторов, основные из них:

• модификаторы доступа;
• модификаторы класса, метода, переменной и потока, используемые не для доступа.

Чтобы использовать модификатор в Java, нужно включить его ключевое слово в определение класса, метода или переменной. Модификатор должен быть впереди остальной части оператора, как показано в следующих примерах:

Public class className { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String arguments) { // тело метода }

Модификаторы доступа

Java предоставляет ряд модификаторов доступа, чтобы задать уровни доступа для классов, переменных, методов и конструкторов. Существует четыре доступа:

• Видимый в пакете (стоит по умолчанию и модификатор не требуются).
• Видимый только для класса (private).
• Видимый для всех (public).
• Видимый для пакета и всех подклассов (protected).

Модификатор доступа по умолчанию - без ключевого слова

Модификатор доступа по умолчанию - означает, что мы явно не объявляем модификатор доступа в Java для класса, поля, метода и т.д.

Переменная или метод, объявленные без модификатора контроля доступа доступны для любого другого класса в том же пакете. Поля в интерфейсе неявно являются public, static, final, а методы в интерфейсе по умолчанию являются public.

Пример

Переменные и методы могут быть объявлены в Java без каких-либо модификаторов, как показано в следующем примере:

String version = "1.5.1"; boolean processOrder() { return true; }

Модификатор доступа private

Модификатор private - методы, переменные и конструкторы, которые объявлены как private в Java могут быть доступны только в пределах самого объявленного класса.

Модификатор доступа private является наиболее ограничивающим уровенем доступа. Класс и интерфейсы не могут быть private.

Переменные, объявленные как private, могут быть доступны вне класса, если получающие их открытые (public) методы присутствуют в классе (ниже смотрите пример и пояснения).

Использование модификатора private в Java является основным способом, чтобы скрыть данные.

Пример

Следующий класс использует контроль доступа private:

Public class Logger { private String format; public String getFormat() { return this.format; } public void setFormat(String format) { this.format = format; } }

Здесь переменная format класса Logger является private, так что нет никакого способа для других классов, чтобы получить и установить её значение напрямую.

Таким образом, чтобы эта переменная была доступна для всего, мы определили два открытых (public) метода: getFormat() , который возвращает значение format , и setFormat(String) , который устанавливает её значение.

Модификатор доступа public

Модификатор public - класс, метод, конструктор, интерфейс и т.д. объявленные как public могут быть доступны из любого другого класса. Поэтому поля, методы, блоки, объявленные внутри public класса могут быть доступны из любого класса, принадлежащего к "вселенной" Java.

Тем не менее, если к public классу в другом пакете мы пытаемся получить доступ, то public класс приходится импортировать.

Благодаря наследованию классов, в Java все публичные (public) методы и переменные класса наследуются его подклассами.

Пример

Следующая функция использует контроль доступа public:

Public static void main(String arguments) { // ... }

Метод main() должен быть публичным (public). В противном случае, он не может быть вызван с помощью java-интерпретатора, чтобы запустить класс.

Модификатор доступа protected

Модификатор protected - переменные, методы и конструкторы, которые объявляются как protected в суперклассе, могут быть доступны только для подклассов в другом пакете или для любого класса в пакете класса protected.

Модификатор доступа protected в Java не может быть применен к классу и интерфейсам. Методы и поля могут быть объявлены как protected, однако методы и поля в интерфейсе не могут быть объявлены как protected.

Доступ protected дает подклассу возможность использовать вспомогательный метод или переменную, предотвращая неродственный класс от попыток использовать их.

Пример

Следующий родительский класс использует контроля доступа protected, чтобы его дочерний класс переопределил метод openSpeaker() :

Class AudioPlayer { protected boolean openSpeaker(Speaker sp) { // детали реализации } } class StreamingAudioPlayer { boolean openSpeaker(Speaker sp) { // детали реализации } }

При этом, если мы определим метод openSpeaker() как protected, то он не будет доступен из любого другого класса, кроме AudioPlayer. Если мы определим его как public, то он станет доступным всем. Но наше намерение состоит в том, чтобы раскрыть этот метод только подклассу, вот почему мы использовали модификатор protected.

Правила контроля доступа и наследования

Следующие правила в Java применяются для унаследованных методов:

• Методы, объявленные как public в суперклассе, также должны быть public во всех подклассах.
• Методы, объявленные как protected в суперклассе, должны либо быть либо protected, либо public в подклассах; они не могут быть private.
• Методы, объявленные как private для всех не наследуются, так что нет никакого правила для них.

Модификаторы класса, метода, переменной и потока, используемые не для доступа

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

• модификатор static применяется для создания методов и переменных класса;
• модификатор final используется для завершения реализации классов, методов и переменных;
• модификатор abstract необходим для создания абстрактных классов и методов;
• модификаторы synchronized и volatile используются в Java для потоков.

Модификатор static

Модификатор static - применяется для создания методов и переменных класса.

Переменные static

Ключевое слово static используется для создания переменных, которые будут существовать независимо от каких-либо экземпляров, созданных для класса. Только одна копия переменной static в Java существует вне зависимости от количества экземпляров класса.

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

Методы static

Ключевое слово static используется для создания методов, которые будут существовать независимо от каких-либо экземпляров, созданных для класса.

В Java статические методы или методы static не используют какие-либо переменные экземпляра любого объекта класса, они определены. Методы static принимают все данные из параметров и что-то из этих параметров вычисляется без ссылки на переменные.

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

Пример

Модификатор static в Java используется для создания методов классов и переменных, как показано в следующем примере:

Public class InstanceCounter { private static int numInstances = 0; protected static int getCount() { return numInstances; } private static void addInstance() { numInstances++; } InstanceCounter() { InstanceCounter.addInstance(); } public static void main(String arguments) { System.out.println("Начиная с " + InstanceCounter.getCount() + " экземпляра"); for (int i = 0; i

Будет получен следующий результат:

Начиная с 0 экземпляра Создано 500 экземпляров

Модификатор final

Модификатор final - используется для завершения реализации классов, методов и переменных.

Переменные final

Переменная final может быть инициализирована только один раз. Ссылочная переменная, объявленная как final, никогда не может быть назначен для обозначения другого объекта.

Однако данные внутри объекта могут быть изменены. Таким образом, состояние объекта может быть изменено, но не ссылки.

С переменными в Java модификатор final часто используется со static, чтобы сделать константой переменную класса.

Пример

Методы final

Метод final не может быть переопределен любым подклассом. Как упоминалось ранее, в Java модификатор final предотвращает метод от изменений в подклассе.

Главным намерение сделать метод final будет то, что содержание метода не должно быть изменено стороне.

Пример

Объявление метода, использующего модификатор final в объявление класса, показано в следующем примере:

Public class Test{ public final void changeName(){ // тело метода } }

Класс final

Основная цель в Java использования класса объявленного в качестве final заключается в предотвращении класс от быть подклассом. Если класс помечается как final, то ни один класс не может наследовать любую функцию из класса final.

Пример

Модификатор abstract

Модификатор abstract - используется для создания абстрактных классов и методов.

Класс abstract

Класс abstract не может создать экземпляр. Если класс объявлен как abstract, то единственная цель для него быть расширенным.

Класс не может быть одновременно abstract и final, так как класс final не может быть расширенным. Если класс содержит абстрактные методы, то он должен быть объявлен как abstract. В противном случае будет сгенерирована ошибка компиляции.

Класс abstract может содержать как абстрактные методы, а также и обычные.

Пример

Метод abstract

Метод abstract является методом, объявленным с любой реализацией. Тело метода (реализация) обеспечивается подклассом. Методы abstract никогда не могут быть final или strict.

Любой класс, который расширяет абстрактный класс должен реализовать все абстрактные методы суперкласса, если подкласс не является абстрактным классом.

Если класс в Java содержит один или несколько абстрактных методов, то класс должен быть объявлен как abstract. Абстрактный класс не обязан содержать абстрактные методы.

Абстрактный метод заканчивается точкой с запятой. Пример: public abstract sample();

Пример

Модификатор synchronized

Модификатор synchronized

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

Пример

Модификатор transient

Переменная экземпляра отмеченная как transient указывает виртуальной машине Java (JVM), чтобы пропустить определённую переменную при сериализации объекта, содержащего её.

Этот модификатор включён в оператор, что создает переменную, предшествующего класса или типа данных переменной.

Пример

Модификатор volatile

Модификатор volatile - используются в Java для потоков.

В Java модификатор volatile используется, чтобы позволить знать JVM, что поток доступа к переменной всегда должен объединять свою собственную копию переменной с главной копией в памяти.

Доступ к переменной volatile синхронизирует все кэшированные скопированные переменные в оперативной памяти. Volatile может быть применен только к переменным экземпляра, которые имеют тип объект или private. Ссылка на объект volatile может быть null.

Пример

Как правило, run() вызывается в одном потоке (впервые начинаете использовать Runnable в Java), а stop() вызывается из другого потока. Если в линии 1 используется кэшированное значение active, то цикл не может остановиться, пока Вы не установите active false в линии 2.

В следующем уроке обсудим основные операторы, используемые в языке Java. Этот раздел даст Вам обзор того, как можно использовать их во время разработки приложения.

Привет! В сегодняшней лекции мы познакомимся с понятием «модификаторы доступа » и рассмотрим примеры работы с ними. Хотя слово «познакомимся» будет не совсем правильным: с большинством из них ты уже знаком по предыдущим лекциям. На всякий случай освежим в памяти главное. Модификаторы доступа - это чаще всего ключевые слова, которые регулируют уровень доступа к разным частям твоего кода. Почему «чаще всего»? Потому что один из них установлен по умолчанию и не обозначается ключевым словом:) Всего в Java есть четыре модификатора доступа. Перечислим их в порядке от самых строгих до самых «мягких»:

• private;
• protected;
• default (package visible);
• public.

Модификатор private

Модификатор protected

• в пределах всех классов, находящихся в том же пакете, что и наш;
• в пределах всех классов-наследников нашего класса.

Модификатор package visible

Модификатор public

Последнее обновление: 03.10.2019

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

В C# применяются следующие модификаторы доступа:

public : публичный, общедоступный класс или член класса. Такой член класса доступен из любого места в коде, а также из других программ и сборок.

private : закрытый класс или член класса. Представляет полную противоположность модификатору public. Такой закрытый класс или член класса доступен только из кода в том же классе или контексте.

protected : такой член класса доступен из любого места в текущем классе или в производных классах. При этом производные классы могут располагаться в других сборках.

internal : класс и члены класса с подобным модификатором доступны из любого места кода в той же сборке, однако он недоступен для других программ и сборок (как в случае с модификатором public).

protected internal : совмещает функционал двух модификаторов. Классы и члены класса с таким модификатором доступны из текущей сборки и из производных классов.

private protected : такой член класса доступен из любого места в текущем классе или в производных классах, которые определены в той же сборке.

Мы можем явно задать модификатор доступа, например:

Private protected class State { internal int a; protected void Print() { Console.WriteLine($"a = {a}"); } }

Либо можем не указывать:

Class State { int a; void Print() { Console.WriteLine($"a = {a}"); } }

Если для полей и методов не определен модификатор доступа, то по умолчанию для них применяется модификатор private .

Классы и структуры, объявленные без модификатора, по умолчанию имеют доступ internal .

Все классы и структуры, определенные напрямую в пространствах имен и не являющиеся вложенными в другие классы, могут иметь только модификаторы public или internal.

Посмотрим на примере и создадим следующий класс State:

Public class State { // все равно, что private int defaultVar; int defaultVar; // поле доступно только из текущего класса private int privateVar; // доступно из текущего класса и производных классов, которые определены в этом же проекте protected private int protectedPrivateVar; // доступно из текущего класса и производных классов protected int protectedVar; // доступно в любом месте текущего проекта internal int internalVar; // доступно в любом месте текущего проекта и из классов-наследников в других проектах protected internal int protectedInternalVar; // доступно в любом месте программы, а также для других программ и сборок public int publicVar; // по умолчанию имеет модификатор private void defaultMethod() => Console.WriteLine($"defaultVar = {defaultVar}"); // метод доступен только из текущего класса private void privateMethod() => Console.WriteLine($"privateVar = {privateVar}"); // доступен из текущего класса и производных классов, которые определены в этом же проекте protected private void protectedPrivateMethod() => Console.WriteLine($"protectedPrivateVar = {protectedPrivateVar}"); // доступен из текущего класса и производных классов protected void protectedMethod()=> Console.WriteLine($"protectedVar = {protectedVar}"); // доступен в любом месте текущего проекта internal void internalMethod() => Console.WriteLine($"internalVar = {internalVar}"); // доступен в любом месте текущего проекта и из классов-наследников в других проектах protected internal void protectedInternalMethod() => Console.WriteLine($"protectedInternalVar = {protectedInternalVar}"); // доступен в любом месте программы, а также для других программ и сборок public void publicMethod() => Console.WriteLine($"publicVar = {publicVar}"); }

Так как класс State объявлен с модификатором public , он будет доступен из любого места программы, а также из других программ и сборок. Класс State имеет пять полей для каждого уровня доступа. Плюс одна переменная без модификатора, которая является закрытой (private) по умолчанию.

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

Теперь посмотрим, как мы сможем использовать переменные нашего класса в программе (то есть в методе Main класса Program), если классы State и Program находятся в одном проекте :

Class Program { static void Main(string args) { State state1 = new State(); // присвоить значение переменной defaultVar у нас не получится, // так как она имеет модификатор private и класс Program ее не видит // И данную строку среда подчеркнет как неправильную state1.defaultVar = 5; //Ошибка, получить доступ нельзя // то же самое относится и к переменной privateVar state1.privateVar = 5; // Ошибка, получить доступ нельзя // присвоить значение переменной protectedPrivateVar не получится, // так как класс Program не является классом-наследником класса State state1.protectedPrivateVar =5; // Ошибка, получить доступ нельзя // присвоить значение переменной protectedVar тоже не получится, // так как класс Program не является классом-наследником класса State state1.protectedVar = 5; // Ошибка, получить доступ нельзя // переменная internalVar с модификатором internal доступна из любого места текущего проекта // поэтому спокойно присваиваем ей значение state1.internalVar = 5; // переменная protectedInternalVar так же доступна из любого места текущего проекта state1.protectedInternalVar = 5; // переменная publicVar общедоступна state1.publicVar = 5; } }

Таким образом, мы смогли установить только переменные internalVar, protectedInternalVar и publicVar, так как их модификаторы позволяют использовать в данном контексте.

Аналогично дело обстоит и с методами:

Class Program { static void Main(string args) { State state1 = new State(); state1.defaultMethod(); //Ошибка, получить доступ нельзя state1.privateMethod(); // Ошибка, получить доступ нельзя state1.protectedPrivateMethod(); // Ошибка, получить доступ нельзя state1.protectedMethod(); // Ошибка, получить доступ нельзя state1.internalMethod(); // норм state1.protectedInternalMethod(); // норм state1.publicMethod(); // норм } }

Здесь нам оказались доступны только три метода: internalMethod, protectedInternalMethod, publicMethod, которые имееют соответственно модификаторы internal, protected internal, public.

Благодаря такой системе модификаторов доступа можно скрывать некоторые моменты реализации класса от других частей программы.

Несмотря на то, что модификаторы public и internal похожи по своему действию, но они имеют большое отличие. Классы и члены класса с модификатором public также будут доступны и другим программам, если данных класс поместить в динамическую библиотеку dll и потом ее использовать в этих программах.