Операции над переменными структурного типа

ГЛАВА 11. СТРУКТУРЫ

Определение структуры

Операции над переменными структурного типа

Вложенные структуры

Массивы в структурахМассив структур

Структуры и указатели

· Указатели в структуре

· Указатели на структуру

Динамический массив структур

Ссылка на структуру

Структуры и функции

В С++ существуют специальные средства, позволяющие программистам создавать свои собственные типы данных, такие как структуры, классы и др.

Определение структуры

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

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

char name[10]; // поле name

int year; // поле year

int month; // поле month

После того как определён структурный тип, пользоваться этим типом нельзя до того момента, пока не объявлена переменная структурного типа. Это можно сделать двумя способами:

Date st1; // переменная st1 типа Date

struct Date<

При объявлении нескольких структурных переменных для одного структурного типа их следует разделять запятыми:

Datest1, st2;

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

Доступ к полям структуры осуществляется с помощью операции точка (.). При этом сначала записывается имя структурной переменной, а затем через операцию точку (.) имя поля структуры, например:

Присваивать значения полям структуры можно одним из трёх способов:

st1.year = 1999; // использовать оператор присваивания

cin>>st1.name; // ввести значения полей с клавиатуры

Date st1 = <"Иванов", 1999, 11>; // инициализация при объявлении

Операции над переменными структурного типа

Чаще всего над переменными структурного типа выполняют операцию присваивания. Присваивание структур возможно, только если они имеют один и тот же тип:

st2 = st1; // все поля структуры st1 побитово копируются в st2

Недопустимо присваивание структур разных типов, даже в том случае, когда они идентичны по количеству, типу и размеру их полей.

Несмотря на возможность присваивания однотипных структурных переменных, сравнивать их нельзя:

if(st1 == st2) оператор; // Нельзя: ошибка компиляции!

Единственный доступный способ достоверно сравнить структурные переменные – это их поэлементное сравнение:

Источник

Переменные

Переменная — это именованный участок памяти, в котором хранится значение, которое может быть изменено программой. Все переменные перед их использованием должны быть объявлены. Общая форма объявления [1] имеет такой вид:

Здесь тип означает один из базовых или объявленных программистом типов (если необходимо — с одним или несколькими спецификаторами), а список_переменных состоит из одного или более идентификаторов, разделенных запятыми. Ниже приведены примеры объявлений:

Необходимо помнить, что в С имя переменной никогда не определяет ее тип.

Где объявляются переменные

Локальные переменные

Локальные переменные существуют только во время выполнения программного блока, в котором они объявлены, создаются они при входе в блок, а разрушаются — при выходе из него. Более того, переменная, объявленная в одном блоке, не имеет никакого отношения к переменной с тем же именем, объявленной в другом блоке.

Чаще всего блоком программы, в котором объявлены локальные переменные, является функция. Рассмотрим, например, следующие две функции:

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

Из соображений удобства и в силу устоявшейся традиции все локальные переменные функции чаще всего объявляются в самом начале функции, сразу после открывающейся фигурной скобки. Однако можно объявить локальную переменную и внутри блока программы (блок функции — это частный случай блока программы). Например:

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

Объявление переменных внутри блока программы помогает избежать нежелательных побочных эффектов. Переменная не существует вне блока, в котором она объявлена, следовательно, “посторонний” участок программы не сможет случайно изменить ее значение.

Если имена переменных, объявленных во внутреннем и внешнем (по отношению к нему) блоках совпадают, то переменная внутреннего блока “прячет” (т.е. скрывает, делает невидимой) переменную внешнего блока. Рассмотрим следующий пример:

Результат выполнения программы следующий:

В стандарте С89 все локальные переменные должны быть объявлены в начале блока, до любого выполнимого оператора. Например, следующая функция вызовет ошибку компиляции в С89:

Однако в С99 (и в C++) эта функция вполне работоспособна, потому что в них локальная переменная может быть объявлена в любом месте внутри блока до ее первого использования.

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

По умолчанию локальные переменные хранятся в стеке. Стек — динамически изменяющаяся область памяти. Вот почему в общем случае локальные переменные не сохраняют свое значение в период между вызовами функций.

