Какой модификатор доступа можно применить для пакета. Модификаторы доступа. Защищенные модификаторы доступа охраняемыми

Для начала разберемся с модификаторами доступа. Их всего четыре:

• private члены класса доступны только внутри класса
• package-private или default (по умолчанию) члены класса видны внутри пакета
• protected члены класса доступны внутри пакета и в классах-наследниках
• public члены класса доступны всем

Во время наследования возможно изменение модификаторов доступа в сторону БОЛЬШЕЙ видимости.

Модификатор доступа у конструкторов, методов и полей может быть любой, а вот с классами и их блоками не так все просто. Класс может быть только либо public, либо default, причем в одном файле может находиться только один public класс. У блока может быть только один модификатор – default.

Модификаторы static, abstract и final

Static

• Применяется к внутренним классам, методам, переменным и логическим блокам
• Статические переменные инициализируются во время загрузки класса
• Статические переменные едины для всех объектов класса (одинаковая ссылка)
• Статические методы имеют доступ только к статическим переменным
• К статическим методам и переменным можно обращаться через имя класса
• Статические блоки выполняются во время загрузки класса
• Не static методы не могут быть переопределены как static
• Локальные переменные не могут быть объявлены как static
• Абстрактные методы не могут быть static
• Static поля не сериализуются (только при реализации интерфейса Serializable)
• Только static переменные класса могут быть переданы в конструктор с параметрами, вызывающийся через слово super(//параметр//) или this(//параметр//)

Abstract

• Применяется только для методов и классов
• У абстрактных методов нет тела метода
• Является противоположностью final: final класс не может наследоваться, abstract класс обязан наследоваться
• Класс должен быть объявлен как abstract если:

1. он содержит хотя бы один абстрактный метод
2. он не предоставляет реализацию наследуемых абстрактных методов
3. он не предоставляет реализацию методов интерфейса, реализацию которого он объявил
4. необходимо запретить создание экземпляров класса

Final

• Поля не могут быть изменены, методы переопределены
• Классы нельзя наследовать
• Этот модификатор применяется только к классам, методам и переменным (также и к локальным переменным)
• Аргументы методов, обозначенные как final, предназначены только для чтения, при попытке изменения будет ошибка компиляции
• Переменные final не инициализируются по умолчанию, им необходимо явно присвоить значение при объявлении или в конструкторе, иначе – ошибка компиляции
• Если final переменная содержит ссылку на объект, объект может быть изменен, но переменная всегда будет ссылаться на тот же самый объект
• Также это справедливо и для массивов, потому что массивы являются объектами, – массив может быть изменен, а переменная всегда будет ссылаться на тот же самый массив
• Если класс объявлен final и abstract (взаимоисключающие понятия), произойдет ошибка компиляции
• Так как final класс не может наследоваться, его методы никогда не могут быть переопределены

Конструктор не может быть static, abstract или final

Модификаторы strictfp, transient, volatile, synchronized, native

Strictfp

• Применяется для методов и классов
• Обеспечивает выполнение операций над числами типа float и double (с плавающей запятой) по стандарту IEEE 754

Transient

• Применяется только для переменных уровня класса (локальные переменные не могут быть объявлены как transient)
• Transientпеременные могут не быть final или static.
• Transientпеременные не сериализуются

Volatile

• Используется только с переменными
• Может использоваться со static переменными
• Не используется с final переменными - Значение переменной, объявленной как volatile, измененное одним потоком, асинхронно меняется и для других потоков
• Применяется в многопоточных приложениях

Synchronized

• Применяется только к методам или частям методов
• Используется для контроля доступа к важным частями кода в многопоточных программах

Native

• Используется только для методов
• Обозначает, что метод написан на другом языке программирования
• Классы в Java используют много native методов для повышения производительности и доступа к аппаратным средствам
• Можно предавать/возвращать Java объекты из native методов
• Сигнатура метода должна заканчиваться “;”, фигурные скобки вызовут ошибку компиляции

Особенности в интерфейсах

• Методы всегда public и abstract, даже если это не объявлено
• Методы не могут быть static, final, strictfp, native, private, protected
• Переменные только public static final, даже если это не объявлено
• Переменные не могут быть strictfp, native, private, protected
• Может только наследовать (extends) другой интерфейс, но не реализовывать интерфейс или класс (implements).

Соберем все модификаторы вместе:

	Класс	Внутренний класс	Переменная	Метод	Конструктор	Логический блок
public	Да	Да	Да	Да	Да	Нет
protected	Нет	Да (кроме локальных и анонимных классов)	Да	Да	Да	Нет
default	Да	Да		Да	Да	Да
private	Нет	Да (кроме локальных и анонимных классов)	Да	Да	Да	Нет
final	Да		Да (и для локальной переменной)	Да	Нет	Нет
abstract	Да	Да (кроме анонимных классов)	Нет	Да	Нет	Нет
static	Нет	Да (кроме локальных и анонимных классов)	Да	Да	Нет	Да
native	Нет	Нет	Нет	Да	Нет	Нет
transient	Нет	Нет	Да	Нет	Нет	Нет
synchronized	Нет	Нет	Нет	Да	Нет	Да (только как часть метода)
volatile	Нет	Нет	Да	Нет	Нет	Нет
strictfp	Да	Да	Нет	Да	Нет	Нет

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

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

• private (закрытый)
• public (открытый)
• protected (защищённый)
• доступ по умолчанию, когда никакой модификатор не присутствует

Примеры объявление модификаторов (он всегда должен быть первым):

Public int i; private double j, k; private int createMethod(int a) {...}; public class Cat{}

Как видите, модификатор применим к переменной, методу, классу.

public

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

Предположим, что класс объявлен как public , и в нём имеются два метода. Один private , второй - public . У вас будет доступ к классу и ко второму методу, но не к первому, несмотря на то, что сам класс открыт.

private

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

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

protected

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

Если при создании нового пакета используется наследование от класса, находящемся в другом пакете, новый класс получает доступ только к открытым (public) членам из исходного пакета. Иногда создателю базового класса необходимо предоставить доступ к конкретному методу производным классам, но закрыть его от всех остальных. В этих случаях используется ключевое слово protected . Спецификатор protected также предоставляет доступ в пределах пакета, т.е. члены с этим спецификатором доступны для других классов из того же пакета.

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

Рассмотрим вымышленный класс SillySensor

Public class SillySensor { private int sensorData; public SillySensor() { sensorData = 0; } private void calibrate(int iSeed) { // код для калибровки } protected void seedCalibration(int iSeed) { calibrate(iSeed); } public int getSensorData() { // Check sensor here return sensorData; } }

Класс объявлен как public и доступен в других классах. У класса есть переменная sensorData , которая доступна только в своём классе (private). Конструктор доступен в других классах (public ). Метод calibrate() работает только внутри класса (private ). Метод seedCalibration() доступен в своем классе или в подклассе (protected ). Метод getSensorData() доступен в других классах (public ).

Язык 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 открытом потоке) в другом потоке вызовов остановить () метод. Если активное значение в первой строке буфера используется, во втором ряду , когда активный цикл ложна не останавливается.

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

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; }

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

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

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

В Java используются следующие модификаторы доступа:

public : публичный, общедоступный класс или член класса. Поля и методы, объявленные с модификатором public, видны другим классам из текущего пакета и из внешних пакетов.

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

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

Модификатор по умолчанию . Отсутствие модификатора у поля или метода класса предполагает применение к нему модификатора по умолчанию. Такие поля или методы видны всем классам в текущем пакете.

Рассмотрим модификаторы доступа на примере следующей программы:

Public class Program{ public static void main(String args) { Person kate = new Person("Kate", 32, "Baker Street", "+12334567"); kate.displayName(); // норм, метод public kate.displayAge(); // норм, метод имеет модификатор по умолчанию kate.displayPhone(); // норм, метод protected //kate.displayAddress(); // ! Ошибка, метод private System.out.println(kate.name); // норм, модификатор по умолчанию System.out.println(kate.address); // норм, модификатор public System.out.println(kate.age); // норм, модификатор protected //System.out.println(kate.phone); // ! Ошибка, модификатор private } } class Person{ String name; protected int age; public String address; private String phone; public Person(String name, int age, String address, String phone){ this.name = name; this.age = age; this.address = address; this.phone = phone; } public void displayName(){ System.out.printf("Name: %s \n", name); } void displayAge(){ System.out.printf("Age: %d \n", age); } private void displayAddress(){ System.out.printf("Address: %s \n", address); } protected void displayPhone(){ System.out.printf("Phone: %s \n", phone); }}

В данном случае оба класса расположены в одном пакете - пакете по умолчанию, поэтому в классе Program мы можем использовать все методы и переменные класса Person, которые имеют модификатор по умлчанию, public и protected. А поля и методы с модификатором private в классе Program не будут доступны.

Если бы класс Program располагался бы в другом пакете, то ему были бы доступны только поля и методы с модификатором public.

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

Инкапсуляция

Казалось бы, почему бы не объявить все переменные и методы с модификатором public , чтобы они были доступны в любой точке программы вне зависимости от пакета или класса? Возьмем, например, поле age, которое представляет возраст. Если другой класс имеет прямой доступ к этому полю, то есть вероятность, что в процессе работы программы ему будет передано некорректное значение, например, отрицательное число. Подобное изменение данных не является желательным. Либо же мы хотим, чтобы некоторые данные были достуны напрямую, чтобы их можно было вывести на консоль или просто узнать их значение. В этой связи рекомендуется как можно больше ограничивать доступ к данным, чтобы защитить их от нежелательного доступа извне (как для получения значения, так и для его изменения). Использование различных модификаторов гарантирует, что данные не будут искажены или изменены не надлежащим образом. Подобное сокрытие данных внутри некоторой области видимости называется инкапсуляцией .

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

Public class Program{ public static void main(String args) { Person kate = new Person("Kate", 30); System.out.println(kate.getAge()); // 30 kate.setAge(33); System.out.println(kate.getAge()); // 33 kate.setAge(123450); System.out.println(kate.getAge()); // 33 } } class Person{ private String name; private int age; public Person(String name, int age){ this.name = name; this.age = age; } public String getName(){ return this.name; } public void setName(String name){ this.name = name; } public int getAge(){ return this.age; } public void setAge(int age){ if(age > 0 && age < 110) this.age = age; } }

И затем вместо непосредственной работы с полями name и age в классе Person мы будем работать с методами, которые устанавливает и возвращают значения этих полей. Методы setName, setAge и наподобие еще называют мьютейтерами (mutator), так как они изменяют значения поля. А методы getName, getAge и наподобие называют аксессерами (accessor), так как с их помощью мы получаем значение поля.

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