Типы данных, приведение, операции

В Java используется несколько типов данных (java types) :

• Целочисленные
• Вещественные
• Логические
• Строковые
• Примитивные

Целочисленные данные - byte, short, int, long

Пример применения целочисленных данных java - byte, short, int, long

public class Type
{
    public static void main (String [] arg)
    {
        int   i = 4 + 5;
        byte  b = -128 + 127;
        short s = 22223 + 1;
        long  l = 334+11232143;
        System.out.println (i);
        System.out.println (b);
        System.out.println (s);
        System.out.println (l);
    }
}

Вещественные типы данных - float, double

Пример применения вещественных типов данных java - float, double

public class DoubleFloat
{
    public static void main (String [] arg)
    {
        double b1 = 3.62; 
        double b2 = 4.12 + b1;
        float  pi = 3.14f;
        // При использовании типа float необходимо
        // использовать приведение типа, так как дробные 
        //  числа - это литералы типа double
        float pipi = (float) 3.14;
        double d = 27;
        double c = pi * d;
        System.out.println (c);
    }
}

Логический тип данных

Под логические значения в Java отводится тип boolean, которое может принимать только одно из двух возможных значений true (истина) и false (ложь).

Символьный тип данных - char

Для хранения символов в Java используется тип char размером 2 байта (16 бит). Диапазон значений варьируется от 0 до 65536.

Литералы java

2          // литерал типа int

010        // литерал типа int заданный в восьмеричной системе
           // счисления, признаком использования восьмеричной 
           // системы является нуль в начале числа, в
           // десятеричной системе это будет число 8
0x10       // литерал типа int заданный в шестнадцатеричной
           // системе счисления, признаком её использования 
           // является 0x в начале числа, в десятеричной
1.2        // системе это будет число 16 литерал типа double

2e5        // литерал типа double, записанный в научной
           // нотации, число после e надо воспринимать 
           // как показатель степени десятки, на которую 
           // умножается число указанное до e, т.е. в данном
           // случае записано число 2*10^5 = 200000

-1.23e-3   // литерал типа double, -1.23*10^-3 = -0.00123

2L         // литерал типа long, можно использовать
           // строчную букву l
2F         // литерал типа float, можно использовать
           // строчную букву f
2D         // литерал типа double, можно использовать
           // строчную букву d
2e-2f      // литерал типа float, численно равен 0.02

false      // литерал типа boolean

'a'        // литерал типа char — печатный символ, 
           // задаётся в одинарных кавычках
'\t'       // литерал типа char — специальный символ, не 
           // отображается в виде какого-либо значка на 
           // экране, но управляет выводом или его 
           // форматированием, например, данный символ 
           // добавляет в вывод символ табуляции (отступа)

'\u004D';  // литерал типа char заданный своим кодом в 
           // шестнадцатеричной системе счисления по 
           // кодовой таблице Unicode, данный код 
           // соответствует букве «M» 
"Россия"   // литерал класса String — строка символов, 
           // задаётся в двойных кавычках, может содержать
           // любые литералы типа char, в том числе состоять
           // из единственного символа или быть пустой

"При\nвет" // литерал класса String включающий спецсимвол \n,
           // обрывающий строку, при выводе на экран слоги 
           // «При» и «вет» разместятся на разных строках 
           // друг под другом

Переменная класса java

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

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

При создании (объявлении) переменных нужно указывать имя и тип каждой из них.

int aM;       // создали переменную aM типа int

double ch_PI; // создали переменную ch_PI типа double

int c, d;     // несколько переменных одного типа можно 
              // объявить в одной строке, перечислив их 
              // через запятую, в данном случае созданы
              // переменные c и d типа int

Язык Java чувствителен к регистру символов в идентификаторах, т.е. идентификаторы Chis, CHIS и cHiS — в Java различны. Внутри одного блока не может существовать несколько элементов с одинаковыми идентификаторами.

Операция java

Операция — это некое элементарное действие (например, сложение чисел), обозначаемое в языке Java заранее предопределенной последовательностью символов, которое может выполняться над одной или несколькими переменными и литералами.

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

Операция присваивания

Операция присваивания обозначается символом «=». Она вычисляет значение своего правого операнда и присваивает его левому операнду.

int a;
a = 5; // переменной a присвоили значение 5

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

Объявление переменной и определение её начального значения - инициализация переменных - можно совместить :

float k1 = 13.3;
boolean b1 = true, b2 = true, b3 = false; // и даже для нескольких переменных одного типа