Локальные переменные можно инициализировать каким-либо заранее заданным значением. Это значение будет присвоено переменной каждый раз при входе в тот блок программы, в котором она объявлена. Например, следующая программа напечатает число 10 десять раз:

Формальные параметры функции

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

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

Глобальные переменные

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

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

[2] А в книгах по C++ переменной автоматического класса памяти (т.е. такой, что создается при входе в блок, где она объявлена, и уничтожается при выходе из него).

Источник

Какая операция связывает переменные внутри группы

Следующий слой выразительных средств языка – средства обработки данных. Это – набор элементарных действий (операций) и их сочетаний (выражений), который позволяет изменять значения переменных. К ним относятся:

· традиционные операции над переменными (например, арифметические, логические, поразрядные);

· вызов процедур и функций.

Для начала – немного терминологии:

· операция – элементарное действие по обработке данных (по работе с переменными);

· выражение – элемент синтаксиса с описанием последовательности выполнения операций и их операндов, в котором результат одной операции является операндом другой.

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

· операции разбиты на 16 групп по приоритетам их выполнения;

· большинство операций совместимо по результатам. Это значит, что результат любой операции может быть операндом любой другой операции, то есть их можно комбинировать между собой как угодно, даже в самых «диких» сочетаниях;

· в Си отсутствует понятие логического (булевого) типа «истина-ложь». Для его представления используются значения целой переменной: 0 –«ложь», 1 (или любое отличное от нуля значение) – «истина»;

· в некоторых операциях возможно изменение значений участвующих в ней операндов;

Действие и результат

«Борьбу с пьянством прекратить,

a = b; // Действие над операндом: переменная a получает значение переменной b

// Результат: значение переменной a после присваивания

Наличие в операции результата позволяет использовать ее в контексте (окружении) других операций, например:

c = (a = b) + 5; // Эквивалентно a = b; c = a + 5;

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

a++; // Действие над операндом: переменная a увеличивается нa 1

// Результат: значение переменной до ее увеличения

c = A[i++]; // Эквивалентно c = A[i]; i = i + 1;

Преобразование типов операндов

В выражениях в качестве операндов могут присутствовать переменные и константы разных типов (здесь и далее мы ограничимся пока только известными нам базовыми типами данных). Результат каждой операции также имеет свой определенный тип, который зависит от типов операндов. Если в бинарных операциях типы данных обоих операндов совпадают, то результат будет иметь тот же самый тип. Если нет, то транслятор должен включить в код программы неявные операции, которые преобразуют тип операндов, то есть выполнить приведение типов. Но прежде, чем изучать подробности таких преобразований, ответим на вопрос: «Где они могут происходить»?:

· при выполнении операции присваивания, когда значение переменной или выражения из правой части запоминается в переменной в левой части;

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

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

· преобразование целой переменной в переменную вещественную (с плавающей точкой) и наоборот;

· увеличение или уменьшение разрядности машинного слова, то есть «усечение» или «растягивание» целой переменной;

· преобразование знаковой формы представления целого в беззнаковую и наоборот.

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

Уменьшение разрядности машинного слова всегда происходит путем отсечения старших разрядов числа. Заметим, что это может привести к ошибкам потери значащих цифр и разрядов:

int n=1045; // Во внутреннем представлении n=0x00000415 (1024+16+5)

char c; c = n; // Потеря значащих цифр (0x15)

Увеличение разрядности приводит к появлению дополнительных старших разрядов числа. При этом способ их заполнения зависит от формы представления целого:

· для беззнаковых целых заполнение производится нулями;

· для целых со знаком они заполняются значением знакового (старшего) разряда.

Таким образом, при увеличении размерности целого его значение сохраняется (с учетом формы представления):

char c=0x84; n = c; // Значение n=0xFFFFFF84

unsigned char uc=0x84; u = uc; // Значение u=0x00000084

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

double d1=855.666, d2=0.5E16;

int n; n = d1; // Отбрасывание дробной части

n = d2; // Потеря значимости

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

i nt n=-1; unsigned d;

d = n ; // Значение d =0 xFFFFFFFF (-1)

При выполнении бинарных операций принят следующий порядок:

· если один из операндов – длинное целое ( long ), то второй также приводится к этому типу;

