Тема 8 Работа со строками, Коллекции Java, Обработка ошибок

Работа со строками
В языке C string представляет собой массив 8bit characters, который заканчивается 0
 В Java strings - объекты типа String, с
соответствующими методами для их обработки.
String greeting = "hello";
greeting = new String("hello");
 Знак (+) простой способ конкатенации строк:
print("Name: " + p.getName());

Работа со строками
2
В пакет java.lang встроен класс, инкапсулирующий
структуру данных, соответствующую строке.

Класс String - объектное представление
неизменяемого символьного массива (статические
строки).
 В этом классе есть методы, которые позволяют
сравнивать строки, осуществлять в них поиск и
извлекать определенные символы и подстроки.
 Класс StringBuffer /StringBiulder используется тогда,
когда строку после создания требуется изменять
(динамические строки).

Работа со строками
String() — создается объект с пустой строкой;
2. String (String str) — из одного объекта создается
другой
3. String (StringBuffer str) — преобразованная копия
объекта класса StringBuffer;
4. String (byte[ ] byteArray) — объект создается из
массива байтов byteArray (ASCII);
5. String (char [ ] charArray) — объект создается из
массива charArray символов Unicode;
6. String (byte [ ] byteArray, int offset, int count) —
объект создается из части массива байтов byteArray,
начинающейся с индекса offset и содержащей count
байтов;
31.
07.05.2016
Основные методы string





length() возвращает длину строки.
charAt Возвращает символ, полученный через индекс в
строке.
Substring() Возвращает часть строки.
indexOf() Возвращает позицию первого вхождения
символа или строки в строку.
lastIndexOf Возвращает позицию последнего вхождения
символа или строки в строку.
String sample = "catalog";
System.out.println(sample.length());
-7
System.out.println(sample.charAt(0));
-c
System.out.println(sample.charAt(sample.length()1)); - g
System.out.println(sample.substring(0,3));
-
StringBuffer (StringBuilder) - попутно




После создания объекта String его содержание не может
быть изменено. Функциональность классов StringBuffer
и StringBuilder предназначена для создания и обработки
динамической информации в строках, т.е. модификации
содержимого строк. Методы класса – одинаковы.
StringBuffer может хранить количество символов,
определенное его размером. Если
StringBuffer расширяется, то автоматически расширяется
пространство для дополнительных символов.
Класс StringBuffer также используется для реализации
операций конкатенации + и += для String .
StringBuilder может использоваться при синхронизации
различными данных потоками (thread), что требует
дополнительных накладных расходов (overhaed).
Пример использования
Итак, часто нужно добавить одну строку к другой, что можно сделать с
помощью метода append :
StringBuffer buffer = new StringBuffer();
buffer.append("World class");
buffer.append(" buffering mechanism!");
Ниже пример ввода строки в buffer:
buffer.insert(6,"C");
 Еще пример:
StringBuffer buffer;
buffer = new StringBuffer();
buffer.append("World lass");
buffer.append(" buffering mechanism!");
buffer.insert(6,"C");
System.out.println(buffer.toString());
 Получим результат:
World Class buffering mechanism!

Java Collections - коллекции



Большинство реальных приложений имеют дело с
коллекциями вещей: файлы, переменные, записи
файлов, результирующие наборы данных и т.д.
Язык Java имеет сложную библиотеку поддержки
коллекций (Collections Framework), которая
позволяет создавать и управлять коллекциями
объектов различных типов.
Мы, конечно, не сможем рассмотреть все аспекты
Java Collections, но введем понятия наиболее
используемых классов и приступим к их
использованию.
Массивы - Arrays



Большинство языков программирования включают
понятие массива, который содержит коллекцию
вещей и, естественно, Java – не исключение.
Массив – коллекция элементов одного типа.
Можно объявить массив двумя способами:
Создать его определенного размера, который
фиксирован для времени жизни массива
 Создать его с определенным набором начальных
значений. Размер этого набора начальных значений
определяет размер массива – он будет достаточен для
содержания всех значений и его размер фиксируется
на время жизни массива.

Объявление массива
Синтаксис объявления массива:
new elementType [arraySize] в т.ч. объекты
int intAry[]; //память не выделяется
int[] intAry; // так тоже можно
Это описание переменной (или поля внутри класса) intAry — ссылки
на массив
 Инициализируется ранее описанный массив
 intAry = new int[] {1,2}; // инициализация
 // создается пустой массив из 5 элементов:
