Что это в java
Перейти к содержимому

Что это в java

  • автор:

Java/Основные понятия

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

Класс [ править ]

Класс есть ключевое понятие в объектно-ориентированном программировании, под которое и заточена Java. Класс описывает содержание и поведение некой совокупности данных и действий над этими данными. Объявление класса производится с помощью ключевого слова class . Пример: class < имя_класса > < // содержимое класса >.

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

Наследование [ править ]

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

Объект [ править ]

Object — это экземпляр класса. В нашем примере это может быть какая-то конкретная комната с конкретными размерами, причем количество комнат не ограничено. Предположим, у нас есть два экземпляра комнат: спальня и кабинет. Теперь мы можем, совершенно не зная, с какой комнатой имеем дело, узнать ее объем, т.к. вычисление объема — это свойство, которое работает для любой комнаты.

Интерфейс [ править ]

Interface описывает предполагаемое поведение класса, не упоминая конкретных действий. Создаётся интерфейс с помощью ключевого слова interface ( interface ). Для того чтобы унаследовать (реализовать) классом интерфейс, используется ключевое слово implements ( class implements ).А между собой интерфейсы унаследуются всё тем же словом extends . Для нашего примера можно создать интерфейс Объемный, в котором будет сказано, что класс, поддерживающий данный интерфейс, должен уметь возвращать объем. В таком случае мы можем сказать, что и Комната, и Ящик поддерживают интерфейс Объемный

Ссылка [ править ]

В других языках программирования существует несколько способов ссылаться на объекты. В Java же есть только один тип ссылок, поэтому все, что нужно знать — это то, что если у нас в руках есть ссылка на объект, это то же самое, что у нас в руках есть этот объект. В то же время, если мы добавляем ссылку на объект, то этот объект остается неизменным и не копируется в памяти.

От абстракции к программированию [ править ]

Теперь давайте попробуем записать пример с комнатами на языке Java. Сначала создадим интерфейс.

interface Capacity  public double getCapacity(); //Заметим, что у метода пока нет тела > 

Класс Room и Box поддерживают интерфейс Capacity и могут выглядеть так:

class Room implements Capacity  public double width; public double height; public double length; public Box inner; //ссылка @Override public double getCapacity()  return width * height * length; > > class Box implements Capacity  public double width; public double height; public double length; @Override public double getCapacity()  return width * height * length; > > 

Не будем пока обращать внимания на слово public , об этом мы поговорим позже в разделе Область видимости. А обратим внимание на то, что оба класса как две капли воды похожи друг на друга. Давайте вынесем одинаковую функциональность в общий класс-предок с названием Base :

class Base implements Capacity  public double width; public double height; public double length; @Override public double getCapacity()  return width * height * length; > > class Box extends Base  > class Room extends Base  > 

Допустим, что в любой комнате обязательно находится один объект определенного объёма и объем комнаты не включает объема данного объекта. Тогда класс Room будет выглядеть так:

class Room extends Base  public Box inner; @Override public double getCapacity()  return super.getCapacity() - inner.getCapacity(); > > 

Обратите внимание, что мы перезаписали метод getCapacity (строки 4-7) и теперь объем комнаты не включает объема внутреннего объекта.

Ну вот и пришло время проверить все то, что мы написали. Для проверки создадим еще один класс.

class Test  public static void main(String[] args)  Box box1 = new Box(); box1.width = 1.0; box1.height = 2.0; box1.length = 3.0; Room workRoom = new Room(); workRoom.width = 10.0; workRoom.height = 20.0; workRoom.length = 30.0; workRoom.inner = box1; System.out.println("Объем ящика : " + box1.getCapacity()); System.out.println("Объем комнаты : " + workRoom.getCapacity()); > > 

C:\>java Test
Объем ящика : 6.0
Объем комнаты : 5994.0
C:\>_

Логические операторы в Java

Знакомимся с каждым, узнаём про короткую и полную схемы вычислений. Проводим побитовые операции с целыми числами. Всё закрепляем на примерах.

Артём Авдеев

Артём Авдеев
Java-разработчик, преподаёт в Skillbox, осваивает машинное обучение.

