П2.2.2. Математические операции

Все обычные операции

(кто не знает что такое % - это есть вычисление остатка от

целочисленного деления, например

10 % 3 -> получится 1,

10,2 % 3 -> тоже 1)

увеличить на число и результат положить в ту же ячейку-переменную, откуда брали. Сокращают запись:

а=а+5; то же самое что а+=5;

Аналогично пишут для - % * /

 

Инкремент, например а=а+1;

++а = сначала увеличиваем переменную, потом можем

воспользоваться хранящимся в ней значением.

а++ = наоборот, сначала можем воспользоваться хранящимся

в переменной значением, потом увеличиваем ее на единицу;

 

Пример:

int a=5, b;

b=++a; // это значит в b попала шестерка

         // (сначала к 5 прибавилась 1, потом ее

         // использовали для занесения в ячейку "6")

 

 Аналогично есть "декремент"

--а или а--

(это все не сложно, нужно лишь привыкнуть и запомнить разные разности)

Сравнение

 (результат будет булевского типа)

< > =< >= ==

!= не равно

Пример

int a = 5;

int b = 6;

boolean c

c = а == b // в "с" будет-запишется false

 

Логические операции

|| или

! не

&& и

 

исчерпывающие примеры

true && true = true

true && false = false

false && true = false

false && false = false

 

true || true = true

true || false = true

false || true = true

false || false = false

 

!true = false

!false = true

Зачем это нужно? Для написания всяких сложных условий типа "если переменная А меньше того-то, но больше сего-то, тогда

П2.2.3. Исключительные ситуации (exeptions)

Прежде чем погибнуть по причине ошибки, программа создает "исключения". Это объекты - экземпляры какого-нибудь класса из подклассов java.lang.Throwable Класс Throwable содержит строку сообщения String. Много стандартных классов-наследников у Throwable.

Их (объекты-"исключения") можно перехватывать и обрабатывать, не давая совершиться чему-то страшному. Например вводим буквы вместо цифр в калькулятор. "Обработать искл.сит.", - значит понять что случилось, остановить программу и выдать сообщение, "не цифра!" например. Применяется конструкция

 

try{

  тут кусок программы способный

  привести к ошибкам

}catch(Exception e){

  тут кусок программы "что делать"

  когда ошибка произошла

}finally{

  что делать дальше независимо от результатов обработки в catch

  надеюсь далее будет пример

}

 

Имя "Exception" означает на самом деле ту самую искл. сит., которая произошла в классе, который мы вызвали из раздела Try{"тут кусок программы способный привести к ошибкам"}. Компилятор помнит, откуда был сделан вызов метода, далее в том же блоке try-catch приведшего к исключению, поэтому собственное имя искл.сит. не требуется, вполне годится общестандартное имя "Exception". Экземпляр класса Exception будет создан.

Исключительные ситуации можно создавать и искусственно. Для проверки неких условий. (оператор throw new "имя_Exception" <-[внутри try - catch]). Тут уже Исключ.сит. - это некий объект некоего нами названного класса (наследника класса "Exception"). И тут уже он (объект нашего класса-наследника) имеет собственное имя!

П2.3 Языковые конструкции Java

П2.3.1. Циклы

с предусловием

while (condition) {

do-some-actions; // if condition=false, ни разу действие не сделается

}

с после условием

do{

do-some-actions; // at least it'll be done once

} while (condition a verifier);

с перечислением

 

for (intitialisation; condition; modification){

do-some-actions;

}

Пример:

for (int i = 0; i < 7; i++){

можно на самом деле инициализировать одну переменную, а наращивать другую и проверять третью, а можно и вообще какое-то условие пропустить (но обязательно его указать пустым местом, то есть поставить соответствующую ему точку с запятой!. Как вы помните, i++ означает i=i+1

Еще можно перечислять несколько переменных в каждом разделе for оператор break можно использовать во всех этих циклах (его пишут предварив его if(условие) тогда break

Еще есть оператор continue - пропускает текущую итерацию и продолжает цикл. Пример

Пример:

for (int i=-3; i<3; i++){

if (i==0) continue;       // нельзя делить на ноль

float a = 5/i;            // вообще-то если в Java делить на ноль,

}                         // получиться спец_значение inf (некая константа

                          // равная самому большому числу из возможных

                          // вещественных чисел

Тут i живет только внутри цикла, а вот а - видна снаружи и после завершения цикла не пропадает. Пример однако глупый, потому что промежуточные значения а нигде не останутся.. но это только пример на циклы.

П2.3.2. Условный переход

Все программерство стоит на условных переходах вроде такого "если условие верно, то делай это, если нет - делай то" Короче говоря "Если.. то.." Или по иностранному (все как в языке C)

if (условие) {

действие; // действие м/б одно или куча

...     // если действие одно, фигурные скобки можно не писать

действие;

}

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

if (проверяемое условие или логическая переменная){

действие; 

...

действие;

}else{

действие; 

...

действие; // вместо действия могут быть вложенные if

}

Конструкция switch - выбор значений переменной из списка вариантов

switch (value){

case value1: do_this;

           break;    // срочный выход из цикла

case value2: do_this;

case value3: разные операторы;

default: еще операторы;

}

П2.3.3. Массивы

Это тоже объекты. В отличие от других типов, в библиотеке явно нет стандартного класса от Sun, из которых они создаются. Но оператор new используется и все делается похоже на создание других объектов.

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

int a[];

int[] a;

2) выделить память и указать сколько ячеек в массиве:

a=new int[5];

Все ячейки пронумерованы начиная с нуля. Обращаться к каждой можно используя квадратные скобки. А что тут объектного? Вот что: у объекта "массив" есть одно-единственное свойство length - длина массива в ячейках. Ее читают соответствующим методом-функцией. Длина обозначена числом типа int (long нельзя).

Массивы только одномерные. Подобие многомерности получается путем создания массива из массивов. В ячейке массива сидит массив (причем они разномерные и более того..)

Все массивы "динамические". Значит ли это, что они могут менять свою длину в процессе работы? НЕТ! Массив после создания можно только уничтожить (длина станет null). Слово "динамический" означает, что память под массив можно выделить в любом месте программы (а не заранее!) и память только в том месте программы - на том этапе работы программы - и выделится. Удобно вообще-то: если у вас огромный массив, то память он начнет загромождать не заранее, а только когда он понадобится.

Как еще можно создавать массивы? Можно сразу ему присвоить начальное значение. Длина будет такая, сколько значений указали:

int a[] = {7, 21, 85}; // слово new тут не нужнО

Многомерные массивы:

Объявим "массив с цифрами float в ячейках"

float a[][];

Инициализируем его:

float a[][] = new float [4][2]; // матрица 4 х 2

Разномерный массив:

float a[][] = new float [4][];

Не сказано какой длины будут висеть наборы ячеек из каждой из 4-х ячеек "первого" массива (массива массивов). Это первое new не выделяет память, а только создает некие указатели. Далее нужно написать для выделения памяти:

a[0] = new float[3]; - в первую ячейку положили массив длиной "три"...

Про массивы все. Очень нехарактерно для Java то, что в классе массив есть всего один метод. Есть еще класс Вектор, там методов полно, но есть и расплата - вектор медленно работает. Обычно в классах по не одному десятку методов.

П2.3.4. Подпрограммы

Все. Зачем все вышеназванное нужно? Все оно используется не само по себе, а внутри функций. ФУНКЦИЯ - группа операторов под общим ИМЕНЕМ. Обращаясь к ней по имени мы их все вызываем к работе. Может понятнее было бы назвать ПОДПРОГРАММОЙ. Отработав, операторы дают некий результат своей работы - его "функция" возвращает.

Чтобы вернуть результат, нужно указать заранее его тип. Итак функции пишут так:

data_type FunctionName (тип_арг1 имя_арг1, тип_арг2 имя_арг2,... тип_аргN имя_аргN){

перечень действий-операторов, составляющих;

подпрограмму-функцию;

return(результат); // спец_оператор для возврата результата работы функции-подпрограммы

// return результат; - еще вариант записи оператора "возврат результата"

// этот оператор еще по совместительству завершает функцию (работу подпрограммы)

}

Результатов возвращаются не более одного. Бывает, что функция не должна ничего возвращать. Тогда используют специальный тип - void;

Перед типом результата иногда пишут так наз. описание доступа (спецификатор доступа) - указывают кто может использовать данную. функцию. Об этом позже.

ПРИМЕР - некая функция для суммирования целых чисел.

int Sum(int x, int y){

return (x+y);

}

Аргументы простых типов передаются "по значению". Это значит, что внутри подпрограммы создаются копии переданных туда в качестве аргументов переменных, а сами эти переменные не изменяются. (((Если бы внутри функции использовались указатели - это было бы "по ссылке".. На самом деле передача внутрь функции объектов производится "по ссылке" - об этом позднее. Еще раз: Объекты передаются по ссылке! (нужно внутрь некоторого объекта, в его функцию, передать посторонний объект со всеми его переменными=полями и их значениями... Передается лишь ссылка на этот объект. Внутри области нашего первого объекта НЕ выделяется память, не создается в ней копия постороннего передаваемого объекта.)))

Внутри функции-подпрограммы можно объявлять переменные - они есть "локальные". Когда функция начала работать, этим переменным отведется место в памяти компутера, но как только она перестанет работать (завершится), то эта переменная из памяти уничтожится. И вне функции она будет не видна все время работы функции.

В обычном программировании вы еще слышали "глобальную" переменную. Тут этого термина нет, но считайте что все переменные объявленные вне функции - "глобальные". Они называются на самом деле "полями" - об этом позднее!

int Sum(int x, int y){

int rez; // локальная

rez = x + y;

return (rez);

}

ПЕРЕГРУЗКА функции

Это просто. В программе можно объявить несколько функций с одинаковыми именами, различающиеся только списком аргументов. Этот список должен быть разным обязательно. Разница м/б как в количестве, так и в их типе. Очень популярный механизм. Буквально каждая функция имеет несколько однофамильцев. Например мы хотим суммировать не только целые, но и вещественные числа. А язык-то жестко типизированный. Вот и пригодится перегрузка:

float Sum(float x, float y){

return (x+y);

}

Если при вызове функции я указал вещественное, то вызовется Sum-вещественная, а если целые - Sum-цел.

float a=Sum(5, 6);

a = Sum(5,2, 6);

Пример не ахти какой, так как возможно безопасное преобразование типов... Но идея ясна. Очень это распространено, среди матем. библ. функций..

Функции не живут сами по себе в java-программировании. Они живут внутри КЛАССОВ.