int[] integers = new int[5];
// создается массив из 5 элементов со значениями:
int[] integers = new int[] { 1, 2, 3, 4, 5 };
int intAry[] = {1, 2, 3, 4};// допустимо без new
 Начальные значения помещаются в фигурные скобки через
запятую.
 int[] massis = getInts(); где метод описан int[] getInts() { … return …}
Многомерные массивы
10




Они строятся по принципу "массив массивов".
Массив является объектом, имеющим методы.
Двумерный массив — это массив ссылок на
объекты-массивы.
Трехмерный массив — это массив ссылок на
массивы, которые, в свою очередь, являются
массивами ссылок на массивы.
Многомерные массивы
11
Пример: создать массив целых 3*3.

Вариант 1. (явное создание)
int ary[][] = new int [3][3];
Вариант 2. (использование списка
инициализации)
int ary[][] = new int [][] {
{1, 1, 1},
{2, 2, 2},
{1, 2, 3},
};

Многомерные массивы
static final int ROWS = 2;
static final int COLS = 3;
int grades[][] = new int[ROWS][COLS];
grades[0][0] = 0;
grades[0][1] = 1;
grades[0][2] = 2;
grades[1][0] = 3;
grades[1][1] = 4;
grades[1][2] = 5;
for (int rows = 0; rows < ROWS; rows++) {
for (int cols = 0; cols < COLS; cols++) {
System.out.printf("%d ", grades[rows][cols]);
}
System.out.println();
}
Многомерные массивы
13


Можно создать “рваный” , “непрямоугольный”
многомерный массив, потому что
многомерный массив является массивом
ссылок на массивы.
Т.е. каждый массив следующего уровня
является самостоятельным массивом и может
иметь свой размер
Многомерные массивы
1.
14
2.
int ary[][] = new int [][] {
{1, 1, 1, 1},
{2, 2, 2},
{1, 2, 3, 4, 5},
};
int ary[][] = new int [3][];
ary[0] = new int [5];
ary[1] = new int [2];
ary[2] = new int [6];
Многомерные массивы
Присваивание и копирование
int ary[][] = new int[][] {
{1, 1, 1, 1},
{2, 2, 2},
{1, 2, 3, 4, 5},
};
int copyAry[][] = ary; //массив тот же

copyAry — это не ссылка на копию массива, а
еще одна ссылка на тот же массив

15
Создание массивов – непростой путь

Трудный путь для создания массивов - создать
его, а затем в цикле инициализировать:
int[] integers = new int[5];
for (int i= 0; i < integers.length; i++)
{integers[i] = i; }
Если вы попытаетесь обратиться к более чем 5
элементам - Java runtime обидится и выдаст т.н.
Exception – исключение, о которых поговорим
позже.
Загрузка массива
public static void print(String s) {
System.out.println(s);
}
Для загрузки массива следует образовать цикл в
integers от 1 до длины массива (которая получается
вызовом метода .length массива) и в этом случае вы
цикл остановится на 5.
 Как только массив загружен, к нему можно
обращаться по индексу:
for (int i = 0; i < integers.length; i++)
{print("integer's value "+i+" is: " + integers[i]);}
 Или, начиная с JDK 5 и выше (сейчас 8), (Iterableinterface - итерабельны )
for (int i : integers) {// integers – имя массива
print(" integer's value : " + i); }
//Правда, несколько проще? Пробегает значения
всего массива, но индекс не контролируется

Индекс элемента массива





Доступ к каждому элементу массива
обеспечивается через указание index элемента
массива:
element = arrayName [elementIndex];
Для доступа к элементу массива необходимо
сослаться на массив (по его имени) и указать index
где элемент размещается.
Массив имеет поле length, которое определяет его
размер
Массивы в Java начинаются с нуля. Так, первый
элемент в массиве array размещается в array[0], а
последний в - array[array.length - 1].
Выход за границы массива вызывает исключение
IndexOutOfBoundException).
Массив объектов




Массивы могут содержать объекты – поэтому массив
в языке Java – наиболее часто употребляемая
коллекция.
Создание массива объектов java.lang.Integer не сильно
отличается от создания массива простых типов. Опять
же, это можно сделать двумя способами:
// создается пустой массив на 5 элементов:
Integer[] integers = new Integer[5];
// создается массив из 5 элементов со значениями:
Integer[] integers = new Integer[] { Integer.valueOf(1),
Integer.valueOf(2) Integer.valueOf(3) Integer.valueOf(4)
Integer.valueOf(5)};
Методы класса Array - пример
Класс Arrays
обеспечивает методы,
такие как sort -сортируют
массив,, binarySearch –
поиск в отсортированном
массиве, equals для
сравнения массивов и fill
для помещения значений
в массив
Упаковка и распаковка

