# Non-Access Modifiers
Non-Access Modifiers do not change the accessibility of variables and methods, but they do provide them special properties.
# final
final in Java can refer to variables, methods and classes. There are three simple rules:
- final variable cannot be reassigned
- final method cannot be overriden
- final class cannot be extended
Usages
Good Programming Practice
Some developer consider it good practice to mark a variable final when you can. If you have a variable that should not be changed, you should mark it final.
An important use of final keyword if for method parameters. If you want to emphasize that a method doesn’t change its input parameters, mark the properties as final.
This emphasizes that the sumup method is not going to change the ints .
Inner class Access
If your anonymous inner class wants to access a variable, the variable should be marked final
This class doesn’t compile, as the variable name , is not final.
Effectively final variables are an exception. These are local variables that are written to only once and could therefore be made final. Effectively final variables can be accessed from anonymus classes too.
final static variable
Even though the code below is completely legal when final variable foo is not static , in case of static it will not compile:
The reason is, let’s repeat again, final variable cannot be reassigned. Since foo is static, it is shared among all instances of class TestFinal . When a new instance of a class TestFinal is created, its constructor is invoked and therefore foo gets reassigned which compiler does not allow. A correct way to initialize variable foo in this case is either:
or by using a static initializer:
final methods are useful when base class implements some important functionality that derived class is not supposed to change it. They are also faster than non-final methods, because there is no concept of virtual table involved.
All wrapper classes in Java are final, such as Integer , Long etc. Creators of these classes didn’t want that anyone can e.g. extend Integer into his own class and change the basic behavior of Integer class. One of the requirements to make a class immutable is that subclasses may not override methods. The simplest way to do this is to declare the class as final .
# static
The static keyword is used on a class, method, or field to make them work independently of any instance of the class.
- Static fields are common to all instances of a class. They do not need an instance to access them.
- Static methods can be run without an instance of the class they are in. However, they can only access static fields of that class.
- Static classes can be declared inside of other classes. They do not need an instance of the class they are in to be instantiated.
# abstract
Abstraction is a process of hiding the implementation details and showing only functionality to the user. An abstract class can never be instantiated. If a class is declared as abstract then the sole purpose is for the class to be extended.
# strictfp
strictfp modifier is used for floating-point calculations. This modifier makes floating point variable more consistent across multiple platforms and ensure all the floating point calculations are done according to IEEE 754 standards to avoid errors of calculation (round-off errors), overflows and underflows on both 32bit and 64bit architecture. This cannot be applied on abstract methods, variables or constructors.
# volatile
The volatile modifier is used in multi threaded programming. If you declare a field as volatile it is a signal to threads that they must read the most recent value, not a locally cached one. Furthermore, volatile reads and writes are guaranteed to be atomic (access to a non- volatile long or double is not atomic), thus avoiding certain read/write errors between multiple threads.
# synchronized
Synchronized modifier is used to control the access of a particular method or a block by multiple threads. Only one thread can enter into a method or a block which is declared as synchronized. synchronized keyword works on intrinsic lock of an object, in case of a synchronized method current objects lock and static method uses class object. Any thread trying to execute a synchronized block must acquire the object lock first.
# transient
A variable which is declared as transient will not be serialized during object serialization.
Final, Константы и Immutable в Java
Привет! Слово “модификатор” тебе уже знакомо. Как минимум, ты сталкивался с модификаторами доступа (public, private) и с модификатором static. Сегодня поговорим о специальном модификаторе final . Он, можно сказать, “цементирует” те участки нашей программы, где нам нужно постоянное, однозначное, не меняющееся поведение. Его можно применять на трех участках нашей программы: в классах, методах и переменных. Пройдемся по ним по очереди. Если в объявлении класса стоит модификатор final , это значит, что от данного класса нельзя наследоваться. В прошлых лекциях мы видели простой пример наследования: у нас был родительский класс Animal , и два класса-потомка — Cat и Dog Однако, если мы укажем для класса Animal модификатор final , унаследовать классы Cat и Dog от него не получится. Компилятор сразу же выдает ошибку. В Java уже реализовано много final -классов. Наиболее известный из тех, которыми ты постоянно пользуешься — String . Кроме того, если класс объявлен как final , все его методы тоже становятся final . Что это значит? Если для метода указан модификатор final — этот метод нельзя переопределить. Например, у нас есть класс Animal , в котором определен метод voice() . Однако собаки и кошки явно “разговаривают” по-разному. Поэтому в каждом из классов — Cat и Dog — мы создадим метод voice() , но реализуем его по-разному. В классах Cat и Dog мы переопределили метод родительского класса. Теперь животное будет подавать голос в зависимости от того, объектом какого класса оно является: Вывод: Мяу! Гав! Однако, если в классе Animal мы объявим метод voice() как final , переопределить его в других классах будет нельзя: Тогда наши объекты будут вынуждены пользоваться методом voice() так, как он определен в родительском классе: Вывод: Голос! Голос! Теперь по поводу final -переменных. По-другому они называются константами. Во-первых (и в-главных), первое значение, присвоенное константе, нельзя изменить. Оно присваивается один раз и навсегда. Константу необязательно инициализировать сразу же. Это можно сделать и позже. Но значение присвоенное первым так и останется навсегда. Во-вторых, обрати внимание на название нашей переменной. Для констант в Java принято иное соглашение об именовании. Это не привычный нам camelCase. В случае с обычной переменной мы бы назвали ее constantExample, но названия констант пишется капсом, а между словами (если их несколько) ставится нижнее подчеркивание — “CONSTANT_EXAMPLE”. Зачем нужны константы? Например, они пригодятся, если ты постоянно используешь какое-то неизменное значение в программе. Скажем, ты решил войти в историю и в одиночку написать игру “Ведьмак 4”. В игре явно будет постоянно использоваться имя главного героя — “Геральт из Ривии”. Эту строку и имена других героев лучше выделить в константу: нужное тебе значение будет храниться в одном месте, и ты точно не ошибешься, печатая его в миллионный раз. Вывод:Мы выделили имена героев в константы, и теперь совершенно точно не опечатаемся, и не будет нужды каждый раз писать их руками. Еще один плюс: если нам в итоге все-таки нужно будет изменить значение переменной во всей программе, достаточно сделать это в одном месте, а не переделывать вручную во всем коде 🙂
Immutable-типы
За время работы на Java ты уже, наверное, привык к тому, что программист практически полностью управляет состоянием всех объектов. Захотел — создал объект Cat . Захотел — переименовал его. Захотел — поменял возраст, или еще что-нибудь. Но в Java есть несколько типов данных, которые отличаются особым состоянием. Они являются неизменяемыми, или Immutable. Это значит, что если класс неизменяемый, состояние его объектов изменить невозможно. Примеры? Возможно ты удивишься, но самый известный пример Immutable — класса — String ! Казалось бы, разве мы не можем изменить значение строки? Ну, давай попробуем: Вывод: I love Java I love Java После того, как мы написали: объект со строкой «I love Java» не изменился и никуда не делся. Он благополучно существует и имеет внутри себя ровно тот же текст, что и раньше. Код: просто создал еще один объект, и теперь переменная str1 указывает на него. Но на объект «I love Java» мы никак не можем повлиять. Так, ладно, давай попробуем по-другому! В классе String полно методов, и некоторые из них, похоже с виду меняют состояние строки! Вот, например, есть метод replace() . Давай поменяем слово “Java” на слово “Python” в нашей строке! Вывод: I love Java I love Java Снова не получилось! Может, метод кривой, не работает? Попробуем другой. Вот, например, substring() . Обрезает строку по номерам переданных символов. Давай обрежем нашу до первых 10 символов: Вывод: I love Java I love Java Ничего не поменялось. И не должно было. Как мы и сказали — объекты String неизменяемые. А что же тогда все эти методы класса String ? Они же могут обрезать строку, изменить в ней символы и прочее. Зачем они тогда нужны, если ничего не происходит? Могут! Но они при этом каждый раз возвращают новый объект строки. Бесполезно писать: — ты не изменишь исходный объект. Но если ты запишешь результат работы метода в новую переменную-ссылку, сразу увидишь разницу! Только так все эти методы String и работают. С объектом «I love Java» ничего сделать нельзя. Только создать новый объект, и написать: “Новый объект = результат каких-то манипуляций с объектом «I love Java» ”. Какие типы еще относятся к Immutable? Из того, что тебе железобетонно нужно запомнить уже сейчас — все классы-обертки над примитивными типами — неизменяемые. Integer , Byte , Character , Short , Boolean , Long , Double , Float — все эти классы создают Immutable объекты. Сюда же относятся и классы, используемые для создания больших чисел — BigInteger и BigDecimal . Мы недавно проходили исключения и затрагивали StackTrace . Так вот: объекты класса java.lang.StackTraceElement тоже неизменяемые. Это логично: если бы кто-то мог изменять данные нашего стэка, это могло бы свести на нет всю работу с ним. Представь, что кто-нибудь заходит в StackTrace и меняет OutOfMemoryError на FileNotFoundException. А тебе с этим стеком работать и искать причину ошибки. А программа при этом вообще не использует файлы 🙂 Поэтому от греха подальше эти объекты сделали неизменяемыми. Ну, со StackTraceElement более-менее понятно. А зачем кому-то понадобилось делать неизменяемыми строки? В чем проблема, если бы можно было менять их значения. Наверное, даже удобнее бы было :/ Причин тут несколько. Во-первых, экономия памяти. Неизменяемые строки можно помещать в String Pool и использовать каждый раз одну и ту же вместо создания новых. Во-вторых, безопасность. Например, большинство логинов и паролей в любой программе — строки. Возможность их изменения могла бы повлечь проблемы с авторизацией. Есть и другие причины, но пока что мы не дошли к ним в изучении Java — вернемся попозже.
private static и private final static — зачем?
В каких случаях следует помечать переменные таким образом? Какой толк от static , если он помечен как private ?
Посмотрите данные по шаблону проектирования singleton.
private static гарантирует единственность экземпляра объекта с такими свойствами в потоке, где задействован класс.
private static final гарантирует, что этот экземпляр не подменится на что-то другое.
Удобно при работе с базами данных или каким-то ресурсом, не склонным к разделению.
Какой толк от static, если он помечен как private?
Необходимо, если переменную нужно использовать в статических методах
Final нужно использовать, если ссылка будет инициализироваться один раз и не должна быть заменена. В большинстве случаев static переменные именно так и используются.
Если static переменная изменяется в ходе программы, скорее всего есть какие то проблемы с дизайном ( static — отсутствие экземпляра объекта, в каком то смысле отсутствие состояния, изменение ссылки — смена состояние -> противоречие).
Модификаторы доступа static final следует применять, когда есть необходимость явно указать на то, что переменную не следует или запрещено изменять, то есть модификаторы static final превращают переменную в константу.
В свою очередь переменные помеченные модификатором static являются обычными переменными с тем лишь различием, что их экземпляр (в единственном числе) хранится не с экземпляром каждого создаваемого объекта (области памяти где хранятся переменные экземпляра), а в объекте который описывает ваш класс при этом на каждой JVM такой объект существует в единственном экземпляре. С переменными объявленными как static можно делать все то же что и с обычными переменными при этом для доступа к таким переменным ненужно (но можно получить доступ и через переменную экземпляра) создавать экземпляр класса (конечно если переменная имеет модификатор доступа public ), например, создадим класс содержащий статическую переменную:
Получение подступа к статической переменной:
Присваиваем новое значение статической переменной:
Такие переменные следует применять, когда есть необходимость иметь одну переменную на все экземпляры классов или если необходимо использовать переменную в статическом методе (переменные экземпляра в таком методе недоступны так как экземпляров класса может вообще не существовать на момент вызова статического метода).
При использовании модификатора private свойства переменной и «константы» не изменяются, изменяется лишь доступность переменной/константы.
Константы в Java на примерах
«Constant (константа)» – слово в английском языке, относящееся в основном к «ситуации, которая не меняется». Это одна из фундаментальных концепций программирования в Java, и у нее нет каких-либо специальных предпосылок или концепций, которые необходимо знать перед изучением, кроме базовых навыков программирования.
Константы в Java используются, когда необходимо реализовать «статическое» или постоянное значение для переменной. Язык программирования напрямую не поддерживает константы. Чтобы сделать любую переменную ею, мы должны использовать модификаторы static и final.
Синтаксис
- Модификатор static делает переменную доступной без загрузки экземпляра ее определяющего класса.
- Последний модификатор делает переменную неизменной.
Причина, по которой мы должны использовать как статические, так и конечные модификаторы, заключается в том, что:
- Когда мы объявим переменную «var» только как статическую, все объекты одного класса смогут получить доступ к этому ‘var’ и изменить его значения.
- Когда мы объявляем переменную только как final, для каждого отдельного объекта будет создано несколько экземпляров одного и того же значения константы, и это неэффективно / нежелательно.
- Когда мы используем как static, так и final, тогда «var» остается статичным и может быть инициализирован только один раз, что делает его надлежащей константой, которая имеет общую ячейку памяти для всех объектов своего содержащего класса.
Пример
Допустим, нам нужно определить, кто имеет право на получение постоянных водительских прав в группе людей. Мы уже знаем, что минимальный возраст для получения постоянных водительских прав составляет 18 лет.
Поэтому вместо того, чтобы просить пользователя ввести минимальный возраст для сравнения, мы объявляем идентификатор MIN_AGE как постоянное целое число со значением 18.
Зачем нужны?
Константы делают вашу программу более легкой для чтения и понимания, когда ее читают другие. Использование их также повышает производительность, поскольку константы кэшируются как JVM, так и вашим приложением.
Статические и окончательные модификаторы
- Статический модификатор в основном используется для управления памятью.
- Это также позволяет переменной быть доступной без загрузки какого-либо экземпляра класса, в котором она определена.
- Последний модификатор означает, что значение переменной не может измениться. Как только значение назначено переменной, другое значение не может быть переназначено той же переменной.
С помощью модификатора final типы данных Primitive, такие как int, float, char, byte, long, short, double, Boolean, можно сделать неизменяемыми / неизменяемыми. Вместе, как мы поняли ранее, эти модификаторы создают постоянную переменную.
Общий синтаксис
Это соглашение использовать заглавную букву имени переменной, которую мы хотим объявить как константу. Если мы сохраним спецификатор доступа для постоянной переменной как частный, то его значения не могут быть изменены в этом классе.
Если мы оставим спецификатор доступа общедоступным для постоянной переменной, то его значения можно изменить в любом месте программы.
Пример 1
В этом примере мы использовали перечисление как enum Apple
Каждый из них неявно объявлен как публичный статический финальный член Apple. Переменная перечисления может быть создана как другая примитивная переменная. Он не использует «новый» для создания объекта.
‘ap’ имеет тип Apple, единственные значения, которые могут быть назначены (или могут содержать), являются значениями, определенными перечислением.
Например, это назначает
Все перечисления имеют два предопределенных метода: values() и valueOf(). Синтаксис этих встроенных методов:
Метод values() дает массив, который состоит из списка констант перечисления. Метод valueOf() дает константу перечисления, значение которой соответствует строке, переданной в str.
Пример 2
В приведенном выше примере мы использовали два встроенных метода перечисления.