Логические операции в Java возвращают значение типа boolean: true или false («правда» или «ложь»). Подробнее о булевом типе мы говорили здесь.

В языке Java есть шесть логических операторов. Первые четыре представлены в таблице ниже.

Логический оператор Обозначение в Java Выражение Результат
«И» (AND): конъюнкция, логическое умножение && true && true

Где нужны логические операторы

Если коротко, то в условных выражениях, которые могут включать в себя и операторы сравнения (, >, , >=, ==, !=). При вычислении они возвращают значение булева типа.

Условные выражения, в свою очередь, применяются в операторах ветвления (if-else, switch, тернарном). Подробнее об этих операторах тут.

Как применять

Допустим, мы хотим проверить, что значение переменной a больше значений в переменных b и c. То есть сравнить операнд a с двумя другими. Нам поможет логический оператор && (И).

Логический оператор && (И) возвращает true, если слева и справа от него стоят значения true, а иначе — false.

Иными словами, если оба логических высказывания истинны, то и операция && (И) возвращает истину.

int a = 6; int b = 3; int c = 4; boolean d = (a > b) && (a > c); System.out.println(d); --OUTPUT> true

Как вычисляется значение выражения (a > b) && (a > c):

Сначала проверяется условие (a > b). Оно вернёт true, так как 6 больше 4. Далее проверяется условие (a > c), которое также вернёт true, ведь 6 больше 3.

Теперь у нас с двух сторон от логического оператора && стоят значения true.

По определению выше или по таблице ещё выше, результат вычисления логического выражения (true && true) равен true.

int a = 6; int b = 4; int c = 7; boolean d = (a > b) && (a > c); System.out.println(d); --OUTPUT> false

Результат операции (a > b) вернёт true, так как 6 больше 4, а операция (a > c) уже вернёт false, так как 6 не больше 7.

Значит, слева от логического оператора && стоит true, а справа — false. Следовательно, результат вычисления логического выражения (мы присвоили его булевой переменной d) будет false.

int a = 4; int b = 5; int c = 6; boolean d = (a > b) && (a > c); System.out.println(d); --OUTPUT> false

Результат операции сравнения (a > b) равен false, а что вернёт операция (a > c), уже значения не имеет (смотрите определение выше) — результат вычисления логического выражения (мы присвоили его булевой переменной d) будет равен false.

Рассмотрим примеры с другими операторами.

OR

int a = 4; int b = 6; int c = 3; boolean d = (a > b) || (a > c); System.out.println(d); --OUTPUT> true

Значение переменной d равно true.

int a = 9; int b = 9; boolean c = a > b || a != b; System.out.println(c); --OUTPUT> false

Теперь вычисляйте вы.

XOR

int a = 5; int b = 6; int c = 7; boolean d = (b > a) ^ (c > a); System.out.println(d); --OUTPUT> false

Значение d равно false.

NOT

int a = 5; int b = 9; boolean d = !(a > b); System.out.println(d); --OUTPUT> true

Значение d стало true.

Полные и сокращённые версии AND и OR

&& и || называются сокращёнными логическими операторами AND и OR соответственно, или операторами короткой схемы вычислений. В спецификации Java их ещё зовут условными. Значения их операндов могут быть только булева типа.

В отличие от двойных, одиночные & и | называются операторами полной схемы вычислений. Значения их операндов могут быть как только булевыми, так и только целочисленными (вместе с оператором ^ они используются в побитовых операциях).

В чём разница

В том, что для операторов & и | всегда вычисляются значения обоих операндов, а при работе операторов && и || второй операнд вычисляется только по необходимости.

То есть иногда результат выражения однозначно определён уже по первому операнду:

  • Если первый операнд && равен false, то второй не вычисляется, так как уже понятно, что результат всего выражения будет false.
  • Если первый операнд || равен true, то второй не вычисляется, так как уже понятно, что || вернёт true.

&& и || используют как операторы булевой логики. Они оперируют значениями только булева типа и применяются только в логических выражениях.

Как использовать