Мы уже говорили, что каждый примитивный
тип в Java имеет соответствующий класс в JDK:
Каждый класс JDK
обеспечивает методы для
проверки и конвертирования
внутреннего представления в
соответствующий примитивный
тип и наоборот.
int value = 238;
Integer boxedValue =
Integer.valueOf(value);
И обратное преобразование:
Integer boxedValue = Integer.valueOf(238);
int intValue = boxedValue.intValue();
Автоматическая упаковка и распаковка
Вообще говоря, нет необходимости упаковывать и
распаковывать примитивы явно – можно
использовать автоматическое преобразование
(autoboxing и auto-unboxing):
int intValue = 238;
Integer boxedValue = intValue;
//
intValue = boxedValue;
 Однако не рекомендуют использовать autoboxing и
auto-unboxing, поскольку это может привести к
проблемам – код с преобразованием выглядит
более очевидным и читаемым и стоит
дополнительных усилий.

Анализ и преобразование типов

Упакованные (wrapper ) классы JDK содержат методы
для преобразования из/в String:
String characterNumeric = "238“;
Integer convertedValue =
Integer.parseInt(characterNumeric); и обратно:
Integer boxedValue = Integer.valueOf(238);
String characterNumeric = boxedValue.toString();
Интерфейсы Collection

Основные интерфейсы (теперь-то вы знаете, что
такое интерфейс) collection инкапсулируют
различные типы коллекций. Они представляют
абстрактные данные, которые являются частью
collections framework. Поскольку они являются
интерфейсами, то сами не обеспечивают
реализацию (implementation)! Т.е. нельзя на их
основе создать класс.
Интерфейсы





Интерфейсы – основа для т.н. контракта - класс, который
реализует интерфейс обязан выполнять все обязательства,
определенные в интерфейсе, т.е реализовать все методы.
В терминах Java, класс, который реализует интерфейс
должен реализовать все методы, определенные
интерфейсом.
Содержит подготовленные структуры данных, интерфейсы и
алгоритмы для обработки этих структур данных
Используя коллекции, программист использует
существующие структуры данных, не заботясь о том, как
они реализованы
http://docs.oracle.com/javase/7/docs/technotes/guides/collecti
ons/index.html
public interface List<E>
extends Collection<E>
public interface List<E> extends Collection<E> {
// Positional access
E get(int index);
E set(int index, E element);
//optional
boolean add(E element);
//optional
void add(int index, E element); //optional
E remove(int index);
//optional
boolean addAll(int index,
Collection<? extends E> c); //optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
// Range-view
List<E> subList(int from, int to);
}





Collection - корневой интерфейс в иерархии, из
которого получаются интерфейсы Set, Queue и
List
Set Коллекция, не содержащая дубликатов.
List Упорядоченная коллекция , содержащая
дубликаты.
Map Связывает ключи со значениями и не
может содержать дубликаты ключей.
Queue Обычно коллекция FIFO (first-in, first-out),
которая моделирует обслуживание очереди;
могут быть определены другие порядки
возможности (LIFO,…)
Архитектура классов collection
SortedSet
TreeSet
Set
AbstractSet
Collection
HashSet
LinkedHashSet
Vector
Stack
AbstractCollection
AbstractList
List
ArrayList
AbstractSequentialList
Concrete Classes
Abstract Classes
Interfaces
SortedMap
Map
TreeMap
AbstractMap
Interfaces
LinkedList
Abstract Classes
HashMap
Concrete Classes
LinkedHashMap
Lists - Списки





List – конструкция коллекций (collection), которая по
определению представляет собой упорядоченную коллекцию,
также известную как sequence (последовательность)
Поскольку List упорядочен, можно полностью управлять тем,
куда помещаются его элементы. Коллекция List может
содержать только объекты, и строго регламентирует их
поведение.
List является интерфейсом( interface) и поэтому не может
образовываться непосредственно. В большинстве случаев
можно использовать реализацию (implementation) ArrayList:
List<Object> listOfObjects = new ArrayList<Object>();
Отметим, что мы назначили объект ArrayList переменной типа
List . Язык Java позволяет присваивать переменную одного
типа переменной другого типа, если справа переменная
подкласса или интерфейс, реализующий переменную.(См.
след слайд)
Формальный тип



<Object> в приведенном выше фрагменте кода это формальный тип, что указывает компилятору
на то, что список List содержит коллекцию
типа Object, то есть в список List можно помещать
какие угодно объекты.
Если нужно ужесточить ограничения на то, что
можно или нельзя помещать в список List, это
определение следует переписать так:
List<Person> listOfPersons = new ArrayList<Person>();
Теперь список List может содержать только
экземпляры класса Person.
Использование списков

Использовать списки очень легко, как и коллекции Java в
целом. Вот некоторые из вещей, которые можно делать
со списками:



поместить что-либо в список;
запросить размер списка в данный момент;
извлечь данные из списка. (существуют другие методы:
Давайте попробуем некоторые из них. Вы уже видели,
как создать экземпляр List, создав экземпляр его типа
реализации ArrayList , так что с этого и начнем.
 Чтобы поместить что-то в список List, нужно вызвать
метод add([int index,] variable) :
List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
 Метод add() добавляет элемент в конец списка.
 Можно указать индекс, указывающий место размещения
элемента: listOfIntegers.add(2, Integer.valueOf(253));
Возможна IndexOutOfBoundsException ошибка

Использование списков


Чтобы узнать длину списка, нужно вызвать
метод size() :
List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
print("Current List size: " + listOfIntegers.size());
Чтобы извлечь элемент из списка, нужно вызвать
метод get(int index) и передать ему индекс
требуемого элемента:
List<Integer> listOfIntegers = new ArrayList<Integer>();
listOfIntegers.add(Integer.valueOf(238));
print("Item at index 0 is: " listOfIntegers.get(0));
Пример работы с List
Перебираемая коллекция


Если коллекция реализует интерфейс java.lang.Iterable,
она называется перебираемой (iterable) коллекцией.
Это означает, что можно начать с одного конца и
перебрать всю коллекцию, элемент за элементом.
Мы уже рассматривали специальный синтаксис для
итерации по коллекциям, которые реализуют
интерфейс Iterable. Еще раз:
for (objectType varName : collectionReference) {
// Начинаем сразу с использования ObjectType (через
varName)... }
Перебор элементов List


List<Integer> listOfIntegers = obtainSomehow();
for (Integer i : listOfIntegers) {
print("Integer value is : " + i); }
Иначе:
List<Integer> listOfIntegers = obtainSomehow();
for (int i = 0; i < listOfIntegers.size(); i++) {
Integer i = listOfIntegers.get(i);
print("Integer value is : " + i); }
В первом фрагменте используется сокращенный синтаксис: в нем
нет индексной переменной (в данном случае i) для
инициализации и нет вызова метода get() по отношению к List.
Пример ForEach
Sets - Наборы



Набор (Set) – это коллекция, которая, по определению,
содержит уникальные элементы – без дубликатов. Если List
может содержать одни и те же объекты, то Set может
содержать данный объект только один раз. Коллекция
Set может содержать только объекты и строго
регламентирует их поведение.
Поскольку Set является интерфейсом, нельзя создать его
экземпляр непосредственно, рассмотрим один из способов
его реализации: HashSet. HashSet прост в использовании и
напоминает List.
Вот некоторые из операций, которые можно делать
с набором:




поместить что-то в набор; boolean add([index,] variable)
спросить, насколько велик набор в данный момент size();
извлечь данные из набора get(int index) .
существуют другие методы: boolean remove(Object o), toArray,…)
Использование наборов



Отличительной особенностью набора является то, что он гарантирует
уникальность своих элементов, но не заботится о порядке их расположения.
Можно было бы ожидать, что набор Set состоит из семи элементов, но на
самом деле в нем только пять, потому что объект Integer со
значением 30 будет добавлен только один раз.
При этом при переборе наборов
порядок не гарантируется:
Maps - Отображения



Отображение (Map) – это удобная коллекция, которая
позволяет связать один объект (ключ), с другим (значение).
Естественно, ключ отображения должен быть уникальным, и он
используется для последующего извлечения значений.
Коллекция Java Map может содержать только объекты и строго
регламентирует их поведение.
Поскольку Map является интерфейсом, нельзя создать его
экземпляр непосредственно, и рассмотрим один из способов
его реализации: HashMap.
Вот некоторые операции, которые можно проводить
с отображениями:



поместить что-то в Map put (String key, value) ;
извлечь что-то из Map variable get(String key);
получить Set ключей к Map для его перебора keySet().
Использование Map
Чтобы поместить что-то
в Map, нужно иметь объектключ и объект-значение.
В этом
примере Map содержит
объекты типа Integer с
ключом типа String, который
служит их строковым
представлением. Чтобы
получить определенное
значение Integer, требуется
его строковое представлени
ею.
Использование Set совместно с Map

В некоторых случаях приходится перебирать весь
набор элементов Map. Для этого
понадобится Set ключей к Map:
Set<String> keys = mapOfIntegers.keySet();
for (String key : keys) {
Integer value = mapOfIntegers.get(key);
print("Value keyed by " + key + " is " + value ); }
Map не возвращает своих ключей в List , потому что
каждый ключ уникален, а уникальность – признак Set.
Метод toString() класса Integer, извлекаемый из Map,
вызывается автоматически и преобразует key
Инструкция
1. Внутри метода main перед циклом for each , create List с
помощью конструктора ArrayList с именем sports,
который содержит тип String .
2. Добавьте "Football" к sports.
3. Затем добавьте "Boxing" к sports.
4. В цикле for each в коде пропущен код, который должен
выполняться. Внутри цикла for each введите введите :
System.out.println(sport);
5. Раскомментировать и вставить заголовок для цикла for
each, с использованием метода keySet для majorCities
Тип Generic





