Protected методы java. Модификаторы доступа и инкапсуляция

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

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

Класс Modifier
Класс Modifier кодирует все модификаторы,
используемые в объявлениях типа, в виде
констант:
ABSTRACT, FINAL, INTERFACE, NATIVE,
PRIVATE, PROTECTED, PUBLIC, STATIC,
STRICT, SYBCHRONIZED, TRANSIDENT,
VOLATILE.
Каждой из констант отвечает метод запрос вида
isMod(int modifier) (тут Mod одно из выше
приведенных имен, например, isPublic),
который возвращает true, если модификатор
mod присутствует в объявлении типа.

Рассмотрим пример. Пусть имеется
объявление поля
public static final int s=10;
тогда значение возвращаемое методом
getModifiers соответствующего объекта
класса Field будет иметь вид
Modifier.PUBLIC | Modifier.STATIC |
Modifier.FINAL
Модификатор strictfp представляется
константой STRICT.
Методы- запросы можно использовать в
следующей форме

Modifier.isPrivate(field.getModifiers());
это эквивалентно следующему условию
(field.getModifiers()&Modifier.PRIVATE)!=0
Класс Field
В составе класса Field реализованы методы,
позволяющие запрашивать информацию о
типе поля, а также считывать и задавать его
значение.
Рассмотрим некоторые методы класса Field
1. getType() – возвращает объект класса
Class, отвечающий типу текущего поля.
Например, для поля типа int, получим
int.class.

2. Методы set и get – позволяют считывать
текущее значение поля, а также задавать новое.
Рассмотрим пример:
public static void printField(Object o,
String name) throws
NoSuchFieldException,
IllegalAccessException{
Field field = o.getClass().getField(name);
Short value = (Short) field.get(o);
System.out.println(value);
}
Т.е. метод get возвращает значение, на которое
ссылается соответствующее поле или объект
класса –оболочки.
Пример использования метода set имеет вид:

public static void setField(Object o, String name,
short nv) throws
NoSuchFieldException,
IllegalAccessException{
Field field = o.getClass().getField(name) ;
field.set(o,new Short(nv));
}
Для сохранения nv в поле данного объекта
необходимо использовать классы оболочки.
Существуют также методы имеющие вид
getPrimitiveType (например, getInt) и
setPrimitiveType. Эти методы можно
использовать для изменения полей в классе,
имеющих примитивный тип. Например,
field.setShort(o,nv);

Класс Method
Средства класса Method - позволяют получать
полную информацию, касающуюся
объявлений методов определенного класса,
и при необходимости вызывать эти методы в
контексте заданных объектов.
Рассмотрим методы класса Method.
1. public Class getReturnType() - возвращает
объект Class, соответствующий типу
значения, возвращаемого текущим методом.
Если вместо типа возвращаемого значения в
объявлении метода указано служебное
слово void, рассматриваемый метод вернет
объект void.class.

2. public Class getParameterTypes() - возвращает

параметров, которые заданы в объявлении
текущего метода. Объекты заносятся в массив в
том порядке, в каком параметры перечислены в
объявлении метода. Если метод не имеет
параметров, возвращается пустой массив.
3. public Class getExceptionTypes() - возвращает
массив объектов Class, соответствующих типам
исключений, которые заданы в предложении
throws объявления текущего метода. Объекты
заносятся в массив в том порядке, в каком
наименования типов исключений перечислены в
объявлении метода.

4. public Object invoke(Object onThis, Object args)
throws IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
Вызывает метод, определяемый текущим объектом
Method, в контексте объекта onThis с заданием
значений аргументов, передаваемых массивом args.
Для нестатических методов выбор реализации
осуществляется на основании фактического типа
объекта, определяемого параметром onThis. Для
статических методов onThis не принимается во
внимание и может быть равен null.
Длина массива args должна совпадать с числом
параметров в объявлении метода, а типы объектовэлементов массива должны допускать присваивание
соответствующим типам параметров метода - в
противном случае будет выброшено исключение
IIlegalArgumentException.

10.

Если в составе объекта, определяемого
параметром onThis, нет типа, членом
которого является текущий метод,
выбрасывается исключение
IllegalArgumentException.
Если значение onThis равно null и метод не
статический, генерируется исключение типа
NullPointerException.
Если выполнение вызываемого метода
завершается аварийно, выбрасывается
исключение типа InvocationTargetException.

11.