· если один из операндов – беззнаковый ( unsigned), то второй также приводится к этому типу;

· в конце концов остаются целые операнды, сохраняющие свой тип.

Следует обратить внимание на одну тонкость: если в процессе преобразования требуется увеличение разрядности переменной, то на способ ее «удлинения» влияет только наличие или отсутствие знака у самой переменной. Второй операнд, к типу которого осуществляется приведение, на этот процесс не влияет (принятые в примерах размерности short – 16 разрядов, int – 32 разряда):

unsigned short d = 0xFF000;

Источник

Системный подход к переменным в Ansible

ansible devops codestyle

Hey! Меня зовут Денис Калюжный я работаю инженером в отделе автоматизации процессов разработки. Каждый день новые сборки приложений раскатываются на сотнях серверов кампании. И в этой статье я делюсь опытом использования Ansible для этих целей.

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

С этими проблемами мы столкнулись на проектах в нашей компании, в следствие чего мы пришли к правилам оформления переменных в наших плейбуках, которые в какой-то мере решили эти проблемы.

Переменные в ролях

Роль — это отдельный Объект системы деплоя. Как и любой объект системы, он должен иметь интерфейс взаимодействия с остальной системой. Таким интерфейсом являются переменные роли.

Переменные роли можно разделить на 2 вида по типу:

Переменные свойства — это переменные, которые определяют поведение роли.

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

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

С другой стороны, 1а, 2а, 2б — это переменные, которые не зависят от среды (железо, внешние ресурсы и т.д.) и могут быть заполнены дефолтными значениями в defaults роли. Однако переменные типа 1.б и 2.в заполнить кроме как ‘example’ значениями невозможно, так как они будут меняться от стенда к стенду в зависимости от окружения.

Code style

Старайтесь не использовать словари для переменных. Ansible не позволяет удобно переопределять отдельные значения в словаре.

Пример плохой переменной:

Здесь login — средонезависимая переменная, а password — зависимая. Но
поскольку они объединены в словарь, вам придётся задавать её полностью
всегда. Что очень неудобно. Лучше так:

Переменные в плейбуках деплоя

При составлении плейбука деплоя (далее плейбук), мы придерживаемся правила, что он должен размещаться в отдельном репозитории. Так же, как и роли: каждая в своем git репозитории. Это позволяет осозновать, что роли и плейбук — это разные независимые объекты системы деплоя, и изменения в одном объекте не должны влиять на работу другой. Достигается это изменением дефолтных значений переменных.

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

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

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

Это означает, что уже на этом этапе нужно определиться является ли переменная средозависимой или нет и разместить ее в положенном месте.

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

Переменные свойств для групп

Расширим нашу модель на рисунке 1, добавив 2 группы серверов с другим Java приложением, но с разными настройками.

Представим, как будет выглядить плейбук в этом случае:

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

Code Style

Переменные связи

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

В итоге решено было использовать переменные связи.

Переменные связи — это переменные, которые принадлежат плейбуку, и нужны для связи объектов системы.

Переменные связи заполняются в общих переменных системы group_vars/all/vars и образуются путём выноса всех переменных слушателей из каждой группы, и добавлением в начало переменной название группы откуда слушатель был вынесен.

Таким образом обеспечивается однотипность и непересекаемость имён.

Попробуем связать переменные из примера выше:

Представим, что у нас есть переменные, которые друг от друга зависят:

Вынесем в общие переменные group_vars/all/vars всех слушателей, и добавим в название имя группы:

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

Code Style

Средозависимые файлы

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

Примером таких файлов можно назвать SSL-сертификаты. Хранить их в текстовом виде
в переменной не очень удобно. Зато удобно хранить путь до них внутри переменной.

Поскольку очевидно, что сертификат ключа будет меняться от среды к среде, то это средозависимая переменная, а значит она должна расположиться в файле
group_vars/myapi/vars инвентори переменных, и содержать значение ‘для примера’.

Несколько стендов в одной среде

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

Он будет переиспользовать инвентори group_vars, а также иметь возможность переопределить некоторые переменные непосредственно под себя.

Окончательная структура каталогов для проекта деплоя:

Подведение итога

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

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

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

Источник

