Все типы переменных на java. WDH: Java - Типы, значения и переменные
Тип данных определяется тремя составляющими:
- набором значений или объектов;
- набором операций, которые могут быть применены ко всем значениям в наборе;
- представлением данных, определяющим их хранение.
Какие бывают типы данных в Java?
Язык программирования содержит некоторые заранее определенные встроенные типы и позволяет программистам определять свои собственные, пользовательские.
В Java типы данных делятся на примитивные и ссылочные.
«Примитивный» означает, что дальнейшее его деление невозможно. Расширять или изменять его язык программирования не позволяет. Такой тип данных описывается примитивными и другими пользовательскими типами.
Переменная примитивного типа содержит значение, а ссылочная - адрес объекта в памяти.
Язык Java. время и дата
Составные данные делятся на классы, интерфейсы и массивы. Членами интерфейсного типа являются абстрактные методы и константы. В языке Java типы данных дата и время задаются конструктором Date():
- d = new Date().
Язык Java. Типы данных: String
Строка представляет собой класс, определенный в и он может быть использован для работы с текстом (последовательностью символов).
Объявление ссылочной String-переменной следующее: String str.
- str = new String ("Привет").
Что происходит при выполнении этого кода? Во-первых, выделяется память, и имя str связывается с этой ячейкой памяти. Это не отличается от объявления примитивной переменной. Второй фрагмент кода создает в памяти объект String с текстом «Привет» и сохраняет ссылку на него (или адрес памяти) в str.
Ссылочные типы данных Java также позволяют присвоить ссылку на объект, хранящуюся в одной переменной, другой. Обе они ссылаются на один и тот же объект в памяти. Это может быть достигнуто следующим образом:
- String str1;
- String str2;
- str1 = new String ("Привет");
- str2 = str1;
Объект String создается с помощью оператора new. Но так как строки используются часто, есть более простой способ его создания. Все строковые литералы, т. е. последовательность символов, заключенная в двойные кавычки, рассматриваются как объекты String. Поэтому вместо оператора new можно использовать строковые литералы:
- String str1 = "Hello".
Примитивные типы данных Java - byte, short, int, long, char, float, double и boolean. Они делятся на две категории: логическую и числовую. Последняя может быть разделена на целые числа и числа с плавающей точкой.
Целые типы данных Java представляют собой числовые типы, значения которых являются целыми числами. Их пять: byte, short, int, long и char.
Int
Int представляет собой 32-разрядный знаковый примитивный тип данных. Переменная занимает 32 бита памяти. Допустимый диапазон - от -2147483648 до 2147483647 (-2 31 до 2 31 - 1). Все целые числа в этом диапазоне являются целочисленными литералами или константами. Например, 10, -200, 0, 30, 19 являются литералами int. Их можно присвоить переменной int:
- int num1 = 21;
Целые литералы могут быть выражены в виде двоичного, восьмеричного, десятичного и шестнадцатеричного числа.
Когда литерал начинается с нуля и имеет, по крайней мере, две цифры, он считается записанным в восьмеричном формате. 0 и 00 представляют одинаковое значение - ноль.
Все литералы int в формате шестнадцатеричного числа начинаются с 0x или 0x, и они должны содержать хотя бы одну шестнадцатеричную цифру:
- int num1 = 0x123.
Int-литералы в формате начинаются с 0b или 0B:
- int num1 = 0b10101.
Long
Это 64-разрядный знаковый примитивный тип. Используется, когда результат вычислений может превышать диапазон int. Диапазон long - от -2 63 до 2 63 - 1. Все целые числа этого диапазона являются литералами длинного типа.
Чтобы отличать в языке Java типы данных int и long, литерал последнего типа всегда заканчивается L или l.
Целые литералы длинного типа также могут быть выражены в восьмеричном, шестнадцатеричном и двоичном форматах.
Когда long-литерал присваивается переменной long, компилятор Java проверяет присваиваемое значение и удостоверяется, что оно находится в приемлемом диапазоне; в противном случае произойдет ошибка компиляции.
Поскольку диапазон int меньше, чем у long, значение int-переменной всегда может быть присвоено переменной типа long. Но обратное присвоение невозможно даже в пределах диапазона int. Для этого используется явное указание:
- num1 = (int) num2;
Byte
Byte представляет собой 8-разрядный целый примитивный тип. Его диапазон - от -128 до 127 (-2 7 до 2 7 - 1). Это наименьший целый тип, имеющийся в Java. Как правило, байтовые переменные используются, когда в программе задействовано много значений в диапазоне от -128 до 127, или при работе с бинарными данными. В отличие от литералов int и long, byte-литералы отсутствуют. Тем не менее можно назначить byte-переменной любой int-литерал, так как он перекрывает диапазон байта.
Если значение переменной выходит за пределы диапазона, Java выдаст ошибку компилятора.
Кроме того, можно присвоить только int-литерал, но не значение, хранящееся в переменной int, так как при этом возможна потеря точности. Для этого потребуется явное приведение типа.
- b1 = (byte) num1.
Short
Представляет собой 16-разрядный знаковый целый примитивный тип данных. Его диапазон - от -32768 до 32767 (или -2 15 до 2 15 - 1).
Как правило, необходимость в коротких переменных возникает, когда программа использует большое количество значений, которые не превышают указанный диапазон. Short-литерал отсутствует, но возможно присвоение любого литерала int в пределах диапазона short. Значение byte-переменной может быть присвоено всегда. Остальные правила присвоения int или long short-переменной такие же, как для byte.
Char
Char является 16-разрядным беззнаковым примитивным типом данных, который представляет символ Юникода. Отсутствие знака означает, что переменная не может иметь отрицательное значение. Диапазон - от 0 до 65535, что совпадает с кодировкой набора символов Юникода. Литерал представляет значение char и может быть выражен в таких формах:
- символ, заключенный в одинарные кавычки;
- последовательность управляющих символов;
- последовательность управляющих символов юникода;
- последовательность восьмеричных управляющих символов.
Символ может быть выражен путем заключения его в одинарные кавычки: char C1 = "A". обозначают строковый литерал, который не может быть присвоен char-переменной, даже если строка состоит только из одного символа. Это недопустимо, так как ссылка примитивной переменной не присваивается. Все строковые литералы являются объектами класса String и, следовательно, ссылками, тогда как символьные относятся к примитивному типу.
Литерал, выраженный управляющей последовательностью, записывается в виде обратной косой черты с символом в одиночных кавычках. Всего их 8: ‘\n’, ‘\r’, ‘\f’, ‘\b’, ‘\t’, ‘\\’, ‘\”’, ‘\’’.
Управляющая юникод-последовательность имеет вид "\uxxxx", где \u (обратный слеш, за которым следует строчная u) обозначает ее начало, а хххх представляет ровно четыре шестнадцатеричные цифры кода символа в системе Юникод. Например, "A" имеет значение 65 в десятичной системе и 41 в шестнадцатеричной. Таким образом, этот символ может быть представлен как "\u0041".
Восьмеричная управляющая последовательность записывается в виде "\nnn", где n - восьмеричная цифра (0-7). Диапазон значений - от "\000" до "\377", где 377 8 соответствует 255 10 . Поэтому она используется для представления символов с кодом от 0 до 255, необходимого для совместимости с другими языками программирования. В отличие от юникод-последовательности, где необходимы все четыре шестнадцатеричные цифры, здесь можно использовать 1, 2 или 3 восьмеричные: "\n", "\nn" или "\nnn".
Логический тип
Boolean имеет только два действительных значения: true (истина) и false (ложь). Они называются булевыми литералами. Логическая переменная не может быть приведена к другому типу и наоборот. Java не определяет размер boolean - он зависит от конкретной реализации виртуальной Java- машины.
Типы данных Java с плавающей точкой
Число, которое содержит дробную часть, в памяти компьютера может храниться в представлении с фиксированным количеством цифр до и после точки или с указанием ее положения. Так как количество цифр может меняться, то говорят, что точка «плавает».
В языке Java типы данных с плавающей точкой используют 32 бита. Согласно стандарту IEEE 754, это соответствует одинарной точности, которая позволяет представлять, например, числа 1,4 х 10 -45 и 3,4 х 10 38 , причем как положительные, так и отрицательные.
Все которые заканчиваются на f или F, называются float-литералами. Они могут быть представлены в формате десятичного числа и в виде научной нотации. Например:
- float f1 = 3.25F;
- float f2 = 32.5E-1F;
- float f3= 0.325E + 1F.
Тип определяет два нуля: +0.0F (или 0.0F) и -0.0F. Однако для целей сравнения оба нуля считаются равными. Кроме того, им определены два вида бесконечности: положительная и отрицательная. Результаты некоторых операций (например, не определены и представлены специальным значением NaN.
Двойная точность
Для хранения чисел с плавающей точкой double использует 64 бита. Число двойной точности может представлять положительные и отрицательные значения величиной 4,9 х 10 -324 и 1,7 х 10 308 .
Все действительные числа по умолчанию являются двойными литералами. По желанию могут явно обозначаться суффиксом d или D, например, 19.27d. Двойной литерал может быть выражен в десятичной форме и в научной нотации.
Примитивные типы в Java — важная, часто используемая часть языка, которая требует особого обращения. В этой публикации попробуем ответить на все вопросы связанные с примитивными типами, механизмом их работы, обработкой. Статья предназначена как для новичков, которые только стали на тернистый путь изучения Java (к ним отношусь и я), так и для людей, достаточно знакомым с языком, которые смогут освежить знания и, надеюсь, найдут что-то интересное для себя.
Примитивные типы
Примитивные типы немного нарушают объектную ориентированность языка Java, так так представляют одиночные (простые) значения. Эта особенность объясняется желанием обеспечить максимальную эффективность. Создавать объект простой переменной с помощью new недостаточно эффективно, так как new перемещает объект в кучу. Вместо этого создается «автоматическая» переменная, которая не является ссылкой на объект. Переменная хранит единственное значение и располагается в стеке. Стек — это область хранения данных, расположена в RAM. Процессор имеет прямой доступ до этой области через указатель на стек, поэтому стек — очень быстрый и эффективный способ хранения данных. По скорости стек уступает только регистрам (логично, так как регистры расположены внутри процессора).Все размеры примитивных типов строго фиксированы и не зависят от машинной архитектуры. Это одна с причин улучшенной переносимости Java-программ.
В Java определено восемь примитивных типов, которые можно разбить на четыре группы:
Целые числа
Для целых чисел определены четыре примитивных типа: byte , short , int , long . Все эти типы представляют целочисленные значения со знаком: положительные или отрицательные. В Java нет положительных целочисленных значений без знака (unsigned ). Как было сказано раньше, все размеры примитивных типов фиксированы:Наименьшим целочисленным типом является byte . Переменные этого типа очень удобны для работы с потоками ввода-вывода и при манипулировании двоичными данными. Далее идет тип short , который применяется реже всех остальных типов. Наиболее часто употребляемым типом является int . Его постоянно используют в циклах, для индексации массивов. Может показаться, что использование типов byte и short в местах, где не требуется широкий диапазон значений, будет более эффективным чем использование int . Но это не так, потому что при вычислении выражений значения типа byte или short будут преобразованы в int (мы еще вернемся к этому вопросу). Когда длины типа int недостаточно для хранения значения, нужно использовать long . Его диапазон значений достаточно велик, что делает long удобным при работе с большими целыми числами.
Числа с плавающей точкой
Числа с плавающей точкой (или действительные числа) представлены типами float и double . Используются для хранения значений с точностью до определенного знака после десятичной точки.Тип float определяет числовое значение с плавающей точкой одинарной точности. Этот тип используется, когда нужно числовое значение с дробной частью, но без особой точности. Тип double используется для хранений значений с плавающей точкой двойной точности. Обработка значений двойной точности выполняется быстрее, чем обработка значений одинарной точности. Поэтому большинство математических функций класса java.lang.Math возвращают значения типа double . Эффективнее всего использовать double , когда требуется сохранить точность многократно повторяющихся вычислений или манипулировать большими числами.
Символы
В спецификации примитивный тип char принадлежит к целочисленным типам (или integral types ), но поскольку он играет немного другую роль, можно выделить для него собственную категорию. Его роль — представлять символы Unicode . Для хранения символов требуется 16 бит. Странно, ведь для представления символов основных языков (например, английского, французского, испанского) достаточно 8 бит. Но такая цена интернационализации. Unicode использует полный набор международных символов на всех известных языках мира.Логические азначения
Примитивный тип boolean предназначен для хранения логических значений. Данный тип может принимать одно из двух возможных значений: true (истина) или false (ложь). Значения boolean возвращаются со всех логических операций (например, операции сравнения). Является обязательным при построении циклов, операторов (например, for, if).Литералы
Значения примитивных типов данных в большинстве случаев инициализируются с помощью литералов. Рассмотрим их.Целочисленные литералы
Наиболее часто используемые литералы. Любое целочисленное значение является числовым литералом (например, -10 , 10 — десятичные значения). Можно использовать восьмеричные, шестнадцатеричные и двоичные литералы: // десятичный литерал, числа , не начинается с 0
int decimal = 10; // 10
// восьмеричный литерал начинается с 0, далее числа
int octal = 010; // 8
// шестнадцатеричный литерал начинается с 0x или 0Х, далее числа и символы
int hexadecimal = 0x10; // 16
// двоичный литерал начинается с Оb или 0B, далее числа
int binary = 0b10; // 2
Все целочисленные литералы представляют значения int
. Если значение литерала лежит в диапазоне byte
, short
или char
, то его можно присвоить переменной этого типа без приведения типов. Для создания литерала типа long
, необходимо явно указать компилятору, дополнив литерал буквой "l
" или "L
":
Byte b1 = 127; byte b2 = 128; // ошибка short s1 = -32768; short s2 = -32769; // ошибка char c1 = 0; char c2 = -1; // ошибка long l1 = 10l; long l2 = 0x7fffffffffffffffL; // максимальное значение типа long
Литералы с плавающей точкой
Существует две формы записи литеров с плавающей точкой: стандартная и экспоненциальная: // стандартная форма
double d1 = 0.; // эквивалентно.0 или 0.0;
double d2 = 0.125;
// экспоненциальная форма - используется символ "e" или "E"
// после него степень числа 10, на которую следует умножить данное число
double d3 = 125E+10; // если степень положительная, "+" можно упустить
double d4 = 1.25e-10;
Всех литералам с плавающей точкой по-умолчанию присваивается тип double
. Поэтому чтобы создать литерал типа float
, нужно после литерала указать букву "f
" или "F
". К литералам также можно добавлять букву "d
" или "D
", сообщая, что это литерал типа double, но зачем?
Double d1 = 0.125;
float f2 = 0.125f;
Можно использовать шестнадцатеричные литералы с плавающей точкой, например:
// P - двоичный порядок, что обозначает степень числа 2, на которое следует умножить данное число
double d = 0x10.P10d; // конечно, можно и без "d"
float f = 0x20.P10f;
Для удобности чтения длинных литералов в 7 версии языка была добавлена возможность использовать символ "_" внутри литерала:
// можно делать любые комбинации с использованием любого количества символов "_" int phone = 111__111__111; int bin = 0b1000_1000_1000; double dollars = 23_000.450__500; // не допускается использовать символ "_" в конце или начале литерала, также не можно разрывать "0x" и "0b"
Символьные литералы
Символьные литералы заключаются в одинарные кавычки. Все отображаемые символы можно задавать таким способом. Если символ нельзя ввести непосредственно, используют управляющее последовательности начинающиеся с символа "\ ". Хотя все эти последовательности можно заменить соответствующим Unicode кодом. Также символьный литерал можно создать используя восьмеричную ("\xxx") и шестнадцатеричную форму ("\uxxxx").Char h = "a"; // стандартная форма
char a = "\001"; // восьмеричная форма
char c = "\u0001"; // шестнадцатеричная форма
Существуют также строковые литералы. Информацию о них можно получить .
Логические литералы
С логическими операторами все просто. Существует только два логических литерала:Boolean yes = true; // истина
boolean no = false; // ложь
Логические литералы можно присваивать только переменным типа boolean
. Также важно понимать, что false
не равен 0
, а true
не равен 1
. Преобразовать переменную типа boolean
в другие примитивные типы не выйдет.
Операции
Над целочисленными типами
- операторы сравнения (> , < , >= , <= ) и равенства (== , != )
- унарные операторы (+ , - )
- мультипликативные (* , / , % ) и аддитивные (+ , - ) операторы
- инкремент (++ ) и декремент (-- ) в префиксной и постфиксной формах
- знаковые (>> , << ) и без знаковые (>>> ) операторы сдвига
- побитовые операторы (~ , & , ^ , | )
- условный оператор (? : )
- оператор приведения типов
Над Floating-Point типами
Над числами с плавающей точкой можно проводить все те же операции, что и с целыми числами, за исключением побитовых операторов и операторов сдвига.Над логическим типом
- операторы равенства (== и != )
- логические операторы (! ,& , | , ^ )
- условные логические операторы (&& , || )
- условный оператор (? : )
Преобразование
Существует три типа преобразований:- расширяющее преобразование (widening )
- суживающее преобразование (narrowing )
- widening + narrowing (преобразование byte к char , сначала byte преобразовываем в int , а потом int — в char )
Расширяющее преобразование
Если оба типа совместимы и длина целевого типа больше длины исходного типа выполняется расширяющее преобразование (например byte преобразуется в int ). Следующая таблица демонстрирует все возможные расширяющее преобразования. Курсовом помечены типы, преобразования в которые, возможно, приведут к потери данных.Суживающее преобразование
При суживающем преобразовании возможна потеря информации об общей величине числового значения, также можно потерять точность и диапазон. Все возможные суживающее преобразования показаны в таблице:| short | byte, char |
|---|---|
| char | byte, short |
| int | byte, short, char |
| long | int, byte, short, char |
| float | long, int, byte, short, char |
| double | float, long, int, byte, short, char |
Чтобы выполнить преобразование двух несовместимых типов необходимо воспользоваться приведением (casting ). Если значения исходного целочисленного типа больше допустимого диапазона значений целевого типа, то оно будет сведено к результату деления по модулю на диапазон целевого типа. Если же значения типа с плавающей точкой приводится к значению целочисленного типа, то происходит усечение (отбрасывается дробная часть).
Byte a = (byte)128; // - 128 byte b = (byte)42; // привидение возможно, но, в данном случаи, в нем нет необходимости int i1 = (int)1e20f; // 2147483647 int i2 = (int)Float.NaN; // 0 float f1 = (float)-1e100; // -Infinity float f2 = (float)1e-50; // 0.0
Продвижение
Когда требуемая точность промежуточного значения выходит за пределы допустимого диапазона значений любого с операндов в выражении используется автоматическое продвижение типов.Int a = 100;
float b = 50.0f;
double c = 50.0;
double result = a - b + c; // 100.0
// на самом деле: result = (double)((float)a - b) + c;
Правила продвижения хорошо демонстрирует следующая диаграмма:
Классы-обертки
Для представления примитивных типов как объектов было сделаны классы-обертки (wrapper classes ). Какие преимущества дают нам классы-обертки?- возможность использования объектов классов-оберток в качестве параметров к методам или как generic-параметры
- возможность использования констант, которые отвечают за границы соответствующего типа данных (MIN_VALUE и MAX_VALUE )
- возможность использования методов для преобразования в другие примитивные типы, конвертации между системами счисления
Почти все классы (кроме Boolean и Character ) унаследованы от абстрактного класса Number и являются сравнимыми (реализуют интерфейс Comparable ). Иерархия, примерно, такая:
// существует несколько способов создания Integer i1 = new Integer("10"); Integer i2 = new Integer(10); Integer i3 = Integer.valueOf(10); Integer i4 = Integer.valueOf("10", 10); // можно указать систему счисления, только для оберток целочисленных примитивных типов Character c1 = new Character("c"); // тут только один способ // получаем значения примитивных типов int i5 = i1.intValue(); char c2 = c1.charValue();
Автоупаковка и распаковка
В версии JDK 5 были введены два важных средства:- Автоупаковка (autoboxing ) — процесс автоматического инкапсулирования примитивного типа в соответствующий класс-обертку. Отпадает необходимость явно создавать объект.
- Распаковка (unboxing ) — процесс автоматического извлечения примитивного типа с соответствующего класса-обертки. Отпадает необходимость явного вызова метода для получения примитивного типа.
Public static void main(String... s) { Integer i1 = 10; // автоупаковка - Integer.valueOf(10) int i2 = i1; // распаковка - i1.intValue() method(10); // автоупаковка в объект класса Integer - Integer.valueOf(10) ++i1; // распаковка - i1.intValue(), автоупаковка - Integer.valueOf(i1.intValue() + 1) } private static int method(Integer i) { return i; // распаковка объекта, принятого как параметр - i.intValue() }
Некоторые полезные методы
Integer i1 = 128; i1.compareTo(5); // 1, то есть i.intValue() > Integer.valueOf(5) Integer.decode("0xabc"); // не работает с двоичными литералами Integer.parseInt("10", 3); // работает с любой системой счисления // метод преобразования i1.byteValue(); // (byte)i.intValue() // методы проверки Float f = 20.5f; Boolean badFloat = f.isInfinite() || f.isNaN(); // false, автоупаковка boolean // преобразование в строку f.toString();Спасибо за внимание. Все дополнения, уточнения и критика приветствуются.
Переменная - это основной элемент хранения информации в Java- программе. Переменная характеризуется комбинацией идентификатора, типа и области действия. В зависимости от того, где объявлена переменная, она может быть локальной, например, для кода внутри метода, либо это может быть переменная экземпляра класса, доступная всем методам данного класса. Локальные области действия объявляются с помощью фигурных скобок.
1.1. Объявление переменных
Все переменные должны быть объявлены до первого их использования в программе. Основная форма объявления переменной такова:
тип идентификатор [ = значение] [, идентификатор [ = значение ]...];
Тип - это либо один из встроенных типов, либо имя класса или интерфейса. Ниже приведено несколько примеров объявления переменных различных типов. Обратите внимание на то, что некоторые примеры включают в себя инициализацию начального значения. Переменные, для которых начальные значения не указаны, автоматически инициализируются нулем.
Таблица 1.1. Объявление переменных различных типов
|
Вид переменной |
||
|
int а, b, с; |
Объявляет три целых переменных а, b, с |
|
|
int d = 3, е, f = 5; |
Объявляет еще три целых переменных, инициализирует d и f |
|
|
byte z = 22; |
Объявляет переменную z типа byte и инициализирует ее |
|
|
double pi = 3.14159; |
Объявляет переменную pi типа double и инициализирует ее числом пи |
|
|
char x = "x"; |
Символьная переменная х получает значение "х" |
Идентификатор – это наименование переменной. В качестве идентификатора может использоваться любая последовательность строчных и прописных букв, цифр и символов _ (подчеркивание) и $ (доллар). Идентификаторы не должны начинаться с цифры.
Значение - это любой литерал или выражение, результатом которого является значение того же (или совместимого с указанным в объявлении переменной) типа. В приведенном ниже примере создаются три переменные, соответствующие сторонам прямоугольного треугольника, а затем с помощью теоремы Пифагора вычисляется длина гипотенузы, в данном случае числа 5, величины гипотенузы классического прямоугольного треугольника со сторонами 3-4-5.
class
Variables {
public
static void main (String args ){
double a =
3;
double b =
4;
double c;
с
= Math.sqrt (a* a + b* b);
System.out.println ("c = "+ c);
}
1.2. Область видимости переменной
Блоки составных операторов в Java отмечаются парой фигурных скобок {}. Переменные в Java начинают действовать с того места в программе, где они объявлены до конца содержащего их блока. Блоки могут быть вложены друг в друга, и у каждого может быть свой собственный набор локальных переменных.
Давайте сегодня по-быстрому разберемся с типами в Java. Все типы в Java делятся на две группы — это примитивные и ссылочные типы.
Здесь будем разбираться с примитивными типами.
Ну пожалуй самый примитивный тип — это логический тип данных. Он же boolean — самый простой тип данных. Переменная такого типа может хранить лишь два значения: true (истина) или false (ложь). С переменными такого типа можно проводить следующие опреации: «!» — отрицание (not), «&&» — логическое И (and), «||» — логическое ИЛИ (or), «^» — исключающе ИЛИ (xor). Таблицы истинности для этих операций можно .
Дальше целочисленные типы данных. К ним в Java относятся следующие типы: byte , short , int и long . Каждый из этих типов принимает разный диапазон значений, объединяет их только то, что все значения всегда целочисленные. Так для типа byte интеравал от?128 до 127, для типа short от?32768 до 32767, для типа int от?2147483648 до 2147483647 ну и для типа long интервал от?9.2·10 18 до 9.2·10 18 . C ними все просто вычитаем, складываем, делим, умножаем…
Ну и конечно есть типы данных с плавающей запятой, дробные типы. Это float и тип с двойной точностью double . float принимает значения в диапазоне приблизительно от?3.4·10 38 до 3.4·10 38 , а double в диапазоне от?1.8·10 308 до 1.8·10 308 . Помимо этого, для этих типов существуют особые значения +? — плюс бесконечность, -? — минус бесконечность и NaN — не число (например при делении на 0).
Итак, если мы хотим объявить переменную какого-то типа, мы должны указать сначала ее тип, а потом ее имя:
Int i; float f;
Так же сразу можно указать начальное значение:
Int i = 0; float f = 3.5;
В Java используется неявное преобразование типов. Что это такое? Ну например вы хотите сложить две переменные одна типа int а другая типа float. Тогда ваша переменная типа int будет преобразована к типу float и только после этого произойдет сложение. Соответственно и результат получится типа float. При этом меньший тип всегда преобразуется к бльшему, а целое к дробному. Ну например вот это будет работать:
Int a = 3; float b = 4.5, c; с = a + b;
а вот это нет:
Int a = 3, c; float b = 4.5; с = a + b;
Здесь переменная в которую записывается результат имеет тип int, а сам результат получится типа float. Конечно можно привести один тип к другому вручную. Делается это вот так:
Int a = 3, c; float b = 4.5; c = (int) (a + b);
здесь с помошью записи (int) мы приводим сумму a и b к типу int. Однако понятно, что в целочисленной переменной с не может храниться значение 7.5. При приведении дробных типов к целым дробная часть просто откидывается . Это может послужить причиной некотороых ошибок, поэтому об этом не стоит забывать.
Java является объектно-ориентированным языком, которому свойственна абстракция, однако для прикладных задач всегда приходится оперировать известными параметрами. В программировании они называются переменными. Чем java переменная отличается от объекта?
Всё просто – переменная является ячейкой в памяти, где хранится её значение. Любое действие – прямая работа с этим участком памяти. Объект же является более комплексной величиной. Он занимает определённый диапазон памяти, взаимодействие осуществляется через некую передаточную функцию (методы), выраженную в параметрах объекта.
В данной статье мы поговорим именно о переменных, здесь это совсем не тривиальное понятие.
Объявляются переменные java так:
тип_данных имя_переменной;
Здесь же при объявлении можно присвоить значение.
тип_данных имя_переменной = значение_переменной;
Также можно объявить одновременно несколько переменных, просто перечисляя их через запятую.
тип_данных имя_переменной1, имя_переменной2…;
Классификация по принадлежности
Выделяется четыре типа java переменных:
- переменные экземпляра (instance variables);
- переменные класса (class variables);
- локальные переменные (local variables);
- параметры (parameters).
Пусть у нас есть несколько объектов одного класса Automobile(). Помимо общих параметров у них есть уникальные, скажем, максимальная скорость maxSpeed(). Их можно инициировать в теле программы, а можно хранить в нестатических полях класса (объявленных без добавления слова static). Таким образом, каждый экземпляр будет обладать индивидуальным параметром, не зависящим от скоростей других объектов.
public class Automobile { public String name; private double maxSpeed ; public Automobile (String autoName ){ name = autoName; }}Переменная класса, или статическая переменная java, напротив, объявляется исключительно с применением слова static. В данном случае её значение будет одинаковым для всех экземпляров. В случае того же автомобиля, введём параметр gearsNum – число передач. Для всех экземпляров оно будет равно 6.
Необязательный модификатор final позволяет присвоить значение переменной только один раз. За соблюдением этого следит компилятор.
public class Automobile { public String model ; private double maxSpeed ; public static final int gearsNum = 6 ; }Локальные переменные и методы в java неизменно связаны. В последних часто фигурируют вспомогательные параметры, которые в дальнейшем коде не нужны. Для объявления локальной переменной нет особой формы инициализации, границы её действия зависят лишь от места объявления. В данном случае - в фигурных скобках внутри метода. При выходе из него переменная будет уничтожена, поэтому обратиться к ней будет уже нельзя.
Крайний случай локальных переменных - это параметры. В частности, классический пример «Hello, World!»:
class HelloWorld { public static void main (String args ) { System . out. println("Hello World!" ); } }Здесь сразу два параметра. Первая - собственно, «Hello, World!», вторая - аргумент строки args в main.
Классификация по видимости
На основании описанного выше, можно проследить ещё одно деление – по видимости переменных. Существует 4 группы:
- Public. Данный модификатор переменных доступен всем классам и объектам программы. Объявляется при помощи ключевого слова public в начале строки.
- Protected. Области видимости java переменных в этом случае ограничены текущим пакетом и подклассами. Объявляется аналогично - ключевым словом protected.
- Package protected. Модификатор переменных, доступных только внутри пакета. Объявления не требуется, отсутствие ключевых слов указывает на package protected.
- Private. Переменные, доступные исключительно внутри класса. В данном случае, определить тип переменной можно по ключевому слову private.
Несмотря на то, что приватные элементы доступны внутри класса, вопрос: «как обращаться к private java переменным?» всё же имеет ответ. Для того, чтобы иметь возможность извне поменять значение приватного параметра, достаточно внутри того же класса создать публичный метод. Например так:
class Drive { private int gears; public void setGears (int val ) { gears = val; } }Таким образом, в случае необходимости вы легко сможете изменить значение private переменной.
Указатели - ещё один вариант глобальных переменных. Вспомните, для создания экземпляра объекта мы используем следующую запись:
класс_объекта имя_указателя = new класс_объекта;
Такие переменные называются ссылочными переменными.
