Текст книги "Java: руководство для начинающих (ЛП)"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 14 (всего у книги 36 страниц)
Когда метод вызывает самого себя, в системном стеке распределяется память для новых локальных переменных и параметров, и код метода выполняется с этими новыми переменными и параметрами с самого начала. При рекурсивном вызове метода не создается его новая копия, но лишь используются его новые аргументы. А при возврате из каждого рекурсивного вызова старые локальные переменные и параметры извлекаются из стека, и выполнение возобновляется с точки вызова в методе. Рекурсивные методы можно сравнить по принципу действия с постепенно сжимающейся и затем распрямляющейся пружиной.
Рекурсивные варианты многих процедур могут выполняться немного медленнее, чем их итерационные эквиваленты, из-за дополнительных затрат системных ресурсов на неоднократные вызовы метода. Если же таких вызовов окажется слишком много, то в конечном итоге может быть переполнен системный стек. А поскольку параметры и локальные переменные рекурсивного метода хранятся в системном стеке и при каждом новом вызове этого метода создается их новая копия, то в какой-то момент стек может оказаться исчерпанным. Если возникнет подобная ситуация, исполняющая система Java сгенерирует исключение. Но в большинстве случаев об этом не стоит особенно беспокоиться. Как правило, переполнение системного стека происходит тогда, когда рекурсивный метод выходит из под контроля.
Главное преимущество рекурсии заключается в том, что она позволяет реализовать некоторые алгоритмы яснее и проще, чем итерационным способом. Например, алгоритм быстрой сортировки довольно трудно реализовать итерационным способом. А некоторые задачи, например искусственного интеллекта, очевидно, требуют именно рекурсивного решения. При написании рекурсивных методов следует непременно указать в соответствующем месте условный оператор, например if, чтобы организовать возврат из метода без рекурсии. В противном случае возврат из вызванного однажды рекурсивного метода может вообще не произойти. Подобного рода ошибка весьма характерна для реализации рекурсии в практике программирования. Поэтому рекомендуется пользоваться операторами, содержащими вызовы метода println (), чтобы следить за происходящим в рекурсивном методе и прервать его выполнение, если в нем обнаружится ошибка. Применение ключевого слова static
Иногда требуется определить такой член класса, который будет использоваться независимо от всех остальных объектов этого класса. Как правило, доступ к члену класса организуется посредством объекта этого класса, но в то же время можно создать член класса для самостоятельного применения без ссылки на конкретный экземпляр объекта. Для того чтобы создать такой член класса, достаточно указать в самом начале его объявления ключевое слово static. Если член класса объявляется как static, он становится доступным до создания любых объектов своего класса и без ссылки на какой-нибудь объект. С помощью ключевого слова static можно объявлять как переменные, так и методы. Наиболее характерным примером члена типа static служит метод main (), который объявляется таковым потому, что он должен вызываться виртуальной машиной Java в самом начале выполняемой программы.
Для того чтобы воспользоваться членом типа static за пределами класса, достаточно указать имя этого класса с оператором-точкой. Но создавать объект для этого не нужно. В действительности член типа static оказывается доступным не по ссылке на объект, а по имени своего класса. Так, если требуется присвоить значение 10 переменной count типа static, являющейся членом класса Timer, то для этой цели можно воспользоваться следующей строкой кода: Timer.count = 10;
Эта форма записи подобна той, что используется для доступа к обычным переменным экземпляра посредством объекта, но в ней указывается имя класса, а не объекта. Аналогичным образом можно вызвать метод типа static, используя имя класса и оператор-точку.
Переменные, объявляемые как static, по существу являются глобальными. Когда же объекты объявляются в своем классе, копия переменной типа static не создается. Вместо этого все экземпляры класса совместно пользуются одной и той же переменной типа static. Ниже приведен пример программы, демонстрирующий отличия переменной, объявленной как static, от обычной переменной экземпляра. // Применение статической переменной, class StaticDemo { int х; // обычная переменная экземпляра static int у; // статическая переменная – это одна копия, // совместно используемая всеми объектами. // возвратить сумму значений переменной экземпляра х и // статической переменной у. int sum() { return х + у; } } class SDemo { public static void main(String args[]) { StaticDemo obi = new StaticDemo(); StaticDemo ob2 = new StaticDemo(); // У каждого объекта имеется своя копия переменной экземпляра, obl.x = 10; ob2.х = 20; System.out.println("Of course, obl.x and ob2.x " + "are independent."); System.out.println("obi.x: " + obl.x + "nob2.x: " + ob2.x); System.out.println() ; // Все объекты совместно пользуются одной общей // копией статической переменной. System.out.println("The static variable у is shared."); StaticDemo.y = 19; System.out.println("Set StaticDemo.y to 19."); System.out.println("ob1.sum() : " + obl.sum()); System.out.println("ob2.sum(): " + ob2.sum()); System.out.println(); StaticDemo.y = 100; System.out.println("Change StaticDemo.y to 100"); System.out.println("ob1.sum() : " + ob1.sum()); System.out.println("ob2.sum(): " + ob2.sum()); System.out.println(); } }
Выполнение этой программы дает следующий результат: Of course, obl.x and ob2.x are independent, obl.x: 10 ob2.x: 20 The static variable у is shared. Set StaticDemo.y to 19. obi.sum(): 29 ob2.sum(): 39 Change StaticDemo.y to 100 obi.sum(): 110 ob2.sum(): 120
Нетрудно заметить, что статическая переменная у используется как объектом obi, так и объектом оЬ2. Изменения в ней оказывают влияние на весь класс, а не только на его экземпляр.
Метод типа static отличается от обычного метода тем, что его можно вызывать по имени его класса, не создавая экземпляр объекта этого класса. Пример такого вызова уже приводился ранее. Это был метод sqrt () типа static, относящийся к классу Math из стандартной библиотеки классов Java. Ниже приведен пример программы, в которой объявляется статическая переменная и создается метод типа static. // Применение статического метода, class StaticMeth { static int val = 1024; // статическая переменная // Статический метод, static int valDiv2() { return val/2; } } class SDemo2 { public static void main(String args[]) { System.out.println("val is " + StaticMeth.val); System.out.println("StaticMeth.valDiv2(): " + StaticMeth.valDiv2()); StaticMeth.val = 4; System.out.println("val is " + StaticMeth.val); System.out.println("StaticMeth.valDiv2(): " + StaticMeth.valDiv2()); } }
Выполнение этой программы дает следующий результат: val is 1024 StaticMeth.valDiy2() : 512 val is 4 StaticMeth.valDiv2(): 2
На применение методов типа static накладывается ряд следующих ограничений.
В методе типа static допускается непосредственный вызов только других методов типа static.
Для метода типа static непосредственно доступными оказываются только другие данные типа static, определенные в его классе.
В методе типа static должна отсутствовать ссылка this.
В приведенном ниже классе код статического метода valDivDenom () создан некорректно. class StaticError { int denom =3; // обычная переменная экземпляра static int val = 1024; // статическая переменная /* Ошибка! К нестатическим переменным нельзя обращаться из статического метода. */ static int valDivDenom() { return val/denom; // не подлежит компиляции! } } Статические блоки
Иногда для подготовки к созданию объектов в классе должны быть выполнены некоторые инициализирующие действия. В частности, может возникнуть потребность установить соединение с удаленным сетевым узлом или задать значения некоторых статических переменных перед тем, как воспользоваться статическими методами класса. Для решения подобных задач в Java предусмотрены статические блоки. Статический блок выполняется при первой загрузке класса, еще до того, как класс будет использован для каких-нибудь других целей. Ниже приведен пример применения статического блока. // Применение статического блока, class StaticBlock { static double root0f2; static double root0f3; // Этот блок выполняется при загрузке класса. static { System.out.println("Inside static block."); root0f2 = Math.sqrt(2.0); rootOf3 = Math.sqrt(3.0); } StaticBlock(String msg) { System.out.println (msg) ; } } class SDemo3 { public static void main(String args[]) { StaticBlock ob = new StaticBlock("Inside Constructor"); System.out.println("Square root of 2 is " + StaticBlock.rootOf2); System.out.println("Square root of 3 is " + StaticBlock.rootOf3) ; } }
Результат выполнения данной программы выглядит следующим образом: Inside static block. Inside Constructor Square root of 2 is 1.4142135623730951 Square root of 3 is 1.7320508075688772
Как видите, статический блок выполняется еще до того, как будет создан какой-нибудь объект.
Пример для опробования 6.3. Быстрая сортировка
В главе 5 был рассмотрен простой способ так называемой пузырьковой сортировки, а кроме него, вкратце упоминались и более совершенные способы сортировки. В этом проекте предстоит реализовать один из самых лучших способов: быструю сортировку. Алгоритм быстрой сортировки был разработан Ч. Хоаром и назван его именем. На сегодняшний день это самый лучший универсальный алгоритм сортировки. Он не был продемонстрирован в главе 5 лишь потому, что реализовать быструю сортировку лучше всего с помощью рекурсии. В данном проекте будет создана программа для сортировки символьного массива, но демонстрируемый подход может быть применен к сортировке любых объектов.
Быстрая сортировка опирается на принцип разделения. Сначала выбирается опорное значение (так называемый компаранд), и массив разделяется на две части. Все элементы, которые больше или равны разделяемому компаранду, помещаются в одну часть массива, а те элементы, которые меньше компаранда, – в другую часть. Затем процесс рекурсивно повторяется для каждой оставшейся части до тех пор, пока массив не окажется отсортированным. Допустим, имеется массив, содержащий последовательность символов f edacb, а в качестве компаранда выбран символ d. На первом проходе массив будет частично упорядочен следующим образом: Исходные данные f e d a с b Проход 1 b с a d e f
Этот процесс повторяется для каждой части: Ьса и def. Как видите, процесс рекурсивен по своей сути, поэтому рекурсивный способ лучше всего подходит для реализации быстрой сортировки.
Компаранд можно выбрать двумя способами: случайно либо вычислив среднее значение части элементов массива. Эффективность сортировки окажется оптимальной в том случае, когда компаранд выбран как раз посредине диапазона значений элементов, содержащихся в массиве, но зачастую выбрать такое значение непросто. Если же выбрать компаранд случайным образом, то вполне возможно, что он окажется на краю диапазона. Но и в этом случае алгоритм быстрой сортировки будет действовать правильно. В том варианте быстрой сортировки, который реализуется в данном проекте, в качестве компаранда выбирается элемент, находящийся посередине массива.
Последовательность действий
Создайте новый файл QSDemo. j ava.
Создайте сначала класс Quicksort, код которого приведен ниже. // Пример для опробования 6.3. Простая версия класса Quicksort, // реализующего быструю сортировку, class Quicksort { // организовать вызов конкретного метода быстрой сортировки static void qsort(char items[]) { qs(items, 0, items.length-1); } // Рекурсивная версия метода быстрой сортировки символов, private static void qs(char items[], int left, int right) { int i, j; char x, y; i = left; j = right; x = items[(left+right)/2]; do { while((items[i] < x) && (i < right)) i++; while((x < items[j]) && (j > left)) j—; if(i <= j) { у = items[i]; items[i] = items[j]; items[j] = y; i++; j—; } } while (i <= j); if(left < j) qs(items, left, j); if(i < right) qs(items, i, right); } }
Для упрощения интерфейса в классе Quicksort предоставляется метод qsort (), из которого вызывается метод qs (), фактически выполняющий сортировку. Такой подход позволяет выполнять сортировку, передавая методу лишь имя массива и не осуществляя первоначальное разделение. А поскольку метод qs () используется только в классе, он определяется как private.
Для того чтобы воспользоваться классом Quicksort, достаточно вызвать метод Quicksort. qsort (). Этот метод определен как static, и поэтому для его вызова достаточно указать имя класса, а создавать объект не обязательно. По завершении работы этого метода массив будет отсортирован. Данная версия программы работает только с символьными массивами, но вы можете адаптировать ее для сортировки массивов любого типа.
Ниже приведен весь исходный код программы, демонстрирующей применение класса Quicksort. // Пример для опробования 6.3. Простая версия класса Quicksort, // реализующего быструю сортировку, class Quicksort { // организовать вызов конкретного метода быстрой сортировки static void qsort(char items[]) { qs(items, 0, items.length-1); } // Рекурсивная версия метода быстрой сортировки символов, private static void qs(char items[], int left, int right) { int i, j; char x, y; i = left; j = right; x = items[(left+right)/2]; do { while((items[i] < x) && (i < right)) i++; while((x < items[j]) && (j > left)) j—; if(i <= j) { у = items[i]; items[i] = items[j]; items[j] = y; i++; j—; } } while (i <= j); if(left < j) qs(items, left, j); if(i < right) qs(items, i, right); } } class QSDemo { public static void main(String args[]) { char a [ ] = { 'd 'x', 'a', 'r', 'p 'j', 'i' }; int i; System.out.print("Original array: "); for(i=0; i < a.length; i++) System.out.print(a[i]) ; System.out.println(); // отсортировать массив Quicksort.qsort(a); System.out.print("Sorted array: "); for(i=0; i < a.length; i++) System.out.print(a[i]); } } Вложенные и внутренние классы
В Java определены вложенные классы. Вложенным называется такой класс, который объявляется в другом классе. Вложенные классы не относятся к базовым языковым средствам Java. Они даже не поддерживались до появления версии Java 1.1, хотя с тех пор часто применяются в реальных программах, и поэтому о них нужно знать.
Вложенный класс не может существовать независимо от объемлющего класса, потому что последний ограничивает область его действия. Если вложенный класс объявлен в пределах области действия объемлющего класса, он становится членом последнего. Имеется также возможность объявить вложенный класс, который станет локальным в пределах блока.
Существуют два типа вложенных классов. Одни вложенные классы объявляются с помощью модификатора доступа static, а другие – без него. В этой книге будет рассматриваться только нестатический вариант вложенных классов. Классы такого типа называются внутренними. Внутренний класс имеет доступ ко всем переменным и методам внешнего (т.е. объемлющего) класса и может обращаться к ним непосредственно, как и все остальные нестатические члены внешнего класса. Иногда внутренний класс используется для предоставления услуг объемлющему классу. Ниже приведен пример применения внутреннего класса для вычисления различных значений в объемлющем его классе. // Применение внутреннего класса, class Outer { int nums[]; Outer(int n[]) { nums = n; } void Analyze() { Inner inOb = new Inner(); System.out.println("Minimum: 11 + inOb.minO); System.out.println("Maximum: " + inOb.maxO); System.out.println("Average : " + inOb.avgO); } // Внутренний класс. class Inner { int min() { int m = nums[0]; for (int i=l; i < nums.length; i++) if(nums[i] < m) m = nums[i]; return m; } int max() { int m = nums[0]; for (int i=l; i < r^urns. length; i++) if(nums[i] > m) m = nums[i]; return m; } int avg() { int a = 0; for(int i=0; i < nums.length; i++) a += nums[i]; return a / nums.length; } } } class NestedClassDemo { public static void main(String args[]) { int x[] = { 3, 2, 1, 5, 6, 9, 7, 8 }; Outer outOb = new Outer(x); outOb.Analyze(); } }
Результат выполнения данной программы выглядит следующим образом: Minimum: 1 Maximum: 9 Average: 5
В данном примере внутренний класс Inner обрабатывает массив nums, являющийся членом класса Outer. Как упоминалось выше, вложенный класс имеет доступ к членам объемлющего класса, и поэтому он может непосредственно обращаться к массиву nums. А вот обратное не справедливо. Так, например, метод analyze () не может непосредственно вызвать метод min (), не создав объект типа Inner.
Как упоминалось выше, класс можно вложить в области действия блока. В итоге получается локальный класс, недоступный за пределами блока. В следующем примере программы класс ShowBits, созданный в примере для опробования 5.3, преобразуется таким образом, чтобы стать локальным. // Применение класса ShowBits в качестве локального, public static void main(String args[]) { class LocalClassDemo { // Внутренний вариант класса ShowBits. // Локальный класс, вложенный в метод. class ShowBits { int numbits; ShowBits(int n) { numbits = n; } void show(long val) { long mask = 1; // сдвинуть влево для установки единицы в нужной позиции mask <<= numbits-1; int spacer = 0; for(; mask != 0; mask >»= 1) { if((val & mask) != 0) System.out.print("1"); else System, out .pri-nt ("0") ; spacer++; if((spacer % 8) ==0) { System.out.print(" "); spacer = 0; } } System.out.println() ; } } for(byte b = 0; b < 10; b++) { ShowBits byteval = new ShowBits(8); System.out.print(b + " in binary: "); byteval.show(b); } } }
Выполнение этой программы дает следующий результат: 0 in binary: 00000000 1 in binary: 00000001 2 in binary: 00000010 3 in binary: 00000011 4 in binary: 00000100 5 in binary: 00000101 6 in binary: 00000110 7 in binary: 00000111 8 in binary: 00001000 9 in binary: 00001001
В данном примере класс ShowBits недоступен за пределами метода main (), а следовательно, попытка получить доступ к нему из любого метода, кроме main (), приведет к ошибке.
И последнее замечание: внутренний класс может быть безымянным. Экземпляр безымянного, или анонимного, внутреннего класса создается при объявлении класса с помощью оператора new. Безымянные внутренние классы будут подробнее рассмотрены в главе 15. Аргументы переменной длины
Иногда оказываются полезными методы, способные принимать переменное число аргументов. Например, методу, устанавливающему соединение с Интернетом, могут понадобиться имя и пароль пользователя, имя файла, протокол и другие параметры. Если при вызове метода какие-нибудь из этих данных не указаны, то должны использоваться значения по умолчанию. В таком случае было бы уместнее передавать только те аргументы, для которых не предусмотрены значения по умолчанию. А для этого требуется метод, поддерживающий список аргументов переменной, не фиксированной длины.
Раньше для поддержки переменного числа аргументов применялись два способа, причем оба были далеки от совершенства. Первый способ состоял в следующем: если максимальное число аргументов невелико и известно заранее, то можно создать разные варианты одного метода. Очевидно, что такой подход применим лишь в отдельных случаях. Если же значений оказывалось слишком много или их максимальное количество не было известно заранее, то применялся второй способ: параметры помещались в массив, который и передавался методу. Обоим этим способам присущи определенные недостатки, и со временем стало ясно, что требуется какой-то другой, более совершенный подход к решению данной задачи.
В версии JDK 5 появились языковые средства Java, упрощающие создание методов, которым требуется переменное число аргументов. Эти средства называются аргументами переменной длины, а метод, принимающий переменное число аргументов,– методом переменной арности, или же методом с аргументами переменной длины. Список параметров, соответствующих аргументам переменной длины, имеет не фиксированную, а переменную длину. Поэтому метод с аргументами переменной длины может принимать произвольно изменяющееся число аргументов. Общие положения об аргументах переменной длины
Для указания на то, что метод может принимать переменное число аргументов, в его объявление включается многоточие (...)• Ниже приведен пример метода vaTest (), принимающего переменное число аргументов. // Метод vaTest() с аргументами переменной длины. // Объявление списка аргументов переменной длины. static void vaTest(int ... v) { System.out.println("Number of args: " + v.length); System.out.println("Contents: "); for(int i=0; i < v.length; i++) System.out.println(" arg " + i + ": " + v[i]); System.out.println(); }
Обратите внимание на следующий синтаксис объявления аргумента v: int ... v
Этот синтаксис сообщает компилятору, что метод vaTest () может вызываться с указанием произвольного числа аргументов, в том числе и совсем без них. Более того, аргумент v неявно объявляется как массив типа int [ ]. А в теле метода vaTest () доступ к аргументу v осуществляется с помощью обычного синтаксиса обращения к массивам.
Ниже приведен весь исходный код примера программы, демонстрирующего метод vaTest () в действии. // Демонстрация метода с аргументами переменной длины, class VarArgs { // Метод vaTest() с аргументами переменной длины, static void vaTest(int ... v) { System.out.println("Number of args: " + v.length); System.out.println("Contents: ") ; for(int i=0; i < v.length; i++) System.out.println(" arg " + i + ": " + v[i]); System.out.println(); } public static void main(String args[]) { // Метод vaTest() может вызываться с переменным числом аргументов. vaTest(10); // 1 аргумент vaTest(l, 2, 3); // 3 аргумента vaTest(); // без аргументов } }
Выполнение этой программы дает следующий результат: Number of args: 1 Contents: arg 0: 10 Number of args: 3 Contents: arg 0: 1 arg 1: 2 arg 2: 3 Number of args: 0 Contents:
В приведенной выше программе обращает на себя внимание следующее. Во-первых, как пояснялось выше, обращение к аргументу v в методе vaTest () осуществляется как к массиву. Дело в том, что он действительно является массивом. Многоточие в объявлении этого метода указывает компилятору на использование переменного числа аргументов и на необходимость поместить их в массив v. Во-вторых, при обращении к методу vaTest () в методе main () указывается разное число аргументов, включая и вызов данного метода вообще без аргументов. Указываемые аргументы автоматически помещаются в массив v. Если же аргументы не указаны, длина этого массива будет равна нулю.
Помимо аргумента переменной длины, в методе можно также указывать и обычные аргументы, но при одном условии: аргумент переменной длины должен быть указан последним. Например, приведенное ниже объявление метода является вполне допустимым, int dolt(int a, int b, double с, int ... vals) {
В данном случае первые три аргумента, передаваемые при вызове метода dolt (), будут соответствовать первым трем параметрам. А остальные аргументы будут считаться относящимися к параметру переменной длины vals.
Ниже приведен переработанный вариант метода vaTest (), в котором используются как обычные аргументы, так и аргументы переменной длины. // Использование аргументов переменной длины // вместе с обычными аргументами, class VarArgs2 { // Здесь msg – обычный аргумент, // a v – аргумент переменной длины. static void vaTest(String msg, int ... v) { System.out.println(msg + v.length); System.out.println("Contents: ") ; for(int i=0; i < v.length; i++) System.out.println(" arg " + i + ": " + v[i]); System.out.println(); } public static void main(String args[]) { vaTest("One vararg: ", 10); vaTest ("Three varargs: ", 1, 2, 3); vaTest("No varargs: "); } }
Выполнение этого фрагмента кода дает следующий результат: One vararg: 1 Contents: arg 0: 10 Three varargs: 3 Contents: arg 0: 1 arg 1: 2 arg 2: 3 No varargs: 0 Contents:
He следует, однако, забывать, что аргумент переменной длины должен быть указан последним. Например, следующее объявление метода недопустимо: int dolt(int a, int b, double с, int ... vals, boolean stopFlag) { // Ошибка!
В данном примере сделана попытка указать обычный аргумент после аргумента переменной длины.
Существует еще одно ограничение, которое следует соблюдать: аргументы переменной длины можно указать в методе только один раз. Например, приведенное ниже объявление метода составлено неверно. int dolt(int a, int b, double с, int ... vals, double ... morevals) { // Ошибка!
Ошибкой в данном случае является попытка указать два разных типа аргументов переменной длины. Перегрузка методов с аргументами переменной длины
Если требуется, то метод, принимающий переменное число аргументов, можно перегрузить. Например, в следующей программе трижды перегружается метод vaTest (): // Перегрузка метода с аргументами переменной длины, class VarArgs3 { // Первый вариант метода vaTest(). static void vaTest(int ... v) { System.out.println("vaTest (int ...): " + "Number of args: " + v.length); System.out.println("Contents: ") ; for(int i=0; i < v.length; i++) System.out.println(" arg " + i + ": " + v[i]); System.out.println(); } // Второй вариант метода vaTest(). static void vaTest(boolean ... v) { System.out.println("vaTest(boolean ...): " + "Number of args: " + v.length); System.out.println("Contents: ") ; for(int i=0; i < v.length; i++) System.out.println(" arg " + i + ": " + v[i]); System.out.println(); } // Третий вариант метода vaTest(). static void vaTest(String msg, int ... v) { System.out.println("vaTest(String, int ...): " + msg + v.length); System.out.println("Contents: ") ; for (int i=0; i < v.length; i++) System.out.println(" arg " + i + ": " + v[i]); System.out.println(); } public static void main(String args[]) { vaTest(1, 2, 3) ; vaTest("Testing: ", 10, 20); vaTest(true, false, false); } }
Выполнение этой программы дает следующий результат: vaTest(int ...): Number of args: 3 Contents: arg 0: 1 arg 1: 2 arg 2: 3 vaTest(String, int ...): Testing: 2 Contents: arg 0: 10 arg 1: 20 vaTest(boolean ...): Number of args: 3 Contents: atg 0: true arg 1: false arg 2: false
В приведенном выше примере программы демонстрируются два способа перегрузки методов с аргументами переменной длины. Во-первых, типы параметров аргументов длины у перегружаемых методов могут отличаться. Это демонстрируют варианты метода vaTest (int . . .) и vaTest (boolean . . .). Напомним: многоточие обозначает, что соответствующий аргумент должен рассматриваться как массив указанного типа. Следовательно, как и при перегрузке обычных методов указываются разные типы параметров, так и перегрузке методов с аргументами переменной длины задаются разные типы подобных аргументов. Исполняющая система Java использует эти данные для правильного выбора вызываемого метода.
Второй способ перегрузки методов с аргументами переменной длины состоит в добавлении обьгчных аргументов. Он реализован в варианте метода vaTest (String, int . . .). В этом случае исполняющая система Java использует для выбора нужного варианта метода данные как о числе параметров, так и об их типах. Аргументы переменной длины и неоднозначность
При перегрузке методов с аргументами переменной длины может возникнуть довольно неожиданная ошибка. А возникает она вследствие неоднозначности в выборе метода. Рассмотрим в качестве примера следующую программу: // Перегрузка метода с аргументами переменной длины //и неоднозначность выбора метода. // //В этой программе имеется ошибка, и // поэтому она не будет компилироваться, class VarArgs4 { // Использование аргумента переменной длины типа int. static void vaTest(int ... v) { // ... } // Использование аргумента переменной длины типа boolean. static void vaTest(boolean ... v) { // ... } public static void main(String args[]) { vaTest(1, 2, 3); // OK vaTest(true, false, false); // OK vaTest(); // Ошибка вследствие неоднозначности! } }
В этой программе перегрузка метода vaTest () указана правильно, но она не компилируется. И причиной тому служит следующий вызов: vaTest(); // Ошибка: неоднозначность вызова!
Переменное число аргументов подразумевает в том числе и нулевое их число, и поэтому приведенный выше вызов может быть интерпретирован и как 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 . . .) без аргументов переменной длины? В итоге возникает неоднозначная ситуация.
Вследствие ошибок, подобных описанным выше, в ряде случаев приходится отказываться от перегрузки и присваивать методам разные имена. Кроме того, ошибки неоднозначности вскрывают концептуальные просчеты в программировании, которые можно исправить, более тщательно обдумав структуру программы. Упражнение для самопроверки по материалу главы 6
Допустим, имеется следующий фрагмент кода:class X { private int count; Является ли допустимым приведенный ниже фрагмент кода?class Y { public static void main(String args[]) { X ob = new X(); ob.count = 10;.
Модификатор доступа должен __ объявлению члена класса.
Помимо очереди, в программах часто используется структура данных, которая называется стеком. Обращение к стеку осуществляется по принципу “первым пришел – последним обслужен44. Стек можно сравнить со стопкой тарелок, стоящих на столе.Последней берется тарелка, поставленная на стол первой. Создайте класс Stack, реализующий стек для хранения символов. Используйте методы push () и pop () для манипулирования содержимым стека. Пользователь класса Stack должен иметь возможность задавать размер стека при его создании. Все члены класса Stack, кроме методов push () и pop (), должны быть объявлены как private. (.Подсказка: в качестве заготовки можете воспользоваться классом Queue, изменив в нем лишь способ доступа к данным.)