Рассмотрим пример. Вызовем средствами
рефлексии метод return str.indexOf(".", 8)
тогда имеем
try {
Сlass strClass = str.getClass();
Method indexM = strClass.getMethod("indexOf",
new Class { string.class, int.class });
Object result = indexM.invoke(str, new object {
".", new lnteger(8)});
return ((Integer) result).intValue();
}
catch (NoSuchMethodException e) { …….. }
catch (invocationTargetException e) {…….. }
catch (illegalAccessException e) {……}

12.

Класс Constructor
Для создания новых экземпляров (объектов)
типа может быть использован метод
newlnstance объекта Class,
соответствующего этому типу.
Метод вызывает конструктор без аргументов,
принадлежащий типу, и возвращает ссылку
на вновь созданный объект класса Object,
который должен быть явно преобразован к
требуемому типу.
Рассмотрим пример.

13.

static double testData = { 0.3,1.3e-2, 7.9, 3.17 };

try {
for(int arg = 0; arg < args.length; arg++){
String name = args;
Class classFor = Class.forName(name);
SortDouble sorter =
(SortDouble)classFor.newInstance();
SortMetrics metrics = sorter.sort(testData);
System.out.println(name + ": " + metrics);
for(int i =0; i < testData.length; i++)
System.out.println(“ " + testData[i]); } }
catch(Exception e) { System.err.println(e); } }

14.

Метод newlnstance при некорректном
применении способен выбрасывать большое
число объектов исключений различных
типов.
InstantiationException-если класс, объект
которого должен быть создан, не обладает
конструктором без аргументов, либо
определен как абстрактный, либо в
действительности является интерфейсом,
либо выполнение процедуры создания
объекта прерывается по каким-либо иным
причинам.
IllegalAccessException - если класс либо его
конструктор без аргументов недоступны.

15.

SecurityException - если действующая политика
безопасности запрещает создание новых объектов
ExceptionInInitializerError –выбрасывается при
инициализации класса.
В классе Constructor определены и другие методы.
public Сlass getParameterTypes()

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

16.

public Object newlnstance(Object args)
throws InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException
Использует конструктор, представляемый текущим
объектом Constructor, для создания и инициализации
нового экземпляра класса, в котором конструктор
объявлен, с передачей заданных аргументов.
Возвращает ссылку на вновь созданный и
инициализированный объект. Длина массива args
должна совпадать с числом параметров в
объявлении конструктора, а типы объектовэлементов массива должны допускать присваивание
соответствующим типам параметров конструктора -
в противном случае будет выброшено исключение
IllegalArgumentException.

17.

Рассмотрим пример:
class Myclass {
private int a;
public Myclass(int k){a=k;}
public int func(int a,int b){return a+b;}
}
public class Main{
public static void main(String args){
try{
String name="Myclass";
Class mycl=Class.forName(name);
Class d={int.class};
Constructor c=mycl.getConstructor(d);
Myclass ob=(Myclass)c.newInstance(new Object{
new Integer(10)});
System.out.println(ob.func(3,5)); }
catch(Exception e){};
}}

18.

Класс AccessibleObject
Классы Field, Constructor и Method являются
производными от класса AccessibleObject,
который дает возможность разрешать или
запрещать проверку признаков доступа уровня
языка, таких как public и private.
Класс AccessibleObject имеет методы
1. public void setAccessible(boolean flag)
Устанавливает флаг доступа к объекту в
соответствии со значением аргумента: true
означает, что объект больше не подчиняется
правилам доступа, устанавливаемым на уровне
языка (и будет всегда доступен), a false
вынуждает объект поддерживать заданный
уровень доступа.
Если полномочий по изменению флага доступа
недостаточно, выбрасывается исключение типа
SecurityException

19.

2. public static
void setAccessible(AccessibleObject array,
boolean flag)
Позволяет установить флаг доступа к
объектам, передаваемым в виде массива.
Если в процессе обработки очередного
объекта выбрасывается исключение типа
SecurityException, объекты, расположенные
в массиве ранее, сохраняют вновь заданные
значения уровня доступа, а все остальные
объекты остаются в прежнем состоянии.
3. public boolean isAccessible()
Возвращает текущее значение флага доступа
к объекту

20.

Класс Array
Класс Array используется для создания массива
средствами рефлексии.
Для создания массивов используются две формы метода
newInstance.
public Object newlnstance(Class compType, int length)
Возвращает ссылку на новый массив типа compType
заданной длины length.
public Object newInstance(Class compType, int dim)
Возвращает ссылку на новый многомерный массив типа
compType, размерности которого заданы значениями
элементов массива-параметра dim.
Если массив dim пуст или обладает длиной, превышающей
допустимое число размерностей (обычно 255),

llegalArgumentException.

21.

Рассмотрим примеры.
Пример1. Сформируем массив типа byte
byte ba = (byte)
Array.newlnstance(byte.class,13);
Это равнозначно
byte ba = new byte;
Пример2.
int dims = {4, 4};
double matrix =(double)
Array.newlnstance(double.class, dims);
Это равнозначно
double matrix = new double;

22.

Класс Array обладает методами get и set.
Пусть задан массив ха значений типа int; тогда
выражению xa[i] будет соответствовать:
Integer n=Array.get(xa, i)
Присвоить значение элементу массива можно так:
xa[i] = 23; - это то же самое, что
Array.set(xa, i, new Integer(23));
Класс Package
Вызов метода getPackage класса Class позволяет
получить объект класса Package, содержащий
описание пакета, в составе которого определен
класс (сам класс Package размещен в пакете
java.lang).
Метод getName() объекта Package возвращает
полное имя текущего пакета.

23.

Класс Proxy
Класс Proxy позволяет динамически создавать
классы, реализующие один или несколько
интерфейсов.
Предположим, что имеется класс A,
реализующий некоторые интерфейсы.
Java-машина во время исполнения может
сгенерировать прокси-класс для данного
класса A, т.е. такой класс, который
реализует все интерфейсы класса A, но
заменяет вызов всех методов этих
интерфейсов на вызов метода invoke,
интерфейса InvocationHandler,для
которого можно определять свои
реализации.

24.

Создается прокси-класс с помощью вызова метода
Proxy.getProxyClass, который принимает ClassLoader и
массив интерфейсов (interfaces), а возвращает объект
класса java.lang.Class, который загружен с помощью
переданного ClassLoader и реализует переданный массив
интерфейсов.
На передаваемые параметры есть ряд ограничений:
1. Все объекты в массиве interfaces должны быть
интерфейсами. Они не могут быть классами или
примитивами.
2. В массиве interfaces не может быть двух одинаковых
объектов.
3. Все интерфейсы в массиве interfaces должны быть
загружены тем ClassLoader, который передается в метод
getProxyClass.
4. Все не публичные интерфейсы должны быть определены
в одном и том же пакете, иначе генерируемый прокси-класс
не сможет их все реализовать.

25.

5. Ни в каких двух интерфейсах не может быть
метода с одинаковым названием и
сигнатурой параметров, но с разными
типами возвращаемого значения.
6. Длина массива interfaces ограничена
65535-ю интерфейсами. Никакой Java-класс
не может реализовывать более 65535
интерфейсов.

26.

Свойства динамического прокси-класса
1. Прокси-класс является публичным, снабжен
модификатором final и не является абстрактным.
2. Имя прокси-класса по-умолчанию не
определено, однако начинается на Proxy. Все
пространство имен, начинающихся на Proxy
зарезервировано для прокси-классов
(В последних версиях Java это не обязательно).
3. Прокси-класс наследуется от
java.lang.reflect.Proxy.
4. Прокси-класс реализует все интерфейсы,
переданные при создании, в порядке передачи.

27.

5. Если прокси-класс реализует непубличный
интерфейс, то он будет сгенерирован в том пакете,
в котором определен этот самый непубличный
интерфейс. В общем случае пакет, в котором
будет сгенерирован прокси-класс неопределен.
6. Метод Proxy.isProxyClass возвращает true для
классов, созданных с помощью
Proxy.getProxyClass и для классов объектов,
созданных с помощью Proxy.newProxyInstance и
false в противном случае.
Данный метод используется подсистемой
безопасности Java и нужно понимать, что для
класса, просто унаследованного от
java.lang.reflect.Proxy он вернет false.

28.

Свойства созданного экземпляра прокси-класса следующие:
1. Объект прокси-класса приводим ко всем интерфейсам,
переданным в массиве interfaces. Если IDemo - один из
переданных интерфейсов, то операция proxy instanceof
IDemo всегда вернет true, а операция (IDemo) proxy
завершится корректно.
2. Статический метод Proxy.getInvocationHandler
возвращает обработчик вызовов, переданный при создании
экземпляра прокси-класса. Если переданный в данный
метод объект не является экземпляром прокси-класса, то
будет выброшено IllegalArgumentException исключение.
3. Класс-обработчик вызовов реализует интерфейс
InvocationHandler, в котором определен метод invoke,
имеющий следующую сигнатуру:
public Object invoke(Object proxy, Method method,
Object args) throws Throwable

29.

Рассмотрим пример:
package javaapplication3;
interface Account {
double getBalance();
void changeBalance(int sum);
void percents(double per);}
class MyAccount implements Account{
private double balance;
public MyAccount(){ balance=0.0; }
public double getBalance(){ return balance; }
public void changeBalance(int sum){
balance+=sum;}
public void percents(double per){
balance+=balance*per/100; }; }

30.

class MyAccountProxy implements
InvocationHandler{
private Account ac;
public MyAccountProxy(Account acc){ ac=acc; }
public static Account newInstance(Account da){
return (Account)Proxy.newProxyInstance(
da.getClass().getClassLoader(),
da.getClass().getInterfaces(),
new MyAccountProxy(da));
}

31.

public Object invoke(Object proxy,
Method method, Object args)
throws Throwable{
if(method.getName()=="percents"){
double d=((Double)args).doubleValue();
if (d<0) d=0;
if(d>30) d=30;
args=new Double(d);

else{
return method.invoke(ac, args); }
}
}

32.

public class Main{
public static void main(String args){
MyAccount ma=new MyAccount();
Account
a=(Account)MyAccountProxy.newInstance(ma);
a.changeBalance(150);

a.percents(20);
System.out.println(a.getBalance());
a.percents(35);
System.out.println(a.getBalance());} }

33.

Загрузка классов
Исполняющая система загружает классы по мере
возникновения необходимости в них.
Функциональные особенности процедур загрузки
классов существенным образом зависят от
реализации виртуальных машин Java, но в
большинстве случаев для отыскания классов,
адресуемых приложением, но не загруженных
исполняющей системой, применяется механизм
просмотра пути поиска классов.
Чтобы создать приложение, которое в состоянии
загружать классы способами, отличными от
предусмотренных по умолчанию, следует
воспользоваться объектом класса ClassLoader,
способным получить байт-код реализации нужного
класса и загрузить его в среду исполняющей
системы.

34.

Класс ClassLoader является абстрактным классом.
Для создания собственного загрузчика классов,
необходимо создать класс – наследник от
ClassLoader и переопределить метод
protected Class findClass(String name) throws
ClassNotFoundException
Который находит байт-код класса с заданным
именем name и загружает данные в среду
виртуальной машины, возвращая объект Class,
представляющий найденный класс.
Объект-загрузчик способен делегировать
полномочия по загрузке классов "родительскому"
загрузчику классов (parent class loader).
"Родительский" загрузчик классов может быть
задан в качестве аргумента конструктора класса
ClassLoader.

35.

protected ClassLoader()
Создает объект ClassLoader, неявно
используя в качестве "родительского"
загрузчика классов системный загрузчик
(который может быть получен посредством
вызова метода getSystemClassLoader).
protected ClassLoader(ClassLoader parent)
Создает объект ClassLoader, используя
заданный "родительский" загрузчик классов.
Основным в составе класса ClassLoader
является метод loadClass

36.

public Сlass loadClass(String name) throws
ClassNotFoundException
возвращает объект Class для класса с заданным
именем и при необходимости загружает этот
класс. Если класс не может быть загружен,
выбрасывается исключение типа
ClassNotFoundException.
Схема загрузки классов, предлагаемая методом
loadClass по умолчанию и обычно не
переопределяемая, выглядит так:
1. проверить посредством вызова метода
findLoadedClass класса ClassLoader, не
загружался ли заданный класс раньше; в составе
ClassLoader предусмотрена таблица объектов
Class для всех классов, загруженных средствами
текущего загрузчика классов; если класс был
загружен прежде, метод findLoadedClass
возвратит ссылку на существующий объект Class;

37.

2. если класс не загружался, вызывается
loadClass "родительского" загрузчика
классов; если текущий загрузчик не
обладает "родителем", используется
системный загрузчик классов;
3. если класс все еще не загружен,
вызывается метод findClass, выполняющий
поиск и загрузку класса.
Таким образом, необходимо реализовать
собственные версии следующих методов
ClassLoader:

38.

protected synchronized Class
loadClass(String name,boolean resolve)

protected Class findClass(String name)
throws ClassNotFoundException
protected java.net.URL findResource(String name)
protected java.util.Enumeration
findResources(String name) throws IOException
(Абстрактный класс ClassLoader представляет
только реализацию метода loadClass, основанную
на protected-методах – findLoadedClass и findClass).

39.

Рассмотрим пример.
class PlayerLoader extends ClassLoader {
public Class findClass(String name) throws
ClassNotFoundException {
try {
byte buf = bytesForClass(name);
return defineClass(name, buf, 0, buf.length);
}
catch (IOException e) {
throw new ClassNotFoundException(e.toString());
}
}
// ... Объявления метода bytesForClass и других
методов
}

40.

Метод findClass обычно выполняет две
функции.
Во-первых, он должен обнаружить байт-код
заданного класса и сохранить его в массиве
типа byte - эта обязанность в примере
возложена на метод bytesForСlass.
Во-вторых, он использует прикладной метод
defineСlass, чтобы выполнить фактическую
загрузку класса, определяемого байт-кодом.
Метод defineСlass имеет вид

41.

protected final Class defineClass(String name,
byte data, int offset, int length) throws
ClassFormatError
Возвращает объект Class для класса с заданным именем
name; бинарное представление класса передается в
виде массива data.
Для загрузки класса используются только байты,
содержащиеся в элементах массива data с индексами
от offset до offset+length. Если байты из указанного
промежутка не удовлетворяют требуемому формату
описания класса, выбрасывается объект исключения
типа ClassFormatError.
Метод ответствен за сохранение ссылки на объект
Class для загруженного класса в таблице загруженных
классов, просматриваемой методом findLoadedClass.

42.

Рассмотрим метод bytesForClass.
protected byte bytesForClass(String name) throws
lOException, ClassNotFoundException{
FileInputStream in = null;
try {

if (length == 0) throw new ClassNotFoundException(name);
byte buf = new byte;

return buf;
}
finally {
if (in!=null) in.close();
}
}

43.

Таким образом полный код имеет вид:
import java.lang.reflect.*;
import java.io.*;
class MyClassLoader extends ClassLoader{
public Class findClass(String name) throws
ClassNotFoundException {
byte buf=ReadFromBuffer(name);
if(name.equals("MyInterface1")){

} else if(buf==null) {
return findSystemClass(name);
} else {
return defineClass(name,buf,0,buf.length);
}
}

44.

protected byte ReadFromBuffer(String name) throws
ClassNotFoundException {
FileInputStream in = null;
try {
in = new FileInputStream(name + ".class");
int length = in.available(); // число доступных байтов
if (length == 0) throw
new ClassNotFoundException(name);
byte buf = new byte;
in.read(buf); // Считывание байтов
return buf;
}
catch(FileNotFoundException e){ return null;}
catch(IOException e){ return null;}
finally{
try{ if (in!=null) in.close(); }
catch(IOException e){ }
}
}

45.

protected synchronized Class
loadClass(String name,boolean resolve) throws
ClassNotFoundException{
Class result= findClass(name);
if (resolve) resolveClass(result);
return result;
}
}

46.

public class Main1 {
public static void main(String args) {
try{
String name="Myclass";
ClassLoader ld=new MyClassLoader();
Class cl=Class.forName(name, true, ld);
Constructor s=cl.getConstructor(int.class);
MyInterface1
ob=(MyInterface1)s.newInstance(
new Integer(8));
System.out.println(ob.func(3,5));
}catch(Exception e){ };
}
}

47.

public interface MyInterface1{
public int func(int a,int b);
}
public class Myclass implements MyInterface1 {
private int a;
public Myclass(int k) { a=k; }
public int func(int a,int b){ return a+b; }

Хочу продолжить делиться приобретенными знаниями и своими впечатлениями от подготовки к экзамену. Огромное спасибо всем тем, кто дал рекомендации к нулевой части этой серии! Сегодня я поговорю еще немножко о модификаторах доступа и их взаимоотношениях с наследованием и пакетами, рассмотрю varargs и перечисления, а также массивы и способы их инициализации. Я надеюсь, что хабражители снова откликнутся и дополнят то, о чем я забыл упомянуть или попросту не знал.

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

Методы, поля, локальные переменные и их модификаторы

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

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

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

Хочу также обратить внимание на некоторые особенности, которые возникают при использовании доступа по умолчанию и модификатора protected. Рассмотрим следующуий пример. Пусть имеется базовый класс, объявленный в пакете test. Этот класс обладает двумя полями. Первое объявлено с доступом по умолчанию, второе - protected.

Package org.kimrgrey.scjp.test; public class BaseClass { int defaultValue; protected int protectedValue; public BaseClass() { this.defaultValue = 1; this.protectedValue = 1; } }

Если объявить в этом пакете класс SamePackageAccess, который не будет наследоваься от BaseClass, то он все равно получит доступ и к полю defaultValue, и к полю protectedValue. Об этой особенности модификатора protected стоит помнить: члены класса, объявленные как protected, в рамках пакета доступны как через наследование, так и через ссылку. Пример:

Package org.kimrgrey.scjp.test; public class SamePackageAccess { public SamePackageAccess() { BaseClass a = new BaseClass(); a.defaultValue = 2; a.protectedValue = 2; } }

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

Package org.kimrgrey.scjp.test; public class SamePackageSubclass extends BaseClass { public SamePackageSubclass() { this.defaultValue = 3; this.protectedValue = 3; BaseClass a = new BaseClass(); a.defaultValue = 3; a.protectedValue = 3; } }

Теперь давайте посмотрим, что будет, если мы выйдем за пределы пакета. Первое, что случится - мы потеряем доступ к полю, объявленному без явного указания модификатора доступа. Его не будут видеть абсолютно все классы вне родного пакета, в том числе и прямые наследники BaseClass. Поле же с модификатором protected будет доступно через наследование всем своим подклассам. Однако даже наследник не сможет его использовать через ссылку. Кроме того, будучи однажды унаследованным классом вне пакета, поле становится закрытым для любых классов, за исключением дальнейших наследников.

Package org.kimrgrey.scjp.main; import org.kimrgrey.scjp.test.BaseClass; public class OtherPackageSubclass extends BaseClass { public OtherPackageSubclass() { this.defaultValue = 10; // Line 8: не получим доступ, потому что другой пакет this.protectedValue = 10; BaseClass a = new BaseClass(); a.protectedValue = 10; // Line 12: по ссылке не могут обращаться даже наследники BaseClass } }

В этом примере содержится также еще одна важная деталь. Предположим, вас спрашивают, что же случиться если скомпилировать приведенный выше код? И дают следующие варианты ответа:

Код будет успешно скомпилирован
Возникнет ошибка компиляции на строке с номером 8
Возникнет ошибка компиляции на строке с номером 12

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

Среди модификаторов, связанных с наследованием, следует также рассмотреть final. На методы final действует также, как на классы: запрещает их переопределение наследниками. При этом расширять сам класс, в котром находится final метод, по-прежнему можно.

Разрешается применять модификатор final к полям, аргументам методов и локальным переменным. В случае примитивных типов будет запрещено любое изменение значения переменной, кромее ее инициализации. Тут следует помнить, что моментом инициализации локальных переменных считается первое присваивание им значения в рамках метода. До этого переменную использовать нельзя: получите ошибку при компиляции. Помеченное final поле также придется явным образом инициализировать. Это можно сделать либо непосредственно при объявлении, в инициализационном блоке, либо в конструкторе того класса, в котором оно объявлено. Оставлять инициализацию final полей на совести наследников не разрешается. В случае ссылок модификатор final запретит переприсваивать ссылку. Сам объект, на который ссылка указывает, все еще можно изменять: вызывать изменяющие его состояния методы, присваивать полям новое значение и так далее.

Важно помнить, что к локальным переменным неприменимы никакие модификаторы, кроме final. Поэтому, если вы видите в объявлении локальной переменной что-то вроде private int a , то можно смело говорить, что это не скомпилируется. А что же с полями?

К полям, как я уже говорил, применимы все четыре уровня доступа.
Поле может быть помечено как final.
Поле может быть помечено как transient.
Поле может быть помечено как static.
Поле может быть помечено как volatile.
Поле не может быть помечено как abstract.
Поле не может быть помечено как synchronized.
Поле не может быть помечено как strictfp.
Поле не может быть помечено как native.

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

Методы с переменным количеством аргументов

Когда вы указываете параметр vararg, то базовым типом может быть любой тип: примитивный или нет.
Чтобы объявить такой параметр, вы пишите тип, потом три точки, пробел, затем имя массива, который будет использоваться в рамках метода: void f (int... a) . Можно также разделить тип, три точки и идентифкаторы пробелами, так: void f(int ... a) . Внимательно следите за точками. Авторы экзамена любят переносить их за идентификатор. Такой подход не работает.
В метод могут передаваться другие параметры, но в этом случае параметр vararg должен быть последним: void f (double x, int... a)
В методе может быть один и только один vararg параметр.

Для наглядности приведу хороший пример вопроса по этой теме. Выберите такое объявление метода doSomething(), чтобы приведенный ниже код был удачно скомпилирован?

Package org.kimrgrey.scjp.main; public class Application { public static void main(String args) { doSomething(1); doSomething(1, 2); } }

static void doSomething(int... values) {}
static void doSomething(int values) {}
static void doSomething(int x, int... values) {}

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

Package org.kimrgrey.scjp.main; public class Application { private static void f (int... a) { for (int i = 0; i < a.length; ++i) { System.out.println(a[i]); } } public static void main(String args) { f(new int {1, 2 ,3}); } }

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

Перечисления

У перечислений могут быть конструкторы.
У перечислений могут быть поля.
У перечислений могут быть методы.
Если перечисление объявляется вне класса, оно может получить только два уровня доступа: public или по умолчанию.
У перечислений есть статический метод values() , который возвращает массив, содержащий все возможные значения перечисления, причем строго в том порядке, в котором они были объявлены.

Для каждого из значений в рамках перечисления вы можете объявить свое собственное «тело» - его специфическое описание. При этом специфичные для значения версии методов перегружают вариант, который используется для всего перечисления в целом. Это позволяет менять поведение членов перечисления в зависимости от нужд приложения. Пример:

Package org.kimrgrey.scjp.main; import static java.lang.System.*; enum Currency { UNKNOWN, USD { public String getStringCode() { return "USD"; } public int getSomethingElse() { return 10; } }, UAH { public String getStringCode() { return "UAH"; } }, RUR { public String getStringCode() { return "RUR"; } }; public String getStringCode() { return ""; } } public class Application { private static void f (int... a) { for (int i = 0; i < a.length; ++i) { out.println(a[i]); } } public static void main(String args) { out.println(Currency.USD.getStringCode()); // out.println(Currency.USD.getSomethingElse()); } }

В результате выполения этого кода в стандартный поток вывода будет помещена строка «USD». Обратите внимание на метод getSomethingElse(). Он объявлен для значения USD, однако не упоминается для всего перечисления. Не смотря на то, что в объявлении стоит public, никто из вне доступ к этому методу получить не сможет. Если строку за номером 44 раскомментировать, то код даже не скомпилируется.

Немного о массивах

В Java допустимы два варианта объявления массивов. Квадратные скобки могут быть размещены после имени типа, так: int a , - или после идентификатора, так: int a . Важно понимать, что оба способа абсолютно равноправны с точки зрения синтаксиса, хотя первый из них и является рекомендуемым. Таким образом, String s - это ни что иное, как двумерный массив строк. Скомпилируется без вопросов.

При объявлении массива нельзя указать его размер, так как память выделяется только в момент создания массива: int a = new int . Поэтому код int a вызовет ошибку компиляции. В случае с массивом ссылок на объекты важно помнить, что при создании массива сами объекты не создаются. К примеру, код Thread threads = new Thread создаст массив из двадцати null"ов, никаких конструкторов вызываться не будет.

При построении многомерных массивов о них нужно думать, как о массивах, каждый элемент которых ссылается снова на массив. Абстрактные конструкции вроде матриц и кубов упрощают программирование, но могут усложнить сдачу экзамена. К примеру, конструкция int a = new int вполне допустима и создаст двумерный массив, элементы которого могут быть проинициализированы позже: a = new int , - причем совсем не обязательно массивами равной длины: a = new int .

Для того, чтобы проинициализировать массив быстро (не элемент за элементом), можно применять синтаксис вроде этого: int x ={1, 2, 3} . В фигурных скобках могут стоять не только константы, но и переменные и даже выражения. Можно также создавать анонимные массивы, что часто используется когда нужно передать строго определенный массив в функцию: f(new int {2, 4, 8}) . Если вы видите на экзамене такую конструкцию, то обязательно присмотритесь внимательнее. Есть вероятность, что будет написано что-то вроде этого: f(new int {2, 4, 8}) . Такой код не будет скомпилирован, так как размер анонимного массива вычисляется исходя из его объявления и не должен указываться явным образом.

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

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

Модификаторы в Java – это ключевые слова, которые придают классу, полю класса или методу определенные свойства.

Для обозначения видимости класса его методов и полей есть 4 модификатора доступа:

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

Если Вы помните , то в конце, когда мы уже импортировали класс Cat, у нас все равно была ошибка компиляции.

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

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

Представьте, что у Вас есть класс который отображает объект некоего продукта. Например машина. У машины может быть цена. Вы создали поле цена и еще множество других полей, кучу методов которые отвечают за функционал. Все вроде хорошо. Ваш класс машина является частью огромного проекта и все довольны. Но допустим, что кто-то по ошибке или специально создал экземпляр класса автомобиль и поставил отрицательную цену. Разве может товар иметь отрицательную цену? Это очень примитивный пример и вряд ли такое может случиться в реальной жизни, но думаю, идея понятна. Иногда нужно дать доступ не напрямую, а через определенные методы. Может быть, что код отвечает за функционал другого кода, и Вы не хотите, чтобы кто-то изменял и редактировал часть Вашего. Для этого всего и есть ограничение доступа.

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

Пока об модификаторах доступа будет достаточно. В статье «Объектно ориентированное программирование» мы о них поговорим подробнее, а сейчас давайте поговорим о других модификаторах которых, к стати, немало.

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

static модификатор перед методом или полем говорит о том, что они не принадлежат к экземпляру данного класса. Что это означает для нас? Когда мы описали поле класса или метод как static, его можно вызвать без использования экземпляра класса. То есть вместо такой конструкции: Cat cat = new Cat(); cat.method(), можно написать просто Cat.method(). При условии, что метод объявлен как static. Статические переменные едины для всех объектов класса. У них одна ссылка.

public class Modificators {

static int anotherStaticField = 5 ;

public static void myStaticMethod() {

someField = "My field" ;

//nonStaticField = ""; ошибка компиляции

//нельзя использовать нестатические поля

//в статических методах

public void myNonStaticMethod() {

anotherStaticField = 4 ; //ститические поля можно использовать

//в нестатических методах

//main метод тоже имеет модификатор static

new Modificators() .myNonStaticMethod () ;

Modificators.myStaticMethod () ; //вызов статических методов и полей

//через имяКласса.метод

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

Вопрос: что будет выведено на консоль? Нужно помнить, что static блок будет выведен первым при любом раскладе. Далее будет идти блок по умолчанию. Далее смотрите на скрин консоли:

Следующий модификатор, который мы рассмотрим будет final.

Думаю, слово final говорит само за себя. Применяя final модификатор Вы говорите, что поля не могут быть изменены, методы переопределены, а классы нельзя наследовать (о наследовании будет отдельная статья). Этот модификатор применяется только к классам, методам и переменным (также и к локальным переменным).

С модификатором final к методам и классам мы будем говорить в статье ООП.

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

Модификатор synchronized — говорит о том, что метод может быть использован только одним потоком одновременно. Хотя, возможно, это Вам ни о чем не говорит, полезность этого модификатора будет видно, когда мы будем изучать многопоточность.

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

Модификатор volatile — используется при многопоточности. Когда поле с модификатором volatile будет использоваться и изменяться несколькими потоками, данный модификатор гарантирует, что поле будет изменяться по очереди и путаницы с ним не возникнет.

Модификатор native перед объявлением метода указывает что метод написан на другом языке программирования. Обычно на языке C.

Модификатор strictfp — Обеспечивает выполнение операций над числами типа float и double (с плавающей запятой) по стандарту IEEE 754. Или говоря проще, гарантирует что в пределах метода результаты вычислений будут одинаковыми на всех платформах.

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

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

Подробнее о модификаторе abstract будем говорить в статье ООП.

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

Здесь мы постараемся рассмотреть почти все случаи применения модификаторов доступа. Исключение составят лишь их применение для вложенных (nested ) и внутренних (inner ) классов, а так же для интерфейсов, так как эти темы мы еще пока не рассматривали.

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

Модификаторы доступа могут применяться как к классам, так и их членам – полям и методам. Всего существует четыре модификатора доступа и тут приведем их краткое описание, потом рассмотрим каждый подробно.

public – любой компонент, объявленный как public , доступен из любого кода
protected – разрешает доступ к компоненту в пределах пакета и классам наследникам
private – разрешает доступ к компоненты в пределах класса
по умолчанию (нет ключевого слова) – разрешает доступ к компонентам в пределах пакета

Классы наследники – это классы унаследованные от какого-либо класса. Наследование мы пока еще не изучали .

Доступ к классам

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

Доступ к членам класса

Члены класса всегда доступны внутри тела класса. По умолчанию члены класса также доступны в пакете, в котором класс определен .

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

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

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

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

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

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

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

protected .

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

Это самый жесткий по ограничению доступа модификатор. Элементы объявленные как private доступны только внутри этого же класса и ни кому вне класса.

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

Классы и интерфейсы верхнего уровня не могут быть объявлены как private .

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

Я создал классы Mod02.java, DefMod.java, ProMod.java и PrvMod.java которые принадлежат пакету pro.java.pkg002, а так же класс PubMod.java, принадлежащий пакету pro.java.pkg003. Далее приведу просто скрины этих классов и результат работы программы: