Переменные и типы

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

int i;

указывает, что переменная i предназначена для хранения целых чисел ограниченного диапазона (от -2³¹ = -2147483648 до 2³¹-1 = 2147483647).

Java использует типы двух видов: простые и ссылочные. Простые типы - это числа, символы и логические величины, а ссылочные - это объекты и массивы. Для объявления переменных простых типов используются следующие ключевые слова (это не полный список):

• boolean - логический, может принимать два значения true (истина) и false (ложь);
• char - символьный;
• int - целый;
• double - действительный.

Для каждого типа строго определенны наборы допустимых значений и разрешенных операций. Например, для типов int и double операция сложения определена, а для типа boolean - нет. Как правило, переменной одного типа нельзя присваивать значение другого:

// Ошибка, число должно быть целым
int i = 30.0; 

Из приведенного правила есть исключения: в языке Java, например, производится автоматическое преобразование из целого числа в действительное.

// автоматическое преобразование
double a = 1, b = 1.0; 

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

i = 2
j = 3
delta = i.to_f / j

int i = 2;
int j = 3;
double delta = (double) i / j;

Общий вид оператора преобразования типа в языке Java таков:

(имяТипа) операнд

Так, в следующем примере будет напечатано число 29.

double a = 29.99999; 
int i = (int) a;
System.out.println(i);

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

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

Пример
Создайте файл TestSwap.java, в который поместите следующую программу.

/* обмен значений двух переменных
 в Ruby: i, j = j, i
*/
class TestSwap {
 public static void main(String[] args) {
 int i, j, tmp;
 i = 10;
 j = 20;
 System.out.println("До обмена:");
 System.out.println(" i="+i+", j="+j);
 tmp = i;
 i = j;
 j = tmp;
 System.out.println("После обмена:");
 System.out.println(" i="+i+", j="+j);
 }
}

Язык Java, так же как и Ruby, поддерживает присваивание с операцией, имеющее аналогичный синтаксис. Достаточно часто в нем используются операции автоувеличения и автоуменьшения. Операция ++ увеличивает значение переменной на единицу, а операция -- уменьшает.

int i = 0;
int j = 1;
i++;
j--;
// i = 1, j = 0
System.out.println("i="+i+", j="+j);

Операндом автоувеличения и автоуменьшения не могут являться константы или выражения:

5++; // ошибка, работа с константой 
(j + i)++; // ошибка, работа с выражением

Используются две формы записи этих операций: постфиксная (i++) - увеличение значения операнда на единицу после его использования и префиксная (++i) - увеличение значения до использования.

Пример

class TestInc {
 public static void main(String[] args) {
 int i = 10, j = 10;
 int tmpi = i++; // постфиксная форма
 int tmpj = ++j; // префиксная форма

 // tmpi = 10, i = 11
 System.out.println("tmpi="+tmpi+", i="+i);
 // tmpj = 11, j = 11
 System.out.println("tmpj="+tmpj+", j="+j); 
 }
}

Пример
Следующая программа печатает число, получающееся при перестановке цифр сотен и единиц заданного трехзначного числа.

class TestNumber {
 public static void main(String[] args) {
 int number = 342;
 int n1, n2, n3;
 int answer;

 n1 = number / 100; // число сотен
 n2 = (number / 10) % 10; // число десятков
 n3 = number % 10; // число единиц
 answer = n3 * 100 + n2 * 10 + n1;
	 
 System.out.println("Исходное число равно "+number);
 System.out.println("Результат "+answer);
 }
}

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

В языке Java, как и в Ruby, используются строки (экземпляры класса String). Для них определена операция + (конкатенация), которая не только "склеивает" строку со строкой, но позволяет также "подклеить" к строке число или символ.

class TestString {
 public static void main(String[] args) {
 int a = 1;
 double b = 11.5;
 char c = 'c';
 String str = "Строка + ";
 str += "целое число: " + a + 
 ", действительное: " + b;
 System.out.println(str);
 // конкатенация внутри println
 System.out.println("a=" + a + ", b=" +
 b + ", c=" + c);
 }
} 	

Как видно из этого примера при задании символов (тип char) их заключают в апострофы.

Аналогично Ruby два подряд идущих символа \ внутри строки заменяются на один, а для размещения символа кавычки внутри строки его необходимо экранировать.

System.out.println("При\\вет");
System.out.println("Сегодня \"Вторник\"");

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