Модификаторы уровня доступа. Java-модификаторы
Здесь мы постараемся рассмотреть почти все случаи применения модификаторов доступа. Исключение составят лишь их применение для вложенных (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. Далее приведу просто скрины этих классов и результат работы программы:
Существует возможность управлять тем, какие части программы могут получать доступ к членам класса. Управление доступом позволяет предотвращать злоупотребления. Не всегда желательно, чтобы имелся доступ к отдельной переменной или методу класса, которые должны работать только внутри самого класса.
Способ доступа определяется модификатором доступа , который добавляется при объявлении. Всего их четыре:
- 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 – это ключевые слова, которые придают классу, полю класса или методу определенные свойства.
Для обозначения видимости класса его методов и полей есть 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 будем говорить в статье ООП.
На этом можно и закончить статью о модификаторах. Многое о них не было сказано. Но это из-за того, что у нас еще нет понятий ООП. Через несколько статей, мы дополним знания о модификаторах и заполним пробелы.
Привет! В сегодняшней лекции мы познакомимся с понятием «модификаторы доступа » и рассмотрим примеры работы с ними. Хотя слово «познакомимся» будет не совсем правильным: с большинством из них ты уже знаком по предыдущим лекциям. На всякий случай освежим в памяти главное. Модификаторы доступа - это чаще всего ключевые слова, которые регулируют уровень доступа к разным частям твоего кода. Почему «чаще всего»? Потому что один из них установлен по умолчанию и не обозначается ключевым словом:) Всего в Java есть четыре модификатора доступа. Перечислим их в порядке от самых строгих до самых «мягких»:
- private;
- protected;
- default (package visible);
- public.
Модификатор private
Private - наиболее строгий модификатор доступа. Он ограничивает видимость данных и методов пределами одного класса.
Этот модификатор тебе известен из лекции про геттеры и сеттеры. Помнишь этот пример?
public
class
Cat
{
public
String name;
public
int
age;
public
int
weight;
public
Cat
(String name,
int
age,
int
weight)
{
this
.
name =
name;
this
.
age =
age;
this
.
weight =
weight;
}
public
Cat
()
{
}
public
void
sayMeow
()
{
System.
out.
println
("Мяу!"
)
;
}
}
public
class
Main
{
public
static
void
main
(String
args)
{
Cat cat =
new
Cat
()
;
cat.
name =
""
;
cat.
age =
-
1000
;
cat.
weight =
0
;
}
}
Мы рассматривали его в одной из статей раньше.
Здесь мы допустили серьезную ошибку: открыли наши данные, в результате чего коллеги-программисты получили доступ напрямую к полям класса и изменению их значения. Более того, эти значения присваивались без проверок, в результате чего в нашей программе можно создать кота с возрастом -1000 лет, именем «» и весом 0.
Для решения этой проблемы мы использовали геттеры и сеттеры
, а также ограничили доступ к данным с помощью модификатора private .
public
class
Cat
{
private
String name;
private
int
age;
private
int
weight;
public
Cat
(String name,
int
age,
int
weight)
{
this
.
name =
name;
this
.
age =
age;
this
.
weight =
weight;
}
public
Cat
()
{
}
public
void
sayMeow
()
{
System.
out.
println
("Мяу!"
)
;
}
public
String getName
()
{
return
name;
}
public
void
setName
(String name)
{
this
.
name =
name;
}
public
int
getAge
()
{
return
age;
}
public
void
setAge
(int
age)
{
this
.
age =
age;
}
public
int
getWeight
()
{
return
weight;
}
public
void
setWeight
(int
weight)
{
this
.
weight =
weight;
}
}
Собственно, ограничение доступа к полям и реализация геттеров-сеттеров - самый распространенный пример использования private в реальной работе.
То есть реализация инкапсуляции в программе - главное предназначение этого модификатора.
Это касается не только полей, кстати. Представь, что в твоей программе существует метод, который реализует какую-то ОЧЕНЬ сложную функциональность.
Что бы придумать такого для примера…
Скажем, твой метод readDataFromCollider() принимает на вход адрес с данными, считывает данные из Большого Адронного Коллайдера в байтовом формате, преобразует эти данные в текст, записывает в файл и распечатывает его.
Даже описание метода выглядит жутковато, что уж говорить про код:)
Чтобы повысить читаемость кода, было бы хорошо не писать сложную логику метода в одном месте, а наоборот - разбить функциональность на отдельные методы.
Например, метод readByteData() отвечает за считывание данных, convertBytesToSymbols() конвертирует считанные с коллайдера данные в текст, saveToFile() сохраняет полученный текст в файл, а printColliderData() - распечатывает наш файл с данными.
Метод readDataFromCollider() в итоге стал бы намного проще:
public
class
ColliderUtil
{
public
void
readDataFromCollider
(Path pathToData)
{
byte
colliderData =
readByteData
(pathToData)
;
String
textData =
convertBytesToSymbols
(colliderData)
;
File fileWithData =
saveToFile
(textData)
;
printColliderData
(fileWithData)
;
}
public
byte
readByteData
(Path pathToData)
{
// считывает данные в байтах
}
public
String
convertBytesToSymbols
(byte
colliderDataInBytes)
{
}
public
File saveToFile
(String
colliderData)
{
}
public
void
printColliderData
(File fileWithColliderData)
{
// печатает данные из файла
}
}
Однако, как ты помнишь из лекции про интерфейсы, пользователь получает доступ только к конечному интерфейсу. А наши 4 метода не являются его частью. Они вспомогательные
: мы создали их, чтобы улучшить читаемость кода и не засовывать четыре разные задачи в один метод.
Давать доступ пользователю к этим методам не нужно. Если у пользователя при работе с коллайдером появится доступ к методу convertBytesToSymbols() , он скорее всего просто не поймет, что это за метод и зачем нужен. Какие байты конвертируются? Откуда они взялись? Зачем их конвертировать в текст?
Логика, которая выполняется в этом методе, не является частью интерфейса для пользователя.
Только метод readDataFromCollider() - часть интерфейса.
Что же делать с этими четырьмя «внутренними» методами? Правильно! Ограничить доступ к ним модификатором private .
Так они смогут спокойно выполнять свою работу внутри класса и не вводить в заблуждение пользователя, которому логика каждого из них по отдельности не нужна.
public
class
ColliderUtil
{
public
void
readDataFromCollider
(Path pathToData)
{
byte
colliderData =
readByteData
(pathToData)
;
String
textData =
convertBytesToSymbols
(colliderData)
;
File fileWithData =
saveToFile
(textData)
;
printColliderData
(fileWithData)
;
}
private
byte
readByteData
(Path pathToData)
{
// считывает данные в байтах
}
private
String
convertBytesToSymbols
(byte
colliderDataInBytes)
{
// конвертирует байты в символы
}
private
File saveToFile
(String
colliderData)
{
// сохраняет считанные данные в файл
}
private
void
printColliderData
(File fileWithColliderData)
{
// печатает данные из файла
}
}
Модификатор protected
Следующий по строгости модификатор доступа - protected .
Поля и методы, обозначенные модификатором доступа protected , будут видны:
- в пределах всех классов, находящихся в том же пакете, что и наш;
- в пределах всех классов-наследников нашего класса.
Модификатор package visible
Дальше у нас по списку идет модификатор default или, как его еще называют, package visible . Он не обозначается ключевым словом, поскольку установлен в Java по умолчанию для всех полей и методов. Если написать в твоем коде - int x = 10 … у переменной x будет этот самый package visible доступ. Запомнить, что он делает, легко. По сути, default = protected -наследование:) Случаи его применения ограничены, как и у модификатора protected . Чаще всего default -доступ используется в пакете, где есть какие-то классы-утилиты, не реализующие функциональность всех остальных классов в этом пакете. Приведем пример. Представь, что у нас есть пакет «services ». Внутри него лежат различные классы, которые работают с базой данных. Например, есть класс UserService , считывающий данные пользователей из БД, класс CarService , считывающий из этой же БД данные об автомобилях, и другие классы, каждый из которых работает со своим типом объектов и читает данные о них из базы. package services; public class UserService { } package services; public class CarService { } Однако легко может случиться ситуация, когда данные в базе данных лежат в одном формате, а нам они нужны в другом. Представь, что дата рождения пользователя в БД хранится в формате TIMESTAMP WITH TIME ZONE... 2014 - 04 - 04 20 : 32 : 59.390583 + 02 ...нам вместо этого нужен самый простой объект - java.util.Date . Для этой цели можем создать внутри пакета services специальный класс Mapper . Он будет отвечать за конвертацию данных из базы в привычные нам Java-объекты. Простой вспомогательный класс. Обычно мы создаем все классы как public class ClassName , но это не обязательно. Мы можем объявить наш вспомогательный класс просто как class Mapper . В таком случае он все равно делает свою работу, но не виден никому за пределами пакета services ! package services; class Mapper { } package services; public class CarService { Mapper mapper; } А это, по сути, правильная логика: зачем кому-то за пределами пакета видеть вспомогательный класс, работающий только с классами этого же пакета?Модификатор public
И последний по списку, но не по значимости - модификатор public ! С ним ты познакомился в первый день учебы на JavaRush, впервые в жизни запустив public static void main(String args) .
Теперь, когда ты изучил лекции об интерфейсах, для тебя очевидно его предназначение:) Ведь public создан для того, чтобы отдавать что-то пользователям. Например, интерфейс твоей программы.
Допустим, ты написал программу-переводчик, и она умеет переводить русский текст в английский. Ты создал метод translate(String textInRussian) , внутри которого реализована необходимая логика.
Этот метод ты отметил словом public , и теперь он станет частью интерфейса:
public
class
Translator
{
public
String translate
(String textInRussian)
{
// переводит текст с русского на английский
}
}
Можно связать вызов этого метода с кнопкой «перевести» на экране программы - и все! Кто угодно может этим пользоваться.
Части кода, помеченные модификатором public , предназначаются для конечного пользователя.
Если привести пример из жизни, private - это все процессы, происходящие внутри телевизора, когда он работает, а public - это кнопки на пульте телевизора, с помощью которых пользователь может им управлять. При этом ему не нужно знать как устроен телевизор и за счет чего он работает. Пульт - это набор public -методов: on() , off() , nextChannel() , previousChannel() , increaseVolume() , decreaseVolume() и т.д.
Для начала разберемся с модификаторами доступа. Их всего четыре:
- 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 если:
- он содержит хотя бы один абстрактный метод
- он не предоставляет реализацию наследуемых абстрактных методов
- он не предоставляет реализацию методов интерфейса, реализацию которого он объявил
- необходимо запретить создание экземпляров класса
Final
- Поля не могут быть изменены, методы переопределены
- Классы нельзя наследовать
- Этот модификатор применяется только к классам, методам и переменным (также и к локальным переменным)
- Аргументы методов, обозначенные как final, предназначены только для чтения, при попытке изменения будет ошибка компиляции
- Переменные final не инициализируются по умолчанию, им необходимо явно присвоить значение при объявлении или в конструкторе, иначе – ошибка компиляции
- Если final переменная содержит ссылку на объект, объект может быть изменен, но переменная всегда будет ссылаться на тот же самый объект
- Также это справедливо и для массивов, потому что массивы являются объектами, – массив может быть изменен, а переменная всегда будет ссылаться на тот же самый массив
- Если класс объявлен final и 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 |
Да |
Да |
Нет |
Да |
Нет |
Нет |
Статьи по теме
