люди, чем отличаются инициализация и присваивание? только человеческим языком, если можнО
Из Java(в С++ по моему также) , при инициализации выполняется два действия первое выделяется область памяти объемом соответствующим типу переменной (int 32 bit, double 64 bit), второе ей присваевается имя, теперь это имя ссылка указывающая на адрес этой области. Присваивание может идти только после инициализации, при этом происходит простое заполнение этой области определенным значением.
Похожие вопросы
Объявление? Определение? Инициализация?
В чем разница между объявлением переменной, её определением и инициализацией
Начинающим программистам первое время бывает трудно запомнить все те названия и термины, которые обрушиваются на них из учебников и современных вебинаров. Особенно, если они еще чем-то похожи между собой.
Такими близкими по смыслу и довольно часто путающимися являются понятия «объявление» переменной, её «определение» и её «инициализация».
В силу некоторой личной привычки я иногда фиксирую результаты гугления по тому или иному вопросу, связанному с обучением, в небольших конспектах. Это помогает разобраться в материале, систематизировать его и по-своему, более удобно для себя изложить. В дальнейшем такие записи помогают быстро повторить пройденный материал и являются своеобразным альтернативным вариантом изложения той или иной учебной темы.
И поскольку мы живем в жутко социализированное время, то естественно хочется поделиться результатами своего труда с другими,такими же начинающими программистами. Возможно кому-то это тоже пригодится.
Объявление переменной или константы
Итак, выражение называется объявлением переменной или декларированием. На английском это выглядит так — Declaring Constants and Variables:
var a = 10В приведенном примере задана переменная (var), задано имя переменной (а) и задано значение переменной (10).
Определение переменной или константы
Как известно, объявить переменную мы можем и без указания значения. Но тогда нужно указать тип данных будущего значения.
var b: Int?Вспомним, зачем это делается. Если в первом случае мы сразу указываем значение, то Swift автоматом определяет тип данных значения. Если же значение не указано, то Swift не знает, какого типа данные в ней будут храниться и ему нужно явно указать этот тип.
Заодно и еще один термин — аннотация типа. Это вот как раз результат действия по определению, а именно слово Int?.
Аннотация типа может быть простая, состоящая из одного слова, обозначающая тип данных, так и составная. Например, в кортежах (tuples) может быть и такая запись
var b: (Int, Int, Int)И кстати, для чистоты кода в Swift рекомендуется не ставить пробел между именем переменной и двоеточием.
Инициализация переменной или константы
В первом примере, который мы продублируем ниже, где происходит не только объявление переменной, но и её инициализация:
var a = 10Инициализация означает, что переменная запущена в работу, ей присвоено начальное значение, она инициализирована. Без присвоения начального значения переменная просто объявлена, а с начальным значением она еще и инициализирована.
Во втором случае, когда переменная объявлена без начального значения, т.е. она еще не инициализирована, не готова полностью к работе.
var b: IntТри действия — объявление, определение, инициализация
Таким образом, мы имеем здесь три действия — объявление, определение и инициализацию. Их можно записать в одном выражении:
var a: Int = 10Но, как мы помним, Swift рекомендует экономить время, если есть значение, он может самостоятельно определить тип данных.
И еще, обратите внимание, что голого объявления переменной не может быть. Должно быть обязательно объявление с какой-то второй операцией — или с присвоением значения или с определением типа данных значения. И можно применять сразу три действия, но нельзя только одно, т.е. больше можно, меньше нельзя.
Ковбойская история
Разницу между этими тремя действиями можно проиллюстрировать с помощью шуточного примера, найденного на просторах интернета и немного подредактированного))
Итак, в бар входит в ковбой и требует выпивку — это объявление, декларация намерений.
Бармен спрашивает — чем будешь платить: деньгами, отдашь пистолет или отработаешь мытьем посуды? — Я заплачу, — отвечает ковбой, — у меня есть деньги. — Это определение типа данных.
Тогда плати 5 баксов и получай выпивку — Ковбой платит и веселье начинается — Это инициализация, присвоение начального значения, запуск процесса в работу.
Заметка
Обратите внимание, что мы используем выражение «тип данных» и по отношению к значению, и по отношению к переменным и константам. Дело в том, что в программировании по большому счета можно практически все называть типом данных. Это и объекты, и классы, и наиболее нам известные Int, String, Double, Bool и т.д.
Но, чтобы как-то все же отличать типы данных значений от констант и переменных будем называть последние некими сущностями, элементами языка программирования. Тогда у нас будут типы данных для значений и типы данных для определенных элементов программирования (к которым относятся в том числе константы и переменные).
Автор: Максим Савостьянов
7.9.2. Инициализация и присваивание
Вспомним, что имя массива без указания индекса элемента интерпретируется как адрес первого элемента. Аналогично имя функции без следующих за ним скобок интерпретируется как указатель на функцию. Например, при вычислении выражения
получается указатель типа
int (*)( const string , const string );
Применение оператора взятия адреса к имени функции также дает указатель того же типа, например lexicoCompare и lexicoCompare. Указатель на функцию инициализируется следующим образом:
int (*pfi)( const string , const string ) = lexicoCompare;
int (*pfi2)( const string , const string ) = lexicoCompare;
Ему можно присвоить значение:
Инициализация и присваивание корректны только тогда, когда список параметров и тип значения, которое возвращает функция, адресованная указателем в левой части операции присваивания, в точности соответствуют списку параметров и типу значения, возвращаемого функцией или указателем в правой части. В противном случае выдается сообщение об ошибке компиляции. Никаких неявных преобразований типов для указателей на функции не производится. Например:
int calc( int, int );
int (*pfi2s)( const string , const string ) = 0;
int (*pfi2i)( int, int ) = 0;
pfi2i = calc; // правильно
pri2s = calc; // ошибка: несовпадение типов
pfi2s = pfi2i; // ошибка: несовпадение типов
Такой указатель можно инициализировать нулем или присвоить ему нулевое значение, в этом случае он не адресует функцию.
Читайте также
11.7.4 Присваивание IP-адресов
11.7.4 Присваивание IP-адресов Администратор конфигурирует сервер BOOTP для присваивания системам IP-адресов посредством ручного создания таблицы отображения на IP-адрес комбинации типа оборудования и аппаратного адреса клиента. Кодирование типов оборудования определяется
11.9.1 Присваивание IP-адресов
11.9.1 Присваивание IP-адресов В DHCP поддерживаются три типа присвоения адресов:? Ручное, когда IP-адрес вводится на сервере и назначается клиенту постоянно? Автоматическое, когда IP-адрес выбирается сервером из пула доступных адресов и назначается клиенту
R.18.3.3 Присваивание указателю this
R.18.3.3 Присваивание указателю this Присваивая определенные значения указателю this, пользователь мог управлять выделением памяти для объекта некоторого класса. В конструкторе до использования членов класса можно было с помощью такого присваивания реализовать свой алгоритм
Присваивание значений
Присваивание значений Значения переменным присваиваются с помощью обыкновенного знака равенства. Например, чтобы поместить число 3 в переменную с именем intC, напечатайте intC = 3В VBA оператор присваивания представляет собой связанную знаком равенства конструкцию, с
Простое присваивание
Простое присваивание Операция простого присваивания обозначается знаком =. Значение правого операнда присваивается левому операнду. Левый операнд должен быть модифицируемым L-выражением. При присваивании выполняются правила преобразования типов, описанные в разделе
Составное присваивание
Составное присваивание Операция составного присваивания состоит из простой операции присваивания, скомбинированной с какой-либо другой бинарной операцией. При составном присваивании вначале выполняется действие, специфицированное бинарной операцией, а затем
6.6.2. Присваивание и обмен
6.6.2. Присваивание и обмен Что происходит, если мы присваиваем один контейнер другому? Оператор присваивания копирует элементы из контейнера, стоящего справа, в контейнер, стоящий слева от знака равенства. А если эти контейнеры имеют разный размер? Например:// svecl
7.9.2. Инициализация и присваивание
7.9.2. Инициализация и присваивание Вспомним, что имя массива без указания индекса элемента интерпретируется как адрес первого элемента. Аналогично имя функции без следующих за ним скобок интерпретируется как указатель на функцию. Например, при вычислении
14. Инициализация, присваивание и уничтожение класса
14. Инициализация, присваивание и уничтожение класса В этой главе мы детально изучим автоматическую инициализацию, присваивание и уничтожение объектов классов в программе. Для поддержки инициализации служит конструктор — определенная проектировщиком функция (возможно,
14.7. Почленное присваивание A
14.7. Почленное присваивание A Присваивание одному объекту класса значения другого объекта того же класса реализуется почленным присваиванием по умолчанию. От почленной инициализации по умолчанию оно отличается только использованием копирующего оператора присваивания
17.6. Почленная инициализация и присваивание A
17.6. Почленная инициализация и присваивание A При проектировании класса мы должны позаботиться о том, чтобы почленная инициализация (см. раздел 14.6) и почленное присваивание (см. раздел 14.7) были реализованы правильно и эффективно. Рассмотрим связь этих операций с
4.2. Присваивание значений переменным
4.2. Присваивание значений переменным =оператор присваивания (пробельные символы до и после оператора — недопустимы) Не путайте с операторами сравнения = и -eq!Обратите внимание: символ = может использоваться как в качестве оператора присваивания, так и в качестве
Присваивание функции результата
Присваивание функции результата Присваивание функции результата является интересной языковой проблемой, обсуждение которой было начато ранее в данной лекции. Стоит изучить ее подробнее ввиду ее важности и для языков, не использующих ОО-подход.Рассмотрим функцию —
Присваивание (Assignment)
Присваивание (Assignment) Инструкция присваивания записывается в виде:x := eгде x — сущность, допускающая запись (writable), а e — выражение совместимого типа. Такая сущность может быть:[x]. неконстантным атрибутом включающего класса;[x]. локальной сущностью включающей подпрограммы. Для
Присваивание и инициализация в Java
Основное предназначение компьютерных программ — обработка данных. Чтобы обработать данные нужно их как-то хранить. Предлагаю разобраться с тем, как происходит хранение данных.
Переменные
- Поля (fields) : переменные, объявленные в классе;
- Локальные переменные (local variables) : переменные в методе или в блоке кода;
- Параметры (parameters) : переменные в объявлении метода (в сигнатуре).
- Тип переменной показывает, какие данные представляет данная переменная (т.е. какие данные может хранить). Как мы знаем, тип переменной может быть примитивным (primitives primitives) или объектным, не примитивными (Non-primitive). При объектных переменных их тип описывается определённым классом.
- Название переменной должно быть с маленькой буквы, в camel case. Подробнее про именование можно прочитать в «Variables:Naming».
Объявление переменной (Declaration)
Итак, мы вспомнили, что такое переменная. Для того, чтобы с переменной начать работать нужно её объявить. Для начала, разберёмся с локальной переменной. Вместо IDE для удобства воспользуемся онлайн решением от tutorialspoint: Online IDE. Выполним в их online IDE вот такую простенькую программку:
public class HelloWorld < public static void main(String []args)< int number; System.out.println(number); >>
Итак, как видно, мы объявили локальную переменную с именем number и типом int . Нажимаем кнопку «Execute» и получаем ошибку:
HelloWorld.java:5: error: variable number might not have been initialized System.out.println(number);
- Обращение к локальным переменным должно быть выполнено только после того, как они будут инициализированы;
- Локальные переменные не имеют значений по умолчанию;
- Проверка значений локальных переменных выполняется в момент компиляции.
Инициализация локальной переменной
Инициализация переменных одна из самых мудрёных тем в Java, т.к. очень тесно связана с работой с памятью, с реализацией JVM, спецификацией JVM и другими не менее страшными и хитрыми вещами. Но можно попробовать разобраться хоть в какой-то мере. Пойдём от простого к сложному. Чтобы инициализировать переменную воспользуемся оператором присваивания и изменим строчку в нашем прошлом коде:
int number = 2;
В таком варианте ошибок не будет и на экран выведется значение. Что же происходит в этом случае? Давайте попробуем порассуждать. Если мы хотим присвоить переменной какое-то значение, значит мы хотим, чтобы эта переменная хранила значение. Получается, что значение где-то должно храниться, но где? На диске? Но это очень медленно и может на нас накладывать ограничения. Получается, единственное, где мы можем быстро и эффективно хранить данные «здесь и сейчас» это память. Значит, нам нужно выделить в памяти какое-то место. Так и есть. При инициализации переменной под неё будет выделено место в памяти, отведённой java процессу, в рамках которого будет выполняться наша программа. Память, выделяемая java процессу, разделена на несколько областей или зон. В какой из них будет выделено место зависит от того, какого типа была объявлена переменная. Память разделяется на следующие разделы: Heap, Stack и Non-Heap. Начнём со стэковой памяти. Stack переводится как стопка (например, стопка книг). Представляет собой LIFO структуру данных (Last In, First Out). То есть как стопка книг. Когда мы добавляем в неё книги – мы кладём их сверху, а когда забираем – берём верхнюю (т.е. ту, которая добавлена самой последней). Итак, мы запускаем нашу программу. Как мы знаем, Java программу выполняет JVM, то есть виртуальная Java машина. JVM должна знать то, откуда должно начаться выполнение программы. Для этого мы объявляем main метод, который называется «точкой входа». Для выполнения в JVM создаётся основной поток (Thread). При создании потока ему выделяется свой стэк в памяти. Этот стэк состоит из фрэймов. При выполнении каждого нового метода в потоке под него будет выделен новый фрэйм и добавлен на вершину стэка (как новая книжка в стопке книг). Этот фрэйм будет содержит ссылки на объекты и примитивные типы. Да да, наш int будет храниться в стэке, т.к. int это примитивный тип. Прежде чем выделить фрэйм JVM должна понимать, что туда сохранять. Именно по этой причине мы получим ошибку «variable might not have been initialized», ведь если она не инициализирована, то JVM не сможет нам подготовить стэк. Поэтому при компиляции программы умный компилятор поможет нам не допустить ошибку и не сломать всё. (!) Для наглядности советую супер-пупер статью: «Java Stack and Heap: Java Memory Allocation Tutorial». В ней ссылаются на не менее крутое видео:
После завершения выполнения метода из стэка потока будут удаляться фрэймы, выделенные под эти методы, а вместе с ними и очищаться память, выделенная под этот фрэйм со всеми данными.
Инициализация локальных объектных переменных
Давайте опять изменим наш код на чуть более хитрый:
public class HelloWorld < private int number = 2; public static void main(String []args)< HelloWorld object = new HelloWorld(); System.out.println(object.number); >>
Что же тут будет происходить? Давайте ещё раз рассуждать. JVM узнает о том, откуда ей выполнять программу, т.е. она видит main метод. Она создаёт поток, под него выделяет память (потоку ведь надо где-то хранить данные, которые нужны для выполнения). В этом потоке выделяется фрэйм под метод main. Далее мы создаём объект HelloWorld. Этот объект уже создаётся не в стэке, а в хипе. Потому что object у нас не примитивный тип, а объектный. А в стэке будет храниться только ссылка на объект в хипе (мы ведь как-то должны обращаться к этому объекту). Далее в стэке метода main будут выделены фрэймы для выполнения метода println. После выполнения метода main будут уничтожены все фрэймы. При уничтожении фрэйма будут уничтожены все данные. Объект object не будет уничтожен сразу. Сначала на него будет уничтожена ссылка и таким образом на объект object больше никто ссылаться не будет и доступа больше к этому объекту в памяти будет не получить. Умная JVM имеет свой механизм для такого – сборщик мусора (garbage collector или сокращённо GC). Он то и удаляет из памяти такие объекты, на которые больше никто не ссылается. Данный процесс опять же был описан в ссылке, что была приведена выше. Там даже видео есть с объяснением.
Инициализация полей
Инициализация полей, указанных в классе происходит особым образом в зависимости от того, является ли поле статическим или нет. Если у поля стоит ключевое слово static, то данное поле относится к самому классу, а не слово static не указано, то данное поле относится к экземпляру класса. Давайте рассмотрим это на примере:
public class HelloWorld < private int number; private static int count; public static void main(String []args)< HelloWorld object = new HelloWorld(); System.out.println(object.number); >>
В данном примере, инициализация полей происходит в разное время. Поле number будет инициализировано после того, как будет создан объект object класса HelloWorld. А вот поле count будет инициализировано тогда, когда класс будет загружен виртуальной Java машиной. Загрузка классов – это отдельная тема, поэтому не будем сюда примешивать её. Просто стоит знать, что статические переменные инициализируются тогда, когда о классе становится известно при выполнении. Тут важнее другое и Вы уже это заметили. Мы нигде не указали значения, а оно работает. И действительно. Переменные, которые являются полями, если для них не указано значение, то они инициализируются значением по умолчанию. Для числовых значением это 0 или 0.0 для чисел с плавающей точкой. Для boolean это false. А для всех переменных объектных типов значение будет null (об этом мы ещё поговорим). Казалось бы, а почему так? А потому, что объекты создаются в Heap (в куче). Работа с данной областью выполняется в Runtime. И мы в runtime можем инициализировать эти переменные, в отличии от стэка, память под который должна быть подготовлена ещё до выполнения. Так устроена работа с памятью в Java. Но есть тут и ещё одна особенность. В этом маленьком кусочке затрагиваются разные уголки памяти. Как мы помним, в Stack памяти под метод main выделяется фрэйм. В этом фрэйме хранится ссылка (reference) на объект в Heap памяти. Но где тогда хранится count? Как мы помним, эта переменная инициализируется сразу, до создания объекта в хипе. Вот тут действительно хитрый вопрос. До Java 8 существовала область памяти, называемая PERMGEN. Начиная с Java 8 эта область претерпела изменения и называется METASPACE. По сути, статические переменные являются частью описания класса, т.е. его метаданными. Поэтому, логично, что хранится в хранилище метаданных, METASPACE. MetaSpace относится к той самой Non-Heap области памяти, является её частью. Важно ещё учитывать то, что учитывается порядок, в котором объявлены переменные. Например, в этом коде ошибка:
public class HelloWorld < private static int b = a; private static int a = 1; public static void main(String []args)< System.out.println(b); >>
Что такое null
Как было сказано выше, переменные объектных типов, если они являются полями класса, инициализируются значениями по умолчанию и таким значением по умолчанию является null. Но что же такое null в Java? Первое что важно помнить – примитивные типы не могут быть null. А всё потому, что null – это особенная ссылка (reference), которая не ссылается никуда, ни на какой объект. Поэтому, только объектная переменная может быть равна null. Второе, что важно понимать, что null – это ссылка, reference. Я reference тоже имеют свой вес. На эту тему можно почитать вопрос на stackoverflow: «Does null variable require space in memory».
Блоки инициализации
Рассматривая инициализацию переменных грех не рассмотреть блоки инициализации. Выглядит это следующим образом:
public class HelloWorld < static < System.out.println("static block"); > < System.out.println("block"); >public HelloWorld () < System.out.println("Constructor"); >public static void main(String []args) < HelloWorld obj = new HelloWorld(); >>
Порядок вывода будет: static block, block, Constructor. Как мы видим, блоки инициализации выполняются раньше, чем конструктор. И иногда это может быть удобным средством для инициализации.