Введение обобщенного типа (generic) в JDK 5
Generic - это т.н. параметризованные типы.
Основным мотивом введения generic-ов в Java
было неудобство работы с нетипизированными
коллекциями.
До 5 версии JDK был List без типов (теперь
List<тип>
Использование нетипизированных коллекций
приводит к большим трудозатратам и ошибкам,
которые обнаруживаются только во время
исполнения.

Обобщенные типы - это механизм
компилятора, посредством которого можно
стандартным образом создавать и использовать
типы (классов, интерфейсов и т.п.), получая
единый код и параметризуя все остальное,
таким образом, что для использования
необходимо конкретизировать тип для работы с
классом.
java.util.ArrayList.
ArrayList arrayList = new ArrayList();
arrayList.add("Hello, world!");
arrayList.add(new Integer(10));
arrayList.add("Congratulate you!");

Просто ArrayList (без типа)
Пример ошибки в runtime

generic-и улучшают
проверку типов при
компиляции и,
следовательно, такие
ошибки приведения типов
выявляются на этапе
компиляции, а не во время
исполнения.
Параметризованный тип состоит из
имени класса или интерфейса X и
секции параметров <T1, T2, ..., Tn>,
которая должна соответствовать числу
объявленных параметров
private
void
printCollection(Collection <String> c)
public class ArrayList<E> extends AbstractList<E>
{
implements
List<E>,
RandomAccess,
Cloneable,
for (String s : c) {
Serializable
System.out.println("Item: "+s);
{
}
// ...
}
}
Параметризованные классы и методы

следующие критерии необходимости параметризация
класса:
Базовый класс находится в центре некоторой обертки: то есть
"некоторая сущность", находящаяся в центре класса может
применяться широко, и окружающие эту сущность элементы
(например, атрибуты), идентичны; (например,
разрабатывается пакет предназначен для выполнения
унифицированных действий вне зависимости от сущности)
 Предполагается общее поведение: независимо от этого
«некоторая сущность», которая находится в центре класса, в
значительной мере выполняются одни и те же операции.
(действия с сущностью регламентны)
 Коллекция отвечает следующим требованиям: 1. Collection
операции (add, remove, size, clear и т.п.) не зависят от типа

Параметризованный List


Код создания List в синтаксисе типов выглядит
следующим образом:
List<E> listRef = new concreteListClass<E>();
Здесь символ E (или любой другой), который
означает Element, и есть как раз та "некоторая
сущность", а concreteListClass - это
инициализированный класс JDK. JDK включает в
себя несколько реализаций List<E>, но мы
будем использовать ArrayList<E>.
Пример параметризованного класса

Применить этот
класс для работы
с Person
Исключения - Exceptions



Ни одна программа никогда не работает правильно в
100% случаев, и разработчики языка Java учли это.
Рассмотрим встроенный в платформу Java
механизмам обработки ситуаций, когда код работает
не совсем так, как планировалось.
Исключение - это событие, которое происходит во
время выполнения программы, нарушая нормальный
ход выполнения ее инструкций.
Все исключения в Java являются объектами. Поэтому
они могут порождаться не только автоматически при
возникновении исключительной ситуации, но и
создаваться самим программистом.
Иерархия классов исключений:

Исключения делятся на несколько классов, но
все они имеют общего предка — класс
Throwable. Его потомками являются подклассы
Исключения (Exceptions)
Exception и Error.
являются результатом
проблем в программе,
которые в принципе решаемы
и предсказуемы. Например,
произошло деление на ноль в
целых(Errors)
числах.представляют
Ошибки
собой более серьёзные
проблемы, которые, не следует
пытаться обрабатывать в
собственной программе,
поскольку они связаны с
Типы исключений




Контролируемые исключения (checked)
Неконтролируемые исключения (unchecked), к
которым относятся ошибки (Errors)
Исключения времени выполнения
(RuntimeExceptions), потомок класса Exception
Контролируемые исключения представляют собой
ошибки, которые можно и нужно обрабатывать в
программе, к этому типу относятся все потомки класса
Exception (но не RuntimeException). Они проверяются
компилятором (то есть компилятор проверяет, что
ваш код где-то обрабатывает их, а Eclipse будет этому
способствовать).



Обработка исключений ― важная часть Javaпрограммирования. По сути, вы помещаете свой код в
блок try (что означает: "попробуем так и посмотрим,
вызовет ли это исключение") и используете его для
вылавливания исключений разного типа.
Обработка исключения может быть произведена с
помощью операторов try…catch, либо передана
внешней части программы.
Например, метод может передавать возникшие в нём
исключения выше по иерархии вызовов, сам его не
обрабатывая.
Пример RuntimeException
Неконтролируемые исключения не требуют
обязательной обработки, однако, при желании,
можно обрабатывать исключения класса
RuntimeException.
class Main {
public static void main(String[] args) {
int a = 4;
System.out.println(a/0);
}
}
Exception in thread "main" java.lang.ArithmeticException:
/ by zero
at Main.main(Main.java:4)

Обработка ошибки

class Main {
public static void main(String[] args) {
int a = 4;
try {
System.out.println(a/0);
} catch (ArithmeticException e) {
System.out.println("Произошла
недопустимая арифметическая операция");
}
}
}
Обработка исключений
общая форма блока обработки исключений.
try {

…. // блок кода } // Exception e; можно создать объект
throw(e) // возбуждение исключения
catch (ТипИсключения1 е) {
// обработчик исключений типа
// ТипИсключения1 }
catch (ТипИсключения2 е) {
// обработчик исключений типа
//ТипИсключения2
throw(e) // повторное возбуждение
//исключения }
finally { }

Обработка исключений



Сначала выполняется код, заключенный в фигурные
скобки оператора try.
Если во время его выполнения не происходит никаких
нештатных ситуаций, то далее управление передается
за закрывающую фигурную скобку последнего
оператора catch, ассоциированного с данным
оператором try.
Если в пределах try возникает исключительная
ситуация, то далее выполнение кода производится по
одному из нижеперечисленных сценариев:
Обработка исключений




Производится выполнение блока кода,
ассоциированного с данным catch
Если код в этом блоке завершается нормально, то и
весь оператор try завершается нормально.
Если код в catch завершается нештатно, то и весь try
завершается нештатно по той же причине.
Если возникла исключительная ситуация, класс
которой не указан в качестве аргумента ни в одном
catch, то выполнение всего try завершается нештатно.
Обработка исключений


Оператор finally предназначен для того, чтобы
обеспечить гарантированное выполнение какого-либо
фрагмента кода, вне зависимости от того, возникла ли
исключительная ситуация
Если блок finally завершается ненормально, то весь try
завершится ненормально по той же причине.
Обработка исключений
Программист сам может явно сгенерировать
ошибку с помощью оператора throw.
public int calculate (int theValue)
throws Exception {
if( theValue < 0) {
throw new Exception( "Some
descriptive info");
}
}




Блоки try, catch и finally вместе образуют “капкан
для ловли исключений".
Сначала код, который может вызвать исключение,
заключается в оператор try.
Если это срабатывает, управление сразу передается
блоку catch, или обработчику исключений. Когда
оба оператора выполнены, управление передается
блоку finally, независимо от того, имело ли место
исключение.
"Поймав" исключение, можно попытаться
аккуратно обойти его или же выйти из программы
(или метода), выводя соответствующее сообщение.