Java Core для самых маленьких. Часть 3. Переменные

В предыдущей статье мы говорили о типах данных, а теперь поговорим о вытекающей из этого теме, о переменных.

На скриншоте выше продемонстрирован пример создания переменных.

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

Итак, переменные принято называть в lowerCamelCase стиле. Сейчас покажу как хорошо, а как плохо:

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

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

Обратим внимание на имя константы. Когда мы даем имя константе, то должны делать это в стиле SCREAMING_SNAKE_CASE. Давайте исправим мой код:

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

Инициализация переменных

У всех переменных из моих примеров уже было присвоено начальное значение. Процесс присвоения начального значения называется инициализацией переменной. И не обязательно инициализировать переменную во время ее объявления. Java позволяет сделать это и позже.

Во-первых, можно объявлять переменные через запятую (если они одинакового типа):

При этом, смотрите, мы можем некоторые из них инициализировать прямо во время объявления. А теперь инициализируем оставшиеся:

Для инициализации переменных типа char я использовал цепочку присваиваний. Да, и так тоже можно. Хотя используется очень редко.
Если мы попытаемся провести какую-то операция с переменной, у которой нет значения, то получим ошибку.

Оператор присваивания

Литералы

В Java постоянные значения задаются литеральным представлением. Простым языком, при помощи определенных символов мы можем указывать тип данных. Вот например, при работе с целочисленными литералами нам не нужны никакие литералы. Мы просто пишем число 1998; и Java понимает, что это целочисленное значение.

Так, что еще за символы подчеркивания в значении переменной? Это всего-навсего декор. С JDK 7 допустимо указывать знаки подчеркивания, для разбиения больших чисел на разряды, для удобства чтения.

В вышеописанных примерах были литералы для целочисленных десятичных значений. А еще мы можем присвоить целому числу литерал в виде восьмеричного значения. Для этого вам нужно добавить в самом начале значения 0. Но в таком случае, логично, что это значение не сможет содержать цифры 8 и 9, поскольку они выходят за пределы восьмеричной системы счисления.

Мало того, еще мы можем использовать литерал шестнадцатеричных значений. Такие значения обозначают с начальным 0x или 0X, а цифры в пределах от 10 до 15 заменяются символами ABCDEF английского алфавита.

С JDK 7 есть возможность указывать целочисленные литералы в двоичном виде. Для этого вначале значения нужно указать 0b или 0B и соответственно в значениях можно использовать только цифры 0 и 1. В реальности, вам навряд ли понадобятся литералы шестнадцатеричных, восьмеричного или двоичных значений. Однако, знать о них нужно.

Литералы дробных чисел

Но существует и экспоненциальная форма записи этих чисел в виде 2.34e12;

Где число после символа ‘e’ обозначает степень 10-ти. Простыми словами, мы записали 2 целых и 34 сотых умноженное на 10 в 12 степени.

Как и в случае с целочисленными значениями, литералы с плавающей точкой поддерживают нижнее подчеркивание начиная с JDK 7.

Логические литералы

Символьные литералы

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

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

А вот если символ нельзя ввести непосредственно с клавиатуры, то для ввода таких символов используют ряд управляющих последовательностей. Например, символ переноса строки ‘\n’. Существуют последовательности, которые существуют для ввода значений в восьмеричной и шестнадцатеричной форме. Например, мы захотели ввести букву tu катаканы смайлик: ツ. Берем и пишем:

В данной таблице вы можете посмотреть наиболее используемые последовательности символов:

Когда-то давно, я писал статью про экранирование символом. Настоятельно рекомендую прочитать, как дополнительный материал. Узнаете много интересного.

Строковый литерал

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

Динамическая инициализация

Пару слов о таком термине как динамическая инициализация. Ничего сложного, только звучит страшно.

Переменную можно инициализировать другой переменной. Также, допускается инициализация переменной результатом какого-то выражения.

Главное, чтобы тип данных выражения / инициализирующей переменной совпадал с типом данных целевой переменной.

Преобразование и приведение типов

Знаю, вы уже подустали, сделали массу перерывов и подходов. Обещаю, это последняя тема в этой статье.

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

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

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

Подводим итоги

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

Скажем спасибо Егору за предоставленный материал.

Источник