Тема 2.19 Ключевое слово final
Переменная может быть объявлена как final (окончательная). Это позволяет предотвратить изменение содержимого переменной. Это означает, что переменная типа final должна быть инициализирована во время ее объявления. Например:
final int FILE_NEW = 1; final int FILE_OPEN = 2; final int FILE_SAVE = 3; final int FILE_SAVEAS = 4; final int FILE_QUIT = 5;
Теперь все последующие части программы могут пользоваться переменной FILE_OPEN и прочими так, как если бы они были константами, без риска изменения их значений.
В практике программирования на Java принято идентификаторы всех переменных типа final записывать прописными буквами. Переменные, объявленные как final, не занимают отдельную область памяти для каждого экземпляра – т.е., по сути, они являются константами.
Ключевое слово final можно применять также к методам, но в этом случае его значение существенно отличается от применяемого к переменным. Это второе применение ключевого слова final описано в главе, посвященной наследованию.
Задания:
Напишите класс Животные, содержаний поля – Имя, Возраст, Вес, Рост. Объявите три константы Возраст, Вес, Рост в которые запишите пороговые значения. Создайте несколько объектов класса. Напишите конструктор бес параметров и конструктор с параметрами. Напишите метод, выводящий все данные о животном на консоль. Метод, определяющий одинаковые ли имена у двух животных. Метод, сравнивающий поля объекта с пороговыми значениями Возраст, Вес, Рост (пример вывода : старше 5 лет; легче 2 кг; выше 20 см ).
Определите класс для комплексных чисел. Напишите методы для выведения числа в комплексном виде, сложения, вычитания и умножения комплексных чисел. Во все методы передается объекты.
Для тех, кто забыл комплексные числа
3) Определите класс для матриц. Напишите перегруженные конструктор для создания одномерной и двумерной матриц. В конструкторы передаются размерности матриц. (В конструктор для одномерной матрицы передается один параметр, для двумерной два). Напишите методы для выведения, сложения, вычитания и умножения матриц.
Тема 2.20 Аргументы переменной длины
В JDK 5 была добавлена новая функциональная возможность, которая упрощает создание методов, принимающих переменное количество аргументов. Эта функциональная возможность получила название varargs (сокращение термина variable-length arguments – аргументы переменной длины). Метод, который принимает переменное число аргументов, называют методом переменной арности, или просто методом varargs.
Ситуации, в которых методу нужно передавать переменное количество аргументов, встречаются не так уж редко. Например, метод, который открывает подключение к Internet, может принимать имя пользователя, пароль, имя файла, протокол и тому подобное, но применять значения, заданные по умолчанию, если какие-либо из этих сведений опущены. В этой ситуации было бы удобно передавать только те аргументы, для которых заданные по умолчанию значения не применимы. Еще один пример – метод printf (), входящий в состав библиотеки ввода-вывода Java. До появления версии J2SE 5 обработка аргументов переменной длины могла выполняться двумя способами, ни один из которых не был особенно удобным. Во-первых, если максимальное количество аргументов было небольшим и известным, можно было создавать перегруженные версии метода – по одной для каждого возможного способа вызова метода. Хотя этот способ подходит для ряда случаев, он применим только к узкому классу ситуаций.
В тех случаях, когда максимальное число возможных аргументов было большим или неизвестным, применялся второй подход, при котором аргументы помещались в массив, а затем массив передавался методу. Листинг 2.23 иллюстрирует этот подход.
Листинг 2.23
// Использование массива для передачи методу переменного
// количества аргументов. Это старый стиль подхода
// к обработке аргументов переменной длины.
public class PassArray {
public static void vaTest(int v[]) {
System.out.print("Количество аргументов: " + v.length + " Содержимое: ");
for (int x : v) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main(String args[]) {
// Обратите внимание на способ создания массива
// для хранения аргументов.
int nl[] = {10};
int n2[] = {1, 2, 3};
int n3[] = {};
vaTest(nl); // 1 аргумент
vaTest(n2); // 3 аргумента
vaTest(n3); // без аргументов
}
}
Эта программа создает следующий вывод:
Количество аргументов: 1 Содержимое: 10 Количество аргументов: 3 Содержимое: 1 2 3 Количество аргументов: 0 Содержимое:
В программе методу vaTest () аргументы передаются через массив v. Этот старый подход к обработке аргументов переменной длины позволяет методу vaTest () принимать любое число аргументов. Однако он требует, чтобы эти аргументы были вручную помещены в массив до вызова метода vaTest (). Создание массива при каждом вызове метода vaTest () не только трудоемкая, но и чреватая ошибками задача. Функциональная возможность использования методов varargs обеспечивает более простой и эффективный подход.
Для указания аргумента переменной длины используют три точки (...). Например, вот как метод vaTest () можно записать с использованием аргумента Переменной длины:
public static void vaTest(int ... v) {
Эта синтаксическая конструкция указывает компилятору, что метод vaTest () может вызываться с нулем или более аргументов. В результате v неявно объявляется как массив типа int []. Таким образом, внутри метода vaTest () доступ к v осуществляется с использованием синтаксиса обычного массива. Предыдущая программа с применением метода vararg приобретает следующий вид(листинг 2.24):
Листинг 2.24
public class VarArgs {
// теперь vaTest () использует аргументы переменной длины
public static void vaTest(int... v) {
System.out.print("Количество аргументов: " + v.length + " Содержимое: ");
for (int x : v) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main(String args[]) {
// Обратите внимание на возможные способы вызова
// vaTest () с переменным числом аргументов.
vaTest(10); //1 аргумент
vaTest(1, 2, 3); //3 аргумента
vaTest(); // без аргументов
}
}
Вывод этой программы совпадает с выводом исходной версии.
Отметим две важные особенности этой программы. Во-первых, как уже было сказано, внутри метода vaTest () переменная v действует как массив. Это обусловлено тем, что v является массивом. Синтаксическая конструкция ... просто указывает компилятору, что метод будет использовать переменное количество аргументов, и что эти аргументы будут храниться в массиве, на который ссылается переменная v. Во-вторых, в методе main () метод vaTest () вызывается с различным количеством аргументов, в том числе, и вовсе без аргументов. Аргументы автоматически помещаются в массив и передаются переменной v. В случае отсутствия аргументов длина массива равна нулю.
Наряду с параметром переменной длины массив может содержать "нормальные" параметры. Однако параметр переменной длины должен быть последним параметром, объявленным методом. Например, следующее объявление метода вполне допустимо:
int dolt(int a, int b, double с, int ... vals) {
В данном случае первые три аргумента, указанные в обращении к методу dolt (), соответствуют первым трем параметрам. Все остальные аргументы считаются принадлежащими параметру vals.
Помните, что параметр vararg должен быть последним. Например, следующее объявление записано неправильно:
int dolt (int a, int b, double с, int ... vals, boolean stopFlag) { // Ошибка!
В этом примере предпринимается попытка объявления обычного параметра после параметра типа vararg, что недопустимо.
Существует еще одно ограничение, о котором следует знать: метод должен содержать только одни параметр типа varargs. Например, следующее объявление также неверно:
int dolt (int a, int b, double с, int ... vals, double ... morevals) { // Ошибка!
Попытка объявления второго параметра типа vararg недопустима. Рассмотрим измененную версию метода vaTest (), которая принимает обычный аргумент и аргумент переменной длины в листинге 2.25.
Листинг 2.25
public class VarArgs {
// Использование- аргумента переменой длины совместно со стандартными аргументами.
//В этом примере msg – обычный параметр, a v – параметр vararg.
public static void vaTest(String msg, int... v) {
System.out.print(msg + v.length + " Содержимое: ");
for (int x : v) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main(String args[]) {
vaTest("Один параметр vararg: ", 10);
vaTest("Три параметра vararg: ", 1, 2, 3);
vaTest("Be3 параметров vararg: ");
}
}
Вывод это программы имеет вид:
Один параметр vararg: 1 Содержимое: 10 Три параметра vararg: 3 Содержимое: 12 3 Вез параметров vararg: 0
Метод, который принимает аргумент переменной длины, можно перегружать.
Типы его параметра vararg могут быть различными. Именно это имеет место в вариантах vaRest (int ...) и vaTest (boolean ...). Помните, что конструкция ... вынуждает компилятор обрабатывать параметр как массив указанного типа. Поэтому, подобно тому, как можно выполнять перегрузку методов, используя различные типы параметров массива, можно выполнять перегрузку методов vararg, используя различные типы аргументов переменной длины. В этом случае система Java использует различие в типах для определения нужного варианта перегруженного метода.
Второй способ перегрузки метода vararg – добавление обычного параметра. Именно это было сделано для vaTest (String, int ...). В данном случае для определения нужного метода система Java использует и количество аргументов, и их тип.
Метод, поддерживающий varargs, может быть перегружен также методом, который не поддерживает эту функциональную возможность. Например, в приведенной ранее программе метод vaTest () может быть перегружен методом vaTest (int х). Эта специализированная версия вызывается только при Наличии аргумента int. В случае передаче методу двух и более аргументов int программа будет использовать varargs-версию метода vaTest (int. . .v).
При перегрузке метода, принимающего аргумент переменной длины, могут случаться непредвиденные ошибки. Они связаны с неопределенностью, которая может возникать при вызове перегруженного метода с аргументом переменной длины. Например, рассмотрим следующую программу(листинг 2.26):
Листинг 2.26
// Аргументы переменной длины, перегрузка и неопределенность.
//Эта программа содержит ошибку, и ее компиляция
// будет невозможна!
public class VarArgs {
public static void vaTest(int... v) {
System.out.print("vaTest (int ...): " + "Количество аргументов: " + v.length + " Содержимое: ");
for (int x : v) {
System.out.print(x + " ");
}
System.out.println();
}
public static void vaTest(boolean... v) {
System.out.print("vaTest(boolean ...) " + "Количество аргументов: " + v.length + " Содержимое: ");
for (boolean x : v) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main(String args[]) {
vaTest(1, 2, 3); //OK
vaTest(true, false, false); // OK
vaTest(); // Ошибка: неопределенность!
}
}
В этой программе перегрузка метода vaTest () выполняется вполне корректно. Однако ее компиляция будет невозможна из-за следующего вызова:
vaTest (); // Ошибка: неопределенность!
Поскольку параметр типа vararg может быть пустым, этот вызов может быть преобразован в обращение к vaTest (int . . .) или к vaTest (boolean . . .). Оба варианта допустимы. Поэтому вызов принципиально неоднозначен.
Рассмотрим еще один пример неопределенности. Следующие перегруженные версии метода vaTest () изначально неоднозначны, несмотря на то, что одна из них принимает обычный параметр:
static void vaTest(int ... v) { // ...
} static void vaTest(int n, int ... v) { //... } Хотя списки параметров метода vaTest () различны, компилятор не имеет возможности разрешения следующего вызова:
vaTest(1)
Должен ли он быть преобразован в обращение к vaTest (int . ..) с одним аргументом переменной длины или в обращение к vaTest (int, int . ..) без аргументов переменной длины? Компилятор не имеет возможности ответить на этот вопрос. Таким образом ситуация неоднозначна.
Из-за ошибок неопределенности, подобных описанным, в некоторых случаях придется пренебрегать перегрузкой и просто использовать два различных имени метода. Кроме того, в некоторых случаях ошибки неопределенности служат признаком концептуальных изъянов программы, которые можно устранить путем более тщательного построения решения задачи.
Задание:
Напишите методы с переменным числом параметров:
1). выводящий все параметры на консоль,
2). вычисляющий сумму всех параметров,
3). произведение всех параметров,
4). сортирующий параметры по возрастанию.