&& и || позволяют экономить вычисления (применять короткую схему) и помогают избегать ошибок. Как это делается?

Начнём с оператора &&. Приведём фрагмент из таблицы выше:

Логический оператор Обозначение в Java Выражение Результат
«И» (AND): конъюнкция, логическое умножение && true && true

Рассмотрим выражение: (3 > 4) AND (5 > 4)

Мы видим, что операнд слева от оператора AND равен false. Смотрим на таблицу выше — и понимаем, что вычислять второй операнд бессмысленно, так как оператор AND уже точно вернёт false.

Именно по такой логике и работает оператор короткой схемы вычислений &&. Если выражение слева от него равно false, то выражение справа вычисляться не будет.

Так же и с оператором ||: если выражение слева от него равно true, то выражение справа не вычисляется, так как результат операции || всё равно будет true.

В большинстве случае применяют именно && и ||. При верном использовании они избавляют Java от ненужных вычислений и страхуют от некоторых ошибок.

int a = 3; int b = 0; boolean d = (b != 0) && (a/b > 0); System.out.println(d); --OUTPUT> false

Если вместо оператора && мы используем &, то получим ошибку (исключение) java.lang.ArithmeticException: / by zero:

int a = 3; int b = 0; boolean d = (b != 0) & (a/b > 0); System.out.println(d); —OUTPUT> Exception in thread java.lang.ArithmeticException: / by zero at

Ошибка возникнет тогда, когда Java попытается вычислить второй аргумент логического выражения, если первый равнялся false.

Иными словами, мы узнали, что b равно 0 (выражение b != 0 вернуло false) — и идём делить на b (делить на ноль), вычисляя значение второго операнда (a/b > 0).

public void printStringLengthMoreThenZero(String str) < if (str != null && str.length() > 0) < System.out.println(str.length()); >else < System.out.println("Тут нечего считать!"); > >

Код выше выводит в консоль длину строки str, в которой есть хотя бы один символ. А если строка пуста или её значение равно null (то есть строковая переменная ни на что не указывает), в консоль выводится сообщение: «Тут нечего считать!»

Мы выбрали оператор короткой схемы вычислений && — и это правильно!

А вот если бы вместо этого использовали оператор полной схемы &, то наш код работал бы не так, как надо.

Мы получали бы ошибку NullPointerException каждый раз, когда вызываем метод для строковой переменной со значением null.

Посмотрим, что происходило бы при вычислении условия блока if:

  • str != null & str.length() > 0
  • null != null & str.length() > 0
  • false & str.length() > 0 // тут возникает ошибка

Сперва вычисляется первый аргумент логического выражения, а именно str != null (иными словами, получаем ответ на вопрос «Строковая переменная не равна null?»). Получили false, значит всё же равна.

Дальше Java должна вычислить второй аргумент логического выражения, а именно str.length() > 0 (иными словами — проверяется «Число символов строки > 0?»).

Для этого вызывается метод str.length(), который должен вернуть целое значение. Оно и будет сравниваться с 0. Но у нас-то str равна null (возвращать методу нечего, строки нет). Тут Java и пожалуется на NullPointerException.

Порядок выполнения операторов

Когда в выражении несколько логических операторов, результат вычисляется с учётом их приоритета. Если нет логических скобок, то операции выполняются в таком порядке:

Если одинаковые операции стоят по соседству, то раньше выполняется та, что левее.

boolean a = true ^ true & false; System.out.println(a);

Вычислим true ^ true & false:

  • Выбираем самый приоритетный оператор (если таких больше одного — тот, что левее). У нас самый приоритетный & (он здесь такой один).
  • Смотрим, что слева и справа от него: это true и false соответственно.
  • Вычисляем выражение true & false — получаем false.
  • В исходном выражении заменяем true & false результатом его вычисления (false) — и получаем: true ^ false.
  • Вычислив это выражение, получаем результат true.
boolean a = true ^ true && false; System.out.println(a);

Теперь самый приоритетный оператор в выражении это ^ — и порядок вычислений будет уже другой:

Результат будет false.

Как изменить порядок вычисления

Порядок вычисления логических операторов меняют круглые скобки — так же, как в арифметике:

boolean a = (true ^ true) & false; System.out.println(a); --OUTPUT> false

Добавив круглые скобки, мы поменяли приоритеты для вычисления. Теперь сперва будет определено выражение (true ^ true), которое вернёт false. А после — вычислится выражение false & false, которое тоже вернёт false.

То есть скобки повышают приоритет стоящего внутри выражения, а внутри самих скобок действуют прежние приоритеты.

Пример посложнее — выражение !(true && (false || true)) ^ !false.

Как логические операторы работают с целыми числами

Мы уже знаем, что логические операции применимы к логическим аргументам (операндам). Каждый логический операнд — это выражение, которое является истинным (true) или ложным (false) — то есть возвращает булево значение. Иными словами, логический операнд — это выражение типа boolean.

Выходит, применять логические операторы к целочисленным аргументам нельзя?

Можно. Внутри Java все целочисленные типы представлены двоичными числами разной длины. И к ним уже применимы бинарные логические операторы ^, | и &.

Только в этом случае они работают с двоичным представлением операндов — выполняют операции над их битами попарно (рассматривая их как логические единицы и нули). Поэтому и сами операторы ^, | и & зовутся побитовыми.

Как ^, | и & работают с целочисленными операндами

int a = 3 & 5; int b = 3 | 5; int c = 3 ^ 5; System.out.println(a); System.out.println(b); System.out.println(c); --OUTPUT> 1 --OUTPUT> 7 --OUTPUT> 6

Чтобы повторить вычисления Java, нужно:

  • Перевести значения обоих операндов в двоичную систему счисления.
  • Расположить результаты перевода друг под другом.
  • Сравнять в них число разрядов (дополнить лидирующими нулями).
  • Применить к битам из каждого столбца оператор (&, | или ^).
  • Записать результат каждой операции ниже в том же столбце.
  • Перевести итог в десятичную форму.

Потренируемся: вычислим сами 3 & 5

Число 3 в двоичной системе счисления имеет вид 11, а число 5 — 101.

Так как у числа 5 три разряда в двоичной системе, а у числа 3 — всего два, добавим лидирующий ноль к числу 3 в двоичной системе и получим 011.

Берём цифры из обоих чисел и применяем к ним попарно оператор & (AND):

3(10) = 011(2) 0 1 1
& & &
5(10) = 101(2) 1 0 1
= = =
001(2) = 1(10) 0 0 1

Получаем число 001. В десятичной записи ему соответствует число 1. Поэтому операция 3 & 5 и возвращает в результате 1.

Вычислим 3 | 5

С оператором | действуем так же:

3(10) = 011(2) 0 1 1
| | |
5(10) = 101(2) 1 0 1
= = =
111(2) = 7(10) 1 1 1

Операторы в Java: Понимание, применение и перегрузка

Java разработчик: как стать за месяц?

Java — очень сложно, так говорят… Правда ли это?

7 фактов про Java

Зачем Java разработчикам читать книги по Java

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

Что такое оператор в Java?

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

Общий обзор операторов Java

В Java существует несколько категорий операторов’

  1. Арифметические операторы
    • Сложение, вычитание, умножение, деление и остаток от деления.
    • Примеры использования арифметических операторов в выражениях.
  2. Логические операторы
    • Логическое И, логическое ИЛИ, логическое НЕ.
  3. Операторы присваивания
    • Присваивание значения переменной.
    • Расширенные операторы присваивания, такие как +=, -=, *= и т. д.
  4. Условные операторы
    • Оператор if-else для выполнения кода на основе условий.
    • Оператор switch для проверки различных вариантов значения выражения.
  5. Циклические операторы
    • Операторы for, while и do-while для выполнения повторяющихся действий.

�� Готовы начать свой путь в мире Java с нуля? Java Start — ваш быстрый старт в программировании! ��

�� Курс от Сергея Немчинского:

  • Просто и понятно: Освоим основы Java пошагово.
  • Всего 2-4 недели обучения.

�� Начальные требования: Умение пользоваться компьютером и читать на английском языке.

��‍�� Начните свой путь к карьере в программировании уже сегодня! ��

Перегрузка операторов в Java: Мифы и реальность

Перегрузка операторов — это возможность определения поведения оператора для пользовательских типов данных. В отличие от других языков, таких как C++, Java не позволяет перегружать операторы произвольно. В Java существует несколько операторов, для которых можно сделать перегрузку. Это арифметические операторы (+, -, *, /), операторы сравнения (==, !=, ) и операторы присваивания (=, +=, -= и т. д.).

Перегрузка операторов позволяет программистам создавать более интуитивный и удобный интерфейс для работы с пользовательскими типами данных. Например, если у вас есть класс «Вектор», вы можете перегрузить оператор сложения (+), чтобы объединить два вектора.

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

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

Оператор new в Java: Зачем он нужен и как его использовать?

Оператор `new` в Java используется для создания новых объектов на основе класса или интерфейса. Он выделяет память для объекта и вызывает конструктор класса для его инициализации.

Чтобы использовать оператор `new`, выполните вот эту последовательность действий:

  1. Определите класс или интерфейс, на основе которого вы хотите создать объект.
  2. Используйте оператор `new`, за которым следует вызов конструктора класса, для создания экземпляра объекта.
  3. Присвойте созданный объект переменной для последующего использования.

From Zero to Hero

Используйте скобки, чтобы указать порядок операций и избежать неоднозначности.

Будьте внимательны при использовании оператора деления (/) с целыми числами, так как он возвращает частное в виде целого числа без округления.

```java int result = 10 / 3; // Результат: 3 ```

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

```java double result = 10.0 / 3; // Результат: 3.3333333333333335 ```

Также будьте осторожны при использовании оператора деления и остатка от деления с отрицательными числами. Результат может не соответствовать вашим ожиданиям. Например:

```java int result1 = -10 / 3; // Результат: -3 int result2 = -10 % 3; // Результат: -1 ```

Операторы сравнения в Java: Как они работают?

Операторы сравнения в Java используются для сравнения значений и определения их отношения. Результатом сравнения является логическое значение `true` или `false`. Вот некоторые операторы сравнения и их использование:

1. Оператор равенства (==)

Сравнивает два операнда на равенство.

```java int x = 5; int y = 7; boolean isEqual = (x == y); // Результат: false ```

2. Оператор неравенства (!=)

Сравнивает два операнда на неравенство.

```java int x = 5; int y = 7; boolean isNotEqual = (x != y); // Результат: true ```

3. Оператор больше (>)

Проверяет, является ли левый операнд больше правого.

```java int x = 5; int y = 7; boolean isGreater = (x > y); // Результат: false ```

По такому же принципу работает оператор меньше (<).

4. Оператор больше или равно (>=)

Проверяет, является ли левый операнд больше или равным правому.

```java int x = 5; int y = 7; boolean isGreaterOrEqual = (x >= y); // Результат: false ```

По такому же принципу работает оператор меньше или равно (<=).

Важно помнить, что операторы сравнения возвращают логическое значение `true` или `false` в зависимости от результата сравнения. Они часто используются в условных выражениях для принятия решений в программе.

Операторы сравнения могут применяться не только к числовым типам данных, но и к символам, строкам и другим типам, которые поддерживают операции сравнения.

Операторы присваивания в Java: От основ к хитростям

Операторы присваивания в Java используются для присвоения значения одной переменной другой переменной или выражению. Рассмотрим некоторые основные операторы присваивания:

1. Оператор присваивания (=)

Присваивает значение правого операнда левому операнду.

```java int x = 5; int y = x; // Значение x присваивается переменной y ```

2. Оператор присваивания с добавлением (+=)

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

```java int x = 5; x += 3; // Результат: x = x + 3, x становится равным 8 ```

По такому же принципу работает оператор присваивания с вычитанием (-=).

3. Оператор присваивания с умножением (*=):

Умножает левый операнд на правый операнд и присваивает результат левому операнду.

```java int x = 5; x *= 4; // Результат: x = x * 4, x становится равным 20 ```

По такому же принципу работает оператор присваивания с делением (/=):

