Маленькие хитрости Java
Я уже достаточно много лет занимаюсь разработкой на java и повидал довольно много чужого кода. Как это не странно, но постоянно от одного проекта к другому я вижу одни и те же проблемы. Этот топик — попытка ликбеза в наиболее часто используемых конструкциях языка. Часть описанного — это довольно банальные вещи, тем не менее, как показывает мой опыт, все эти банальности до сих пор актуальны. Надеюсь, статья пригодится многим java программистам. Итак, поехали:
new vs valueOf
+ vs append
Никогда не используйте операции конкатенации (оператор +) строки в цикле, особенно если таких операций у вас много, это может очень существенно снизить производительность. Все это происходит потому, что в приведенном выше примере «s = s + fileds[i]» выполняется целых 3 операции: создается StringBuilder на основе строки s, вызывается метод конкатенации append, после конкатенации вызывается метод toString (выглядит так: s = new StringBuilder(s).append(fields[i]).toString();). Целых 3 операции вместо одной! Помимо этого каждый результат s + fileds[i] будет занимать память в куче, как отдельная строка.
StringBuilder vs StringBuffer
Всегда ипользуйте StringBuilder, кроме случаев, когда вам необходимо использовать конкретно StringBuffer, так как в StringBuilder нету синхронизированных методов в отличие от StringBuffer и следовательно производительность будет выше, хоть и не значительно.
instanceOf
Старайтесь как можно реже использовать оператор instanceOf. Это один из самых медленных java операторов и подходить к его использованию нужно осторожно. Имейте в виду — чаще всего наличие этого оператора в коде означает непонимание принципов ООП, нежели попытка реализовать некий паттерн. Почти всегда полиморфизм способен помочь избавится от этого оператора.
P. S. Многие в комментариях аппелируют к «Это один из самых медленных java операторов». Это действительно так. Конечно, не совсем корректно сравнивать операторы языка по производительности, так как они выполняют абсолютно разные задачи, но, тем не менее, механизм работы instanceOf гораздо сложнее, например, оператора ‘*’.
Generics
Interface for Consts
Очень часто встречаются интерфейсы для описания констант. Это не правильно с точки зрения ООП. Интерфейс должен описывать поведение, не больше не меньше. Этот пункт не очень принципиален, тем более что результат компиляции будет один и тот же, но все же java это ООП язык и было бы хорошо придерживаться его принципов.
Override
Старайтесь использовать Override аннотацию для методов, которые переопределяют методы супер классов. Это позволяет сразу избежать опечаток и повышает читаемость кода (позволяет сразу понять, что у супер класса есть такой же метод не открывая родительский класс).
null vs empty
Всегда старайтесь в методах вашей бизнес логики возвращать пустые коллекции вместо null значений, это избавляет от лишних null-проверок и делает код чище. Для этого в классе Collections есть несколько замечательных методов:
В комментариях просят уточнить вариант применения. Типичный случай:
Конечно, это не значит что эта техника должна быть применена абсолютно везде. Скажем, если Вы сериализируете обьекты, то тут лучше подойдут null значения. Собственно — «в методах вашей бизнес логики» как раз и означает применение в логике, а не в модели.
Преобразование чисел
Ситуация очень схожа с конкатенацией строк.
Что значит new в java
Практически любой, начинающий программировать на языке Java, рано или поздно сталкивается с таким вопросом:
Дан фрагмент программы:
Определить значения st1==st2, st1==st3, st1.equals(st2) и st1.equals(st3) в результате исполнения этого фрагмента.
Этот вопрос кочует из теста в тест, от одного собеседования при приеме на работу к другому, и даже тесты на получение сертификата от компании Sun Microsystems могут включать его в том или ином виде.
1.Простые переменные и ссылочные переменные в языке Java.
Вам, наверняка, приходилось сталкиваться в ходе изучения языка Java с простыми и ссылочными переменными. Иногда у новичков возникает определенная путаница в этом вопросе, так что давайте еще раз повторим, что это такое и когда какие виды переменных создаются.
Допустим, что вы написали в программе:
int a;
a = 10;
При этом компилятор отвел в памяти место, необходимое для хранения данных типа int (рис. 1) и заполнил это место значением 10, присвоенным переменной (рис. 2).
Так создается и используется простая переменная.
Теперь допустим, что вы написали:
String b;
b = Hello;
При этом компилятор не стал в результате первой команды отводить место, необходимое для текста Hello. Вместо этого он отвел место, необходимое для ссылки (указателя) на ЛЮБОЙ текст (рис. 3). Далее это место заполняется ссылкой на текст Hello, который был присвоен переменной (рис. 4). То есть, на самом деле, переменной b был присвоен не сам текст, а ссылка на него.
Так создается и используется ссылочная переменная.
По поводу использования простых и ссылочных переменных в языке Java существует только одно, зато очень важное правило: Java использует простые переменные ТОЛЬКО для при создании одиночных переменных базовых типов (byte, short, int, long, float, double, char, boolean). Во всех остальных случаях создаются ссылочные переменные. То есть, как при создании объектов любых классов, так и при создании массивов используются ссылки. Это правило работает автоматически и не может быть изменено программистом.
2.Оператор == (проверка на равенство).
4.Память, ссылки и константы.
Теперь настало время задать себе вопрос: «А откуда берется слово Hello, изображенное на рисунке 4, или число 10, изображенное на рисунке 2, во время исполнения программы?» Естественно, не из воздуха. И текст «Hello», и число 10 в приведенных примерах, равно как и другие константы, находятся где-то в памяти компьютера. Детальное описание распределения памяти для нас сейчас не важно.
А что же тогда представляет из себя ссылка, помещаемая в ссылочную переменную b на рис. 4? Просто указатель на область в памяти, где хранится слово «Hello».
А теперь представим себе, что происходит, когда мы используем одну и ту же константу несколько раз в нашей программе. Можно, конечно, каждый раз выделять соответствующий кусочек памяти и хранить одну и ту же константу много раз, но это неэффективно. Все равно, никакой возможности изменить в ходе работы программы содержимое памяти, где лежит константа, нет, это ведь константа! Поэтому компилятор отводит место под константу один раз, а дальше она используется по мере необходимости.
Оператор new в языке Java всегда создает новый объект и возвращает ссылку на этот объект.
Вот мы и подошли к решению приведенной в начале задачи. Давайте пройдем по строчкам кода и представим себе, что при этом творится в памяти.
Рис. 5. В этот момент в памяти отведено место под строчку «Hello», создана переменная st1 и в эту переменную помещена ссылка на строчку.
Рис. 6. Здесь мы вторично используем ту же самую строку «Hello». Как уже говорилось выше, вторично место под константу не отводится, используется та же самая константа. Таким образом, в двух переменных, st1 и st2 лежат ссылки на одну и ту же строку.
String st3 = new String(Hello); // 3
Рис.7
Рис. 7. Здесь, как мы видим, использован оператор new, который всегда создает новый объект. В данном случае создается объект класса строка, и при его создании конструктору передается константа Hello в качестве параметра. Конструктор создает новый объект, используя для его инициализации все ту же константу, однако, возвращаемая оператором new ссылка на новый объект.
Теперь, с помощью последнего рисунка, мы легко ответим на вопрос задания.
st1==st3 сравнивает значения ссылочных переменных st1 и st3. В них лежат ссылки на разные области памяти, и при этом абсолютно не важно, что в этих областях размещается одинаковый текст. Текст оператор не проверяет, он проверяет содержимое переменных. Как мы видим, содержимое переменных разное, а значит, результат будет false.
st1.equals(st2) сравнивает содержимое объектов, адресуемых переменными st1 и st2. В данном случае это один и тот же объект, так что, естественно, содержимое совпадает, а следовательно, результат будет true.
st1.equals(st3) сравнивает содержимое объектов, адресуемых переменными st1 и st3. Хотя, в отличие от предыдущего случая, объекты эти разные, их содержимое совпадает, а следовательно, результат опять будет true.
Как объявить переменную в Java? Инициализация переменной в Java. Константы в Java
В этой статье мы рассмотрим, что такое Java-переменные, что значит инициализация переменных, а также как объявлять константу и зачем вообще нужны переменные и константы в Java.
Переменная — это контейнер, содержащий какое-либо значение. При этом под переменным значением понимают строковое, числовое или логическое значение. Само определение говорит нам о том, что переменная может изменяться по ходу выполнения программы. А вот если у нас задана константа, то это значение меняться не может. Но давайте обо всём по порядку.
Виды переменных в Java
Существуют следующие типы переменных в Java: 1) примитивные (целые — byte, short, char, int, long; дробные или с плавающей точкой — float, double, логические — boolean); 2) ссылочные (создаются с применением конструкторов классов и нужны для доступа к объектам).
Так как Java является строго типизированным языком программирования, каждая переменная, объявляемая разработчиком, должна иметь связанный с переменным значением тип данных.
Как объявлять переменные в Java?
Перед использованием переменной нужно её объявить. Для объявления переменной в Java используют следующий синтаксис:
Идём дальше: если нужно объявить больше чем одну переменную указанного типа, допускается применение списка с запятыми:
Инициализация переменной
Перед использованием переменной, нужно задать ей начальное значение. Этот процесс называется инициализация. Без инициализации мы можем получить ошибку во время выполнения программы, поэтому инициализация очень важна. Для инициализации переменной используют оператор присваивания. Слева указывается имя переменной, справа её значение.
Вот пример инициализации:
Ниже посмотрим другие примеры инициализации и объявления переменных в Java:
Типы переменных в Java
Теперь давайте рассмотрим их подробнее.
Локальные переменные в Java
Пример локальных переменных
В итоге мы получим следующий результат:
Пример локальных переменных без инициализации
Мы уже говорили о том, что переменная без инициализации приведёт к ошибке компиляции и упоминали о важности такой процедуры, как инициализация. Давайте чуть-чуть изменим код и попробуем выполнить нашу программу без инициализации переменной «age»:
Запустив компиляцию без инициализации, мы увидим следующую ошибку:
Пожалуй, об инициализации уже поговорили достаточно. Идём дальше.
Переменные экземпляра
Результат работы нашей программы следующий:
Рассмотрение переменных класса (статических переменных в Java) выходит за рамки нашей статьи. Давайте лучше поговорим о том, что такое константа и зачем нужны константы в Java.
Для чего используются константы?
Константы применяются в Java для хранения данных. Константа отличается от переменной. Главное отличие в том, что при использовании константы мы можем присвоить значение лишь один раз.
В остальном константа объявляется так же, как и переменная. Правда, в случае использования константы сначала идёт ключевое слово final:
Как правило, при записи имени константы применяют верхний регистр.
Константы позволяют задать переменные, которые больше не должны меняться. Допустим, у нас существует переменная для хранения числа «пи». При инициализации мы можем сразу же объявить, что она константа, ведь её значение постоянно.
На этом пока всё. Если хотите знать больше, чем объявление, инициализация и использование переменной, записывайтесь на курс «Разработчик Java». Здесь вы получите навыки разработки серверных приложений, овладеете низкоуровневыми и высокоуровневыми подходами к созданию многопоточных и многопроцессных приложений и много чего ещё.
10 главных конструкций языка Java
Простой и мощный язык.
Java — важный язык разработки во многих больших корпорациях. Мы уже рассказывали про то, как и где применяется Java, теперь настало время для практики.
Так как авторы языка Java при создании вдохновлялись языками C и C++, то в Java тоже появилось много похожих конструкций и команд. Если вы знаете C или C++, то освоить Java вам будет гораздо проще.
👉 В Java после каждой команды ставится точка с запятой.
Комментарии
Комментарии в Java точно такие же, как в C-подобных языках — есть однострочные, которые работают только для одной строки, и многострочные.
// Это однострочный комментарий
// Для каждой строки нужно добавлять его отдельно
/* А это — многострочный
его можно сделать любой длины,
если в начале и в конце поставить нужные символы */
Переменные и типы данных
Как и в C, в Java есть несколько типов данных с разным объёмом выделяемой памяти. Предполагается, что программист сам решит, какой тип использовать лучше всего в каждой ситуации и сам будет следить за тем, чтобы в переменную поместилось всё что нужно.
Присваивание и сравнение
// это присваивание
x = 10;
// а это — сравнение x и 10
// результат сравнения отправляется в переменную b
boolean bol;
b = (x == 10);
Структура программы
Разработчикам Java понравилось, что в C вся программа состоит из функций, среди которых есть одна обязательная — main, поэтому сделали точно так же. В классах эта функция называется методом.
Но есть одно важное отличие: каждая java-программа — это как бы один большой класс со своими разделами, которые должны быть у каждого класса. Благодаря этому большие программы легко собираются из маленьких java-кирпичиков и работают друг с другом как с классами, используя все их возможности.
Ввод и вывод
Для ввода и вывода используют системный класс System и два его объекта — in и out. Но на практике чаще всего вместо in используют объект Scanner, чтобы можно было более гибко управлять вводом данных.
Условные операторы if и switch
Работают так же, как в C и в любых современных языках высокого уровня. Главное здесь — следить за фигурными скобками и не перепутать, что к чему относится. Проще всего это регулировать отступами:
У оператора множественного выбора есть особенность: ему не нужны фигурные скобки для действий в каждом случае. Компьютер по синтаксису понимает, что к чему относится, и выбирает нужный вариант.
Циклы
В Java есть три основных вида циклов:
Ещё есть два полезных оператора:
Функции (они же методы)
Так как каждая программа — это описание какого-то класса, то функции в Java — это и есть методы этого класса. Функций (или методов) может быть сколько угодно, главное — соблюдать правила описания классов. Покажем на примере:
Классы
В Java всё построено на классах, от самой программы до реализаций различных функций. Конечно, можно не использовать классы и работать в чисто процедурном стиле, но в Java так не принято. Это ООП-язык с родной поддержкой классов на всех уровнях.
Сами классы объявляются и используются так же, как и в любом другом ООП-языке:
Объекты
Объекты в Java работают по тому же принципу, что и все объекты в ООП: можно создавать сколько угодно объектов на основе классов и делать их любой сложности.
Обычно используют классы, прописанные в том же файле, что и программа. Если нужно использовать класс из другой программы, её подключают отдельно. Вот самый простой способ сделать объект на основе предыдущего класса с заказом:
Java 16 — новые синтаксические возможности языка
Записи (Records). JEP 395
Традиционные классы в Java довольно перегружены деталями, особенно если речь идет о POJO классах, являющихся простыми неизменяемыми (immutable) агрегатами данных. Такой класс, оформленный по правилам, содержит большое количество не очень ценного и повторяющегося кода, такого как конструкторы, методы чтения полей, методы equals(), hashCode() и toString(). Например, взгляните на класс Point, предназначенный для хранения координат на плоскости:
Объявление записи состоит из имени, опциональных параметров типа, заголовка и тела класса. Заголовок состоит из компонентов класса, которые являются переменными, формирующими его состояние, например:
Для записей многие стандартные вещи генерируются автоматически:
Для каждого компонента из заголовка генерируется финальное приватное поле и метод чтения. Обратите внимание, что методы чтения именуются не стандартным для Java способом. Например, для атрибута x из класса Point метод чтения называется x(), а не getX().
Публичный конструктор с сигнатурой, совпадающей с заголовком класса, который инициализирует каждое поле значением, переданным при создании объекта (канонический конструктор).
Методы equals() и hashCode(), которые гарантируют, что 2 записи «равны», если они одного типа и имеют одинаковые значения соответствующих полей.
Канонический конструктор можно определить явно, при этом список параметров конструктора должен быть идентичным заголовку записи, например:
На записи накладываются некоторые ограничения:
Записи не могут наследоваться от других классов. Родительским классом для записи всегда является java.lang.Record. Это связано с тем, что иначе они имели бы унаследованное состояние, помимо состояния описанного в заголовке.
Классы записей являются финальными и не могут быть абстрактными.
Поля записей являются финальными.
Нельзя добавлять поля и блоки инициализации экземпляра.
Разрешается переопределять генерируемые методы, но тип возвращаемого значения должен в точности совпадать с типом значения генерируемого метода.
Нельзя добавлять нативные методы.
В остальном записи являются обычными классами:
Записи могут быть верхнеуровневыми или вложенными, могут быть параметризованными.
Записи могут иметь статические методы, поля и инициализаторы, а также методы экземпляра.
Записи могут реализовывать интерфейсы.
Записи могут иметь вложенные типы, в том числе и вложенные записи. Вложенные записи являются статическими по умолчанию, иначе они имели бы доступ к состоянию родительского объекта.
Класс записи и компоненты его заголовка могут быть декорированы аннотациями. Аннотации компонентов затем переносятся на поля, методы и параметры конструктора в зависимости от типа аннотации. Аннотации типов на типах компонентов также переносятся в места использования этих типов.
Объекты записей можно сериализовать и десериализовать, однако процесс сериaлизации/десериализации нельзя настраивать writeObject(), readObject(), readObjectNoData(), writeExternal(), readExternal().
Статические члены внутренних классов
Как известно внутренние классы в Java не могут иметь статических членов. Это значило бы, что внутренний класс не мог бы иметь записей. Это ограничение было ослаблено, проверил на следующем примере:
Текстовые блоки. JEP 378
Традиционно, задавать в Java многострочный текст было не очень удобно:
Теперь это можно сделать так:
можно представить в виде:
Также появилась новая escape-последовательность \s, которая транслируется в единичный пробел (\u0020). Поскольку escape-последовательности транслируются после удаления пробелов в начале и конце строки, её можно использовать как барьер, чтобы помешать удалению пробелов. Например, в примере ниже последовательность \s используется, чтобы сделать каждую строку длиной ровно 6 символов:
Паттерны для instanceof (Pattern Matching for instanceof). JEP 394
Практически в каждой программе встречается код вида:
Проблема этого кода в том, что он излишне многословен. Понятно, что после проверки типа, мы захотим привести объект к нему. Почему бы не сделать это автоматически? Для упрощения этой процедуры и были введены паттерны в оператор instanceof:
Область видимости переменной s может быть как внутри блока if (как в примере выше), так и за его пределами, например:
Переменную паттерна можно использовать и в выражении оператора if:
Однако такой пример приведет к ошибке компиляции:
Переменные из паттерна могут затенять поля класса, следует быть внимательным при именовании и использовании переменных:
Изолированные типы (Sealed Classes). JEP 397
Изолированные классы и интерфейсы могут быть расширены и реализованы только теми классами и интерфейсами, которым это разрешено. Это позволяет передать компилятору знания о том, что существует ограниченная иерархия каких-либо классов. Для объявления изолированных типов используется модификатор sealed. Затем, после ключевых слов extends и implements идет ключевое слово permits, после которого перечисляются классы, которым разрешено расширять или реализовывать данный класс/интерфейс. Взглянем на пример:
Классы, перечисленные после ключевого слова permits должны находиться рядом с родительским классом: в том же модуле или пакете. Если они малы и их не так много, их можно разместить в одном файле с родительским классом, в этом случае ключевое слово permits можно опустить. Каждый дочерний класс должен быть прямым наследником изолированного класса. Каждый дочерний класс должен использовать один из трех модификаторов:
Модификатор final, если иерархия типов не должна расширяться далее.
Модификатор sealed, если иерархия типов может расширяться далее, но в ограниченном ключе.
Модификатор non-sealed, если эта часть иерархии может расширяться произвольным образом.
Поскольку компилятор теперь обладает знанием того, что иерархия классов ограничена, это должно позволять нам перебирать типы объекта изолированного класса следующим образом:
Однако, мне так и не удалось заставить такой код работать (возможно, потому что это все еще превью реализация):
UPD: как выяснилось в комментариях, ожидание анализа на exhaustiveness в цепочках if-else появилось в результате ошибочного понимания объяснения в JEP.
Switch выражения (Switch Expressions). JEP 361
Использование оператора switch чревато ошибками из-за его сквозной семантики. Взгляните на пример:
Из-за большого количества ключевых слов break легко запутаться и пропустить его где-то.
Кроме того, очень часто оператор switch используется для эмуляции switch выражения, но это не удобно и тоже чревато ошибками:
Теперь рассмотрим пример switch выражения:
Заключение
В данной статье мы рассмотрели новые синтаксические возможности Java 16: записи, текстовые блоки, паттерны для instanceof, изолированные типы и switch выражения. Стоит отметить, что изолированные типы все еще находятся на стадии preview, а потому в Java 17 могут и не войти.