Присваивать значение литералу — нельзя :

5 = a; // это ошибка, литералу нельзя присвоить значение

Если переменная располагается справа от оператора присваивания или используется как аргумент какого-то метода, то происходит чтение её значения (т. е. мысленно можно заменить переменную литералом, который в неё хранится на текущем шаге программы).

// переменной w будет присвоено значение a
int w = a;

// В консоле будет отображено значение w 
System.out.println(w);

Любой переменной до того, как она впервые будет использована для чтения — нужно присвоить какое-то значение, иначе, произойдёт ошибка компиляции. Значения можно не присваивать полям классов (им будут присваиваться значения по умолчанию, отражённые в таблице базовых типов).

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

int v, a, w = 5;
System.out.println(a=6);   // переменной a будет присвоено
                           // значение 6 и в консоле
                           // отображено 6
v = a = -3;                // переменным a и v будет 
                           // присвоено значение -3
System.out.println(v=a=w); // переменным a и v будет присвоено
                           // значение, взятое из w, оно же 
                           // будет выведено в консоль

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

При всём многообразии типов часто возникают ситуации, когда данные одного типа нужно преобразовать к другому типу.

Некоторые преобразования происходят неявно. Рассмотрим такой пример:

double a = 3;
System.out.println(a); // в консоле будет отображено 3.0

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

Java преобразовала целочисленное значение 3 в вещественное 3.0 самостоятельно, без явного участия разработчика. Такое преобразование (называемое также "приведение") типа данных называется неявным или автоматическим.

Оно происходит всякий раз, когда в процессе преобразования не могут потеряться какие-либо данные (т.е. когда преобразования производится к более универсальному типу: от коротких целых short к длинным целым long, от целых int к вещественным double и т.п.).

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

Например, если мы произведём следующее присваивание, то при попытке откомпилировать программу получим ошибку «возможна потеря точности»:

int a = 3.14; // ошибка possible loss of precision

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

Явное преобразование

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

int a = (int) 3.14;    // приведение типа 
System.out.println(a); // выведет в консоль 3

Такое преобразование с указанием целевого типа называется явным. Явное преобразование вещественного значения к целому типу происходит за счёт отбрасывания десятичной части (берётся только целая часть).

double b = 2.6;
int c = (int) (0.5 + b);       // можно применять 
                               // к целым выражениям
System.out.println(c);         // выведет 3
System.out.println((int)9.69); // выведет 9
System.out.println((int)'A') ; // выведет 65 — код символа «A»
System.out.println((double)3); // выведет 3.0

Явное преобразование может потребоваться также в тех случаях, когда значение типа позволяющего хранить большее количество знаков надо привести к типу, способному хранить меньшее количество знаков числа. Например, когда long надо преобразовать к short. О том, как происходят такие преобразования, будет рассказано далее при обсуждении принципов хранения данных в памяти компьютера.

Арифметические операции

Арифметические операции - это бинарные операции, в которых участвует два операнда числового типа.

+ складывает оба операнда и возвращает результат сложения.

- вычитает из первого операнда второй.

* перемножает операнды и возвращает результат.

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

% возвращает остаток от деления первого операнда на второй (иначе говоря, приводит первый аргумент по модулю второго). Напомним, что наименьший остаток при делении на любое натуральное n равняется нулю, а наибольший равняется n-1.

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

System.out.println(2+3);           // выведет 5

System.out.println(10%3);          // выведет 1 (остаток от
                                   // деления на целое число)
System.out.println(12%3);          // выведет 0

System.out.println(9/2);           // выведет 4

System.out.println(9/2.0);         // выведет 4.5

System.out.println(9d/2);          // выведет 4.5

System.out.println((double)7/2);   // выведет 3.5

System.out.println((double)(7/2)); // выведет 3.0, ведь к 
                                   // целым преобразуется уже
                                   // результат деления нацело

Приоритет операций

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

1. Умножение, деление, вычисление остатка.
2. Сложение и вычитание.
3. Присваивание.

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

System.out.println(7%3*4);   // выводится 4
System.out.println(4*7%3);   // выводится 1
System.out.println(4*(7%3)); // выводится 4

Хочется напомнить, что переменные типа char — хранят числовые значения (коды символов по кодовой таблице), а поэтому также могу участвовать в арифметических операциях. Рассмотрите следующий пример, учитывая, что десятичный код символа 'Q' равен 81:

int t;
t = 162/'Q';
System.out.println(t); // выводится 2