Операторы присваивания могут быть комбинированы с различными арифметическими операторами для выполнения нужных операций.

Кроме основных операторов присваивания, существуют и более сложные операторы присваивания, такие как операторы побитового сдвига (>=), операторы побитового И (&=), операторы побитового ИЛИ (|=) и другие. Эти операторы позволяют выполнять битовые операции и одновременно присваивать результат.

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

Операторы инкремента и декремента в Java: что это такое и как их использовать

Операторы инкремента (`++`) и декремента (`—`) в Java используются для увеличения или уменьшения значения переменной на 1 соответственно. Они могут быть применены как к числовым типам данных, так и к типу `char` (для инкремента) и `byte`, `short`, `int`, `long`, `float`, `double` (для обоих операторов).

�� Подпишись на наш Ютуб-канал! ��Полезные видео для программистов уже ждут тебя!

�� Выбери свой курс программирования! �� Путь к карьере программиста начинается здесь!

Кофе-брейк #180. Переменные в Java: что это такое и как они используются. 5 вещей, которые вы должны знать о сериализации и десериализации в Java

Java-университет

Переменные в Java: что это такое и как они используются

Кофе-брейк #180. Переменные в Java: что это такое и как они используются. 5 вещей, которые вы должны знать о сериализации и десериализации в Java - 1

Источник: Hackernoon В Java существует четыре различных типа переменных, в зависимости от того, где они объявлены в программе. Сегодня вы узнаете примеры и отличия каждого типа. 1. Переменные экземпляра (Instance variables) или поля экземпляра (Instance fields) — это переменные, объявленные внутри класса без ключевого слова static , но вне метода, конструктора или блока кода. Такие переменные могут быть объявлены в любом месте внутри класса. Вы можете объявить их с модификатором доступа или без него, например, public , private , protected или default (не ключевое слово).

 public class MyClass < //instance field 1 private String instanceField1; public MyClass()<>//Constructor //instance field 2 public int anotherInstanceField2; public void setInstanceField(String parameterVariable) //instance method //instance field 3 boolean instanceField3; public static void main(String[] args) < System.out.println("field 1 value: " + instanceField1); // = null System.out.println("field 2 value: " + anotherInstanceField2); // = 0 System.out.println("field 3 value: " + instanceField3); // = 0 >> 

Если полю экземпляра не присваивается значение во время объявления, то ему присваивается значение по умолчанию, равное нулю, если это примитивный тип, например ( int , boolean , long , float ), или null , если это не примитивный тип, например ( String , Integer , AnyClass ). Они называются полями или переменными экземпляра, потому что они принадлежат экземпляру любого объекта, созданного из класса, в котором они объявлены.

 public Main < public static void main(String[] args) < MyClass obj1 = new MyClass(); MyClass obj2 = new MyClass(); //Now we can access every 'public' field declared in the MyClass class // from the newly created object 'obj' obj1.anotherInstanceField2 = 11; obj2.anotherInstanceField2 = 33; System.out.println(obj1.anotherInstanceField2); // prints '11' System.out.println(obj2.anotherInstanceField2); // prints '33' >> 

Таким образом, каждое поле экземпляра уникально для своего объекта, как видно из приведенного выше фрагмента. В нем obj1 и obj2 имеют уникальные значения, присвоенные их соответствующим полям экземпляра. 2. Поля класса (Class fields) или статические поля (static fields) — это поля, объявленные с ключевым словом static . Они объявляются внутри класса, но вне метода, конструктора или блока кода. Они также могут быть объявлены в любой позиции внутри класса с модификатором доступа или без него, например, public , private , protected или default (не ключевое слово).

 public class MyClass < //static field public static String staticField; public MyClass()<>//Constructor > class Main < public static void main(String[] args) < MyClass obj = new MyClass(); obj.staticField //will throw Not defined Error //Now we cannot access the static field declared in MyClass class from the // newly created object 'obj' because static fields are not attached to any // object. They belong solely to the class they are declared and can only be // accessed from their class. MyClass.staticField = "I am a static field"; System.out.println(MyClass.staticField); // prints 'I am a static field' >> 

Доступ к статическим полям возможен только через их классы, а не из какого-либо объекта, как показано во фрагменте кода выше. 3. Параметры (Parameters) или переменные-аргументы (Argument variables) — это переменные, объявленные внутри конструкции метода между открывающимися и и закрывающимися фигурными скобками сигнатуры метода. Они используются для передачи значений или объектов в метод.

 public class MyClass < //instance field public String instanceField; public MyClass()<>//Constructor //instance method with a parameter variable public void setInstanceField(String parameterVariable) < instanceField = parameterVariable; >> class Main < public static void main(String[] args) < MyClass obj = new MyClass(); obj.setInstanceField("From a parameter variable"); System.out.println(obj.instanceField); // prints 'From a parameter variable' >> 

4. Локальные переменные (Local variables) — это переменные, объявленные внутри метода или любого блока кода, например, внутри блока операторов if , for loop , while loop , блока операторов switch и так далее.

 public Main < public static void main(String[] args) < MyClass obj1 = new MyClass(); // 'obj1' is local reference variable int // 'name' is a local variable here. if (id >1) < String tempName = "Austin"; // 'tempName' is a local reference variable >> > 

В данном коде можно заметить использование reference с некоторыми переменными, в то время как локальная переменная id не упоминалась, как ссылочная переменная. Любая непримитивная переменная является ссылочной переменной. Например, obj1 — это переменная типа MyClass , а tempName — это переменная типа String , и здесь оба типа не являются примитивными типами. При этом id — это переменная типа int , которая является примитивным типом данных. Следовательно, это нессылочная переменная.

5 вещей, которые вы должны знать о сериализации и десериализации в Java

Источник: Devgenius Благодаря этому руководству вы улучшите свои знания о работе сериализации и десериализации. Сериализация в Java помогает преобразовать существующий объект в поток байтов. И наоборот, десериализация делает поток байтов объектом. Используя сериализацию и десериализацию в Java, информацию об объектах можно переносить с одной JVM на другую.

#1 Сериализация

Прежде чем приступить к подробному описанию, давайте обратим внимание на классы SerializeUtils.java и Person.java . Здесь они нам помогут выполнить сериализацию и десериализацию на конкретных примерах.

SerializeUtils.java
 package com.techteam.serialization; import java.io.*; public class SerializeUtils < public static void serialize(T input, String fileName) throws IOException < FileOutputStream file = new FileOutputStream(fileName); ObjectOutputStream out = new ObjectOutputStream(file); out.writeObject(input); out.close(); file.close(); >public static T deserialize(String fileName) throws IOException, ClassNotFoundException < FileInputStream file = new FileInputStream(fileName); ObjectInputStream in = new ObjectInputStream(file); T result = (T) in.readObject(); return result; >public static void externalSeialize(Externalizable e, String fileName) throws IOException < FileOutputStream file = new FileOutputStream(fileName); ObjectOutputStream out = new ObjectOutputStream(file); e.writeExternal(out); out.close(); file.close(); >public static void externalDeseialize(Externalizable e, String fileName) throws IOException, ClassNotFoundException < FileInputStream file = new FileInputStream (fileName); ObjectInputStream in = new ObjectInputStream (file); e.readExternal(in); in.close(); file.close(); >> 
Person.java
 package com.techteam.serialization; import java.io.Serializable; public class Person implements Serializable < private static final long serialVersionUID = 1L; private int id; private String name; private int age; public int getId() < return id; >public void setId(int id) < this.id = id; >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; >> 

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

 package com.techteam.serialization; import java.io.IOException; public class SerializationMain < public static void main(String[] args) throws IOException < Person p = new Person(); p.setId(1); p.setName("Tech team members"); p.setAge(20); SerializeUtils.serialize(p, "/person.txt"); >> 

Кофе-брейк #180. Переменные в Java: что это такое и как они используются. 5 вещей, которые вы должны знать о сериализации и десериализации в Java - 2

После процесса сериализации у нас есть файл с таким содержимым:

#2 Десериализация

Если в предыдущем примере мы создали поток байтов посредством сериализации объекта, то теперь давайте посмотрим, как мы вернемся к объекту, используя десериализацию:

 package com.techteam.serialization; import java.io.IOException; public class DeserializationMain < public static void main(String[] args) throws IOException, ClassNotFoundException < Person p = SerializeUtils.deserialize("/person.txt"); System.out.println("Person data:"); System.out.println(p.getId()); System.out.println(p.getName()); System.out.println(p.getAge()); >> 

Кофе-брейк #180. Переменные в Java: что это такое и как они используются. 5 вещей, которые вы должны знать о сериализации и десериализации в Java - 3

Вот данные после процесса десериализации:

#3 Serial Version UID

Кофе-брейк #180. Переменные в Java: что это такое и как они используются. 5 вещей, которые вы должны знать о сериализации и десериализации в Java - 4

SerialVersionUID означает уникальный идентификационный номер для каждой версии процесса сериализации и десериализации. Этот номер используется, чтобы убедиться, что и сериализованные, и десериализованные объекты используют совместимые классы. Для Person.java я хотел бы увеличить serialVersionUID до 2. Давайте посмотрим на вывод после десериализации файла person.txt.

#4 Ключевое слово Transient

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

 package com.techteam.serialization; import java.io.IOException; import java.io.Serializable; public class PersonWithTransient implements Serializable < private static final long serialVersionUID = 1L; private int id; private String name; private transient int age; public int getId() < return id; >public void setId(int id) < this.id = id; >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 static void main(String[] args) throws IOException, ClassNotFoundException < PersonWithTransient p = new PersonWithTransient(); p.setId(2); p.setName("Tech team members(transient)"); p.setAge(50); SerializeUtils.serialize(p, "/person_transient.txt"); PersonWithTransient deserializeP = SerializeUtils.deserialize("/person_transient.txt"); System.out.println("Person without transient data:"); System.out.println(deserializeP.getId()); System.out.println(deserializeP.getName()); System.out.println(deserializeP.getAge()); >> 

В приведенном выше коде мы использовали ключевое слово transient для переменной age . И вот что у нас получилось после процесса сериализации и десериализации.

#5 Внешний интерфейс (Externalizable Interface)

В Java, когда мы хотим настроить процесс сериализации и десериализации, мы можем использовать переходный процесс, чтобы игнорировать переменные, которые нам не нужны для процесса сериализации и десериализации. Еще один способ упростить и повысить производительность — использовать интерфейс Externalizable вместо интерфейса Serializable . Давайте посмотрим на пример:

 package com.techteam.serialization; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; public class PersonExternalizable implements Externalizable < private static final long serialVersionUID = 1L; private int id; private String name; private int age; public int getId() < return id; >public void setId(int id) < this.id = id; >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; >@Override public void writeExternal(ObjectOutput out) throws IOException < out.writeUTF(this.name); out.writeInt(this.age); >@Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException < this.name = in.readUTF(); this.age = in.readInt(); >public static void main(String[] args) throws IOException, ClassNotFoundException < PersonExternalizable p = new PersonExternalizable(); p.setId(3); p.setName("Tech team members(Externalizable)"); p.setAge(30); SerializeUtils.externalSeialize(p, "/person_externalizable.txt"); PersonExternalizable deserializeP = new PersonExternalizable(); SerializeUtils.externalDeseialize(deserializeP, "/person_externalizable.txt"); System.out.println("Person data:"); System.out.println(deserializeP.getId()); System.out.println(deserializeP.getName()); System.out.println(deserializeP.getAge()); >> 

Кофе-брейк #180. Переменные в Java: что это такое и как они используются. 5 вещей, которые вы должны знать о сериализации и десериализации в Java - 5

Как видите, при использовании Externalizable мы можем легко написать пользовательскую логику, игнорировать переменные и получить более высокую производительность, чем при использовании Serializable . Теперь давайте посмотрим на вывод:

Заключение

Надеюсь, что благодаря этой статье вы получили ясное представление о том, как сериализация и десериализация работают в Java, а приведенные выше примеры в будущем смогут помочь вам на практике.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *