Цикл do/while
Только что рассмотренный нами цикл while при определенных условиях может и не заработать. Например, если условие будет изначально ложно, то цикл не выполнится ни разу. Программа, дойдя до строки кода с оператором while, проверит условие и если оно будет равно false, проигнорирует весь цикл и перейдет к коду, следующему сразу за циклом while. Но иногда возникает необходимость в выполнении цикла по крайней мере один раз. Для этих целей в Java существует цикл do/while. Запись и создания цикла do/while осуществляется следующим образом:
do { // действия }while (услрвие)
Между операторами do и while существует тело цикла, которое будет выполняться до тех пор, пока постусловие, следующее за оператором whilе, не будет ложно. Тело цикла выполнится) по меньшей мере, один раз, после чего будет произведена проверка условия. Цикл do/while используется не часто, но порой оказывается незаменим.
Цикл for
Это самый распространенный цикл, используемый в программировании, основанный на управлении счетчиком. Смысл работы цикла for схож с рассмотренными выше циклами while и do/while. Посмотрите, как выглядит цикл for:
for (int i = 0; i < 10; i++) { // действие }
После ключевого слова for, следует условие выполнения цикла. Само же условие объединяет в себе три этапа по инициализации счетчика: i = 0 проверка условия i < 10 и увеличение переменной i на единицу. Когда программа доходит до цикла for, то происходит инициализация счетчика i = 0 и проверяется условие i < 10. Далее программа переходит в тело цикла. По окончанию всех действий в цикле for, происходит обращение к третьему этапу цикла: i++, увеличивая счетчик на единицу. После чего сразу же происходит переход ко второму этапу - проверке переменной i < 10 и повторный выход в тело цикла. Весь цикл продолжается до тех пор, пока условие i < 10 не станет ложным. Цикл for используется постоянно при инициализации массива данных, где без него очень сложно, а порой и не возможно обойтись.
Так же как и в цикле whilе возможно использование оператора декремента, например:
for (int i = 10; i > 0; i-) { //действие }
Используя любую выбранную конструкцию цикла, вы получаете очень мощный инструмент программирования, избавляющий вас от написания большого количества строк кода.
Циклы
Вы задумывались когда-нибудь над тем, зачем вообще существуют программы? Если упростить и обобщить ответ на этот вопрос, то выяснится, что программы необходимы для автоматизации рабочего процесса, увеличения скорости выполняемой работы, избавления человека от тысяч монотонных действий и так далее. Сейчас, мы как раз и остановимся на повторяющихся друг за другом действиях.
Цикл - это последовательное выполнение повторяющихся действий на основе заданного предусловия. Например, нужно переставить сто ящиков из одного угла в другой. Если это каким-то образом записать на языке Java (к сожалению, переставить за вас ящики Java не сможет), то получится запись в сто строк наподобие этой:
1) взять ящик №1 и поставить другой угол; 2) взять ящик №2 и поставить другой угол; 3) взять ящик №3 и поставить другой угол; ... 100) взять ящик №100 и поставить другой угол;
Сто строк кода - это уже много, но бывает и тысяча. Для этих целей, а именно - упрощения записи повторяющихся действий и служат циклы.
Существует три оператора представляющих циклы в языке Java- это while, do/white и for. Каждый из операторов необходим в своей ситуации, но все же чаще всего используется оператор for. Рассмотрим по порядку каждый из операторов.
Интерфейсы
В программировании мобильных телефонов на Java 2 ME очень часто используются интерфейсы. Интерфейс задает классу, что именно должен делать этот класс, но, не говоря каким образом должны быть реализованы Эти действия, то есть, это некая спецификация, в рамках которой происходит реализация необходимых действий. Создание интерфейса совершается при помощи ключевого слова interface, а для реализации каким-либо классом возможностей интерфейса используется ключевое слово implements. Чтобы более четко разобраться в работе с интерфейсами рассмотрим небольшой пример:
public interface Mylnterface { int Inkriment(); } class MyOne implements Mylnterface { int a; // реализация метода Inkriment() для класса MyOne public int Inkriment() { a = 9++; return a; } } class MyTwo implements Mylnterface { int a; // реализация метода Inkriment() для класса MyTwo public int Inkriment() { а = 2++; return a; } }
Созданный интерфейс Mylnterfасе имеет один пустой метод Incriment (). Тело метода отсутствует, есть только его декларация, а класс МуОnе реализует данный интерфейс для своих нужд. В свою очередь класс MyTwo тоже реализует метод Incriment () в необходимой ему форме. Интерфейс задает, что именно надо сделать, а класс, реализующий данный интерфейс, решает, как ему это сделать. Все методы, заключенные в интерфейсе, обязательно должны быть созданы в классе, реализующим этот интерфейс. Интерфейсы не являются классами, поэтому создать интерфейс при помощи ключевого слова new невозможно, но создавать переменные интерфейса можно, в случае если они сохраняются на объекты класса. Любой интерфейс может наследовать другой интерфейс при помощи ключевого слова extends. Интерфейсы очень ярко отражает полифонизм языка Java.
Классы
Стержнем всех программ Java являются классы, на которых основывается объектно-ориентированное программирование. Вы по сути уже знаете, что такое классы, но пока об этом не догадываетесь. В предыдущем разделе мы говорили об объектах, ставя в пример устройство всего компьютера. Каждый объектов, из которых собран компьютер, является представителем своего класса. Например, класс Мониторов объединяет все мониторы вне зависимости от их типов, размеров и возможностей, а один какой-то конкретный монитор, стоящий на вашем столе и есть объект класса мониторов. Такой подход позволяет очень легко моделировать всевозможные процессы в программировании, облегчая решение поставленных задач. Например, имеется четыре объекта четырех разных классов: монитор, системный блок, клавиатура и колонки. Чтобы воспроизвести звуковой файл необходимо при помощи клавиатуры дать команду системному блоку, само же действие по даче команды вы будете наблюдать визуально на мониторе и, в итоге, колонки воспроизведут звуковой файл. То есть любой объект является частью определенного класса и содержит в себе все имеющиеся у этого класса средства и возможности. Объектов одного класса может быть столько, сколько это необходимо для решения поставленной задачи.
в телах обоих методов имеется
В классе Telefon в телах обоих методов имеется запись после двух слешей: //. Такая запись обозначает комментарии, которые будут игнорироваться компилятором, но нужны для читабельности кода. Чем больше информации вы закомментируете по ходу написания программы, тем больше у вас будет шансов вспомнить через год, что вы хотели сделать.
Комментарии в Java могут быть трех видов, это: //, /*...*/ и /**...*/. Комментарии, записанные с помощь оператора // должны располагаться в одной строке:
// Одна строка !!! Ошибка! На вторую строку переносить нельзя! // Первая строка // Вторая строка // ... // Последняя строка
Комментарии, использующие оператор /*...*/ могут находится на нескольких строках. В начале вашего комментария поставьте /*, а в конце, когда закончите комментировать код, поставьте оператор * /.
Последний вид комментария /**...*/ используется при документировании кода и также может располагаться на любом количестве строк.
Конструктор
Каждый класс обязан содержать конструктор. Конструктор - это тот же самый метод, но имеющий название класса, например:
class Telefon { Telefon(); // конструктор int w, h, s; // переменные void Area(); // метод }
Конструктор позволяет инициализировать создаваемые объекты данного класса с заданными значениями. Каждый класс имеет конструктор, и если вы явно не записали строку кода (как в нашем случае Telefon () , Java автоматически создаст его за вас, такой конструктор носит название конструктора по умолчанию.
Конструкторы в программировании очень полезны и ни одна профессиональная программа не обходится без конструкторов. Чтобы действительно ощутить мощь конструктора, надо создать конструктор с аргументами, благодаря которым можно инициализировать данные класса.
class Telefon { int w, h, s; Telefon (int a, int b) // конструктор { w = a; h = b; } void Area() // площадь телефона { S = W*h; } }
При создании объекта (об этом чуть позже), вы можете указать необходимые значения для параметров а и b, например: а = 70, b = 100. Эти заданные числа автоматически присвоятся переменным w и h при создании объекта класса Telefon. Тем самым произойдет инициализация объекта с необходимыми значениями.
Количество конструкторов в классе ограничивается только вашей фантазией и здравым смыслом. Например, можно создать два конструктора классу Telefon:
Telefon (int a, intb); Telefon (char a, char b);
В этом случае при создании объекта по переданным параметрам конструктору класса, компилятор выберет сам необходимый конструктор и создаст заданный объект.
Конструктор суперкласса
В рассмотренном примере по созданию суперкласса и подкласса Nokia, умышленно использовался конструктор по умолчанию. Ситуация с конструкторами суперклассов требует отдельного внимания.
Когда в программе происходит вызов конструктора, то вызов осуществляется согласно всей иерархии наследования. Первым вызывается конструктор самого первого суперкласса и опускается ниже по все иерархии наследования. Но иногда необходимо обратиться к ближайшему конструктору суперкласса и тогда используется ключевое слово super. Рассмотрим небольшой пример.
// суперкласс Nokia class Nokia { // конструктор суперкласса Nokia // тело класса Nokia } // подкласс NokiaSeries60 class NokiaSeries60 extends Nokia { // конструктор подкласса NokiaSeries60 NokiaSeriesGO(int a, int b) ; // тело подкласса NokiaSeries60 } // подкласс Nokia6600 для суперкласса NokiaeSeries60 class Nokia6600 extends NokiaSeries60 { // конструктор подкласса Nokia6600 Nokia6600 (short f, short b, short c) { super (a, b) // тело конструктора } } // подкласс Nokia6100 для суперкласса NokiaeSeries60 class Nokia6100 extends NokiaeSeries60 { //конструктор подкласса Nokia6100 Nokia6100 (char a, char b) { super (a, b) // тело конструктора } // тело подкласса Nokia6100 }
Если вы желаете воспользоваться конструктором ближайшего суперкласса, в конструкторе подкласса первым должно идти ключевое слово super с параметрами для необходимого конструктора суперкласса. Ключевое слово super имеет двойную смысловую нагрузку и может использоваться не только для вызова конструктора суперкласса. Второй вариант использования ключевого слова super, заключается в доступе к невидимому члену суперкласса. Сейчас мы коснулись так называемого вопроса видимости. Вы не задумывались над тем, что будет, если методы или переменные в суперклассе и подклассе будут совпадать по именам? Дело в том, что если подкласс будет иметь одинаковые названия любых членов класса, то он будет использовать только свои члены класса. Все данные суперкласса окажутся недоступными или невидимыми в силу совпадения названий. Для этих целей может быть использовано слoво super. Посмотрите на пример иллюстрирующий способ его использования:
// суперкласс Siemens class Siemens { int a, b; } // подкласс SiemensMC62 class SiemensMC62 extends Siemens { int a, b; // конструктор подкласса SiemensMC62 SiemensMC62 (int c, int d) { super.a = с; // для а в суперклассе super.b = d; // для b в суперклассе a = с; // для а подкласса b = d; // для b подкласса } }
Использование ключевого слова super очень похоже на обращение объекта класса к методам и переменным. Когда необходимо получить доступ к членам суперкласса, имеющим одинаковые названия, воспользуйтесь ключевым словом super или поступайте проще - давайте различные имена для членов суперкласса и подкласса.
В языке Java существует еще одно ключевое слово this, выполняющее похожие действия. При помощи этого ключевого слова можно произвести вызов любого другого конструктора того же класса либо использовать для указания ссылки на параметр, отсутствующий в конструкторе класса.
Подводя итог темы наследования необходимо упомянуть о классе Object. В языке Java все классы наследуются от большого суперкласса Objec. Это происходит автоматически и беспокоится о явном наследовании при помощи ключевого слова extends не нужно.
Массивы
Очень часто в программировании встречается большое количество однотипных данных. Для того чтобы не объявлять, скажем, сто переменных, существуют массивы данных. Массив - это набор однотипных значений. В языке Java для создания массивов предусмотрена специальная запись:
int[]M;
С помощью такой записи создается пустая переменная, содержащая определенный массив данных. Объявление массива происходит так же как и объявление объекта класса. Необходимо воспользоваться ключевым словом new чтобы выделить память массиву и явно инициализировать его с количеством элементов. Например:
int[]M = new int[20];
В этой строке кода был создан целочисленный массив из двадцати элементов. К каждому из элементов массива можно обратиться при помощи индекса М [n], для сохранения либо изъятия значения заданного элемента.
М[0] = 3; М[1] = 5; М[2] = 20;
Индекс любого созданного массива всегда начинается с 0, об этом нужно помнить. Чтобы инициализировать массив данных, например из пятидесяти элементов, должно потребоваться пятьдесят строк кода, но в нашем распоряжении имеется цикл for, прекрасно справляющийся с этой задачей.
int[]М = new int[50]; for .(int i = 0; i<50; i++) { M[i]. = i; }
В этом примере происходит инициализация каждого элемента массива от 0 до 49, соответственно, такими же значениями. Можно инициализировать массив другим способом, без ключевого слова new.
int[]M = (0, 1, 2, 3, 4}
В этом случае каждый элемент массива инициализируется пятью числами от 0 до 4. Все вышеперечисленные примеры создавали простой одномерный массив данных, но иногда приходится представлять данные в виде парных значений. Например, координаты по X и по Y в системе координат. Для этого в Java существуют многомерные массивы данных.
int stroka = 10; int stolbec =10; int[][]M = new[stroka][stolbec];
Многомерные массивы представлены в виде таблицы. Чтобы получить доступ к заданному элементу массива, нужно указать в какой строке и в каком столбце находится элемент массива. Точно так же в высшей математике происходит работа с матрицами. Многомерный массив данных можно инициализировать с помощью фигурных скобок:
intn []M = { (5, 3, 8}, {7, 12, 16} , 49, 12, 14} }
Инициализация массива данных при помощи цикла for немного сложнее, но очень эффективная и используется постоянно. Например, у вас есть большой массив данных, который требуется обнулить. Вот как будет выглядеть запись для этого массива данных:
int[][]M = new int[100][50]; for1(int i = 0; i < 100; i++) for (int a = 0; a < 50; a++) M[i][a] =0;
Многомерные массивы позволяют хранить большое количество данных при минимуме записанного кода, сохраняя при этом его понятность и читабельность.
Метод main
Класс Telefon, который мы описывали в предыдущем разделе, имел один метод, с помощью которого вычислялась площадь дисплея. Созданная спецификация класса Telefon может быть описана как угодно. Можно добавить реагирующие на обработку событий с клавиатуры телефона и любые другие методы, которые вы сочтете нужными для описания класса Telefon. Таких, и подобных классов может быть любое количество. Каждый из классов принято хранить в своем отдельном файле с расширением *.java. Например, Telefon.java. Все методы находящиеся в классе Telefon, которые вы опишете для данного класса, обязаны производить определенные действия с объектом этого класса, иначе, зачем нужны эти методы. Реализация методов как уже говорилось, происходит непосредственно в создаваемом классе. Но возникает вопрос, где и как, происходит вызов необходимых по ситуации методов или создание объектов используемого класса. В языке Java для этих целей существует Memodmain (), который подобно строительной площадке собирает на своей платформе по частям объекты, методы, строя при этом функциональность всей программы.
public class RunTelefon { public static void main( String[] args) { // Работа программы } }
Пока не обращайте внимания на ключевые слова public и static - о них чуть позже. Создав класс RunTelefon и определив в его теле метод main () мы теперь имеем возможность пользоваться классом Telefon и его не особо богатой функциональностью. Объединив эти два класса в один файл, либо записав каждый по отдельности, вы получите работоспособную программу. Класс Telefon содержит основные данные и методы, а класс RunTelefon берет на себя роль мотора. Внутри класса RunTelefon происходит создание объектов класса, в данном случае класса Telefon и вызовы соответствующих методов этого класса. Например:
class Telefon { //переменные int w, h, s; // метод void Area() { S = w*h; } } class RunTelefon { public static void main (String args[]) { /* создание объектов и вызовы метода Area() */ } }
Поскольку вы пока не умеете создавать объекты классов и вызывать методы, тело класса RunTelefon пустое. Прежде чем идти дальше, необходимо познакомиться с ключевыми словами public, private и protected, а так же научиться создавать конструкторы классов.
Методы
Когда приводился пример воспроизведения звукового файла, то было упомянуто о даче команды или сообщения, на основе которого и выполнялись определенные действия. Задача по выполнению действий решается с помощью методов, которые имеет каждый объект. Методы — это набор команд, с помощью которых можно производить те или иные действия с объектом.
Каждый объект имеет свое назначение и призван решать определенный круг задач с помощью методов. Какой толк был бы, например, в объекте Клавиатура, если нельзя было бы нажимать на клавиши получая при этом возможность отдавать команды? Объект Клавиатура имеет некое количество клавиш, с помощью которых пользователь приобретает контроль над устройством ввода и может отдавать необходимые команды. Обработка таких команд в целом, происходит с помощью методов. Например, вы нажимаете клавишу Esc для отмены каких-либо действий и тем самым даете команду методу, закрепленному за этой клавишей который на программном уровне решает эту задачу. Сразу же возникает вопрос о количестве методов объекта Клавиатура, но здесь может быть различная реализация - как от определения методов для каждой из клавиш (что, вообще-то, неразумно), так и до создания одного метода который будет следить за общим состоянием клавиатуры. То есть, этот метод следит за тем, была ли нажата клавиша, а потом в зависимости от того какая из клавиш задействована, решает, что ему делать.
Итак, мы видим, что каждый из объектов может иметь в своем распоряжении набор методов для решения различных задач. А поскольку каждый объект является объектом определенного класса, то получается, что класс содержит набор методов, которыми и пользуются различные объекты одного класса. В языке Java все созданные вами методы должны принадлежать или являться частью какого-то конкретного класса.
Наследование
В языке Java имеется термин наследование. Это очень мощный инструмент, без которого не обходится ни одна профессионально написанная программа. Каждый из вас, читающий эти строки обязательно хочет стать профессиональным программистом, поэтому стоит подробно рассмотреть механизм наследования.
Наследование - это механизм, позволяющий наследовать от вышестоящего в иерархии класса все его возможности. Что значит класс, стоящий выше в иерархии? В языке Java существует термин суперкласс и подкласс. Например, имеется некий класс Siemens:
class Siemens {Int w, h; int Area() { return w*h; } }
Чтобы создать подкласс класса Siemens, необходимо воспользоваться ключевым словом extends:
class SiemensMSS extends Siemens { // члены класса }
Класс SiemensMSS является подклассом класса Siemens, в свою очередь класс Siemens является суперклассом для класса SiemensMSS. Класс SiemensMSS наследует все члены своего суперкласса Siemens и имеет возможность доступа к ним при одном условии: все члены суперкласса Siemens, к которым вы впоследствии захотите получить доступ, должны быть объявлены со спецификатором public. Поскольку мы не определяли вообще никакого спецификатора, а это по умолчанию равно ключевому слову public, то подкласс SiemensMSS, будет иметь доступ ко всем членам своего суперкласса Siemens. Вы можете воспользоваться методом Area () и переменными w и h. Вам не нужно переопределять переменные и метод суперкласса Siemens, но вы можете добавлять дополнительные переменные и методы для подкласса SiemensMS 5, реализующие свои специфические действия для этого подкласса.
Давайте рассмотрим небольшой пример по созданию суперкласса и подкласса. Как вы уже, наверное, догадались, я воспользовался маркой телефона Siemens М55 для названия подкласса. Чтобы не обижать других производителей телефонов, рассмотрим пример для Nokia.
// суперкласс Nokia class Nokia { // высота, ширина и площадь дисплея int dh, dw, ds; // метод, вычисляющий площадь дисплея int Area() { return dw * dh; } } // подкласс Nokia5100 class Nokia310 extends Nokia { // высота, ширина и площадь всего телефона int th,dw, ds; // метод, вычисляюшщий площадь телефона int tArea() { return tw * th; } { //входная точка приложения class RunNokia ; { public static void main (String args[]) { // при создании объекта используется конструктор по умолчанию Nokia3100 nokia3100 = new Nokia3100(); // задаем значения для переменных noki.a3100.dh = 128; nokia3100.dw = 128; nokia3100.th = 102; nokia3100.tw = 43; // вычисляем площадь дисплея ds = nokia.dArea(); } // вычисляем полощадь телефона dt = nokia.tArea(); } { }
Создав подкласс Nokia3100, вы получите доступ ко всем членам суперкласса Nokia, определенные как public. Используя оператор «.» (точка), вы открываете доступ к переменным и методам суперкласса. При создании объекта суперкласса, например Nokia nokiasuper = new Nokia (), объект созданного класса может пользоваться своими членами класса, но уже члены подкласса ему не доступны.
Иначе говоря, подкласс расширяет свой суперкласс, добавляя новые члены в подкласс, тем самым, подстраивая под себя новые, необходимые только подклассу, члены класса, оставляя за собой возможность использования членов суперкласса.
Суперкласс вправе иметь сколько угодно подклассов, например, в рассмотренном примере можно создать еще десяток-другой подклассов: Nokia5100, Nokia6600, Nokia2100 и так далее. Но каждый из подклассов может иметь только один суперкласс. Множественные наследования в языке Java не предусмотрены. Но каждый из подклассов может иметь свой подкласс, и такая цепочка наследования может длиться до разумной бесконечности.
Объектно-ориентированное программирование
Java типиризированный, и по своей природе объектно-ориентированный язык программирования. Эти термины при детальном рассмотрении очень просты в понимании. Основных типов данных мы коснемся, когда будем обсуждать семантику языка, а сейчас сосредоточимся на объектно-ориентированной парадигме современного программирования.
Объектно-ориентированное программирование построено на объектах по аналогии с нашим миром. Если оглянуться вокруг себя, то обязательно можно найти что-то, что поможет более ярко разобраться в модели такого программирования. Например, я сейчас сижу за столом и печатаю эту главу на компьютере, который состоит из монитора, системного блока, клавиатуры, мыши и так далее. Все эти части являются объектами, из которых состоит компьютер. Зная это, очень легко сформулировать какую-то обобщенную модель работы всего компьютера. Если не разбираться в тонкостях программных и аппаратных свойств компьютера, то можно сказать, что объект Системный блок производит определенные действия, которые показывает объект Монитор. Объект Клавиатура в свою очередь может корректировать или вообще задавать действия для объекта Системный блок, а тот влияет на объект Монитор. Объект Колонки предназначен для воспроизведения звуковых данных с различных источников. Построенный процесс очень хорошо характеризует всю систему объектно-ориентированного программирования. Представьте себе некий мощный программный продукт, содержащий сотни тысяч строк кода. Если не использовать объектно-ориентированное программирование, то вся программа должна выполняться построчно, строка за строкой и в принципе каждая из последующих строк кода обязательно будет связана с предыдущей. Когда потребуется изменить этот программный код, скажем при необходимости улучшения каких-то элементов, то придется произвести большое количество работы с кодом. В объектно-ориентированном программировании все куда проще. Допустим, вас уже не устраивает пятнадцати дюймовый монитор. Вы можете спокойно его обменять, например на семнадцати или девятнадцати дюймовый монитор, конечно же, при наличии определенных материальных средств. Сам же процесс обмена не повлечет за собой огромных проблем. Ну, разве что драйвер придется сменить, да вытереть пыль из-под старого монитора. Объектно-ориентированное программирование очень легко и ясно отражает суть решаемой проблемы и что самое главное, дает возможность веь ущерба для всей программы убирать старые и ненужные объекты заменяя их на новые, точней говоря, модернизировать без лишних затрат. Также общая читабельность всей программы становится намного проще. Существенно и то, что один и тот же код можно использовать в абсолютно разных программах.
Объекты классов
Объекты представляют класс, наследуя от своего класса все возможности. Объявить объект очень просто, необходимо вначале указать класс, а потом объект этого класса. Например:
Telefon object;
Точно так же как создается переменная int а, создается и объект класса. Такая запись создаст пустой объект класса, инициализирующийся значением null. Конечно, это еще не полноценный объект, а всего лишь ссылка на данный класс. Чтобы создать полноценный класс, нужно воспользоваться ключевым словом new, с помощью которого происходит выделение области памяти для содержания создаваемого объекта.
Telefon object; object = new Telefon);
или
Telefon object = new Telefonf);
Обе записи создания объекта класса Telefon одинаковы. Чаще всего используется вторая запись, но это можно оставить на усмотрение программиста. Сначала создается пустая ссылка object, а потом с помощью ключевого слова new выделяется память для объекта и он инициализируется конструктором класса Telefon (). Именно тут и необходим хорошо продуманный конструктор с параметрами, инициализирующий объект с заданными значениями.
Теперь давайте рассмотрим пример посложнее. Создадим класс с конструктором для инициализации высоты и ширины дисплея и в методе main () создадим объект класса Telefon, вычислив при этом площадь экрана абстрактного телефона.
class Telefon { int w, h, s; // конструктор класса Telefon Telefon (int a, int b) { w = a; h = b; } // метод, вычисляющий площадь экрана void Area() { S = w*h; } } // class RunTelefon может находится в файле RunTelefon.Java class RunTelefon { public static void main (String args[]) { // создаем объект класса Telefon Telefon object = new Telefon (70, 90); // вычисляем площадь дисплея object.Area(); } }
Разберем весь пример более подробно. Итак, мы создаем класс Telefon с тремя переменными: w, h и s, в которых впоследствии будут храниться, соответственно, ширина, высота и площадь дисплея телефона. Далее создаем конструктор класса Telefon для инициализации высоты и ширины дисплея. Метод Area () класса Telefon вычисляет площадь экрана, сохраняя полученный результат в переменной s. После этого идет класс RunTelefon с методом main (), являющийся входной точкой для всей программы. Как только написанное приложение начнет работать, программа найдет метод main () и начнет выполнять содержимое программы.
В первой строке кода метода main () происходит создание объекта класса Telefon со значениями ширины - 70 и высоты - 90 для экрана телефона. Вторая строка кода вызывает метод Area (), вычисляющий площадь дисплея. Метод Area () нельзя просто так вызвать в программе, он должен ссылаться на объект класса Telefon. Запись object.Area () как раз и указывает на то, что объект класса Telefon вызывает метод Area (). Если имеется несколько объектов класса Telefon, то есть несколько различных телефонов, тогда вызов метода Area () должен происходить для каждого из объектов класса Telefon, например:
object1.Area(); object2.Area(); objects.Area();
Для каждого из объектов класса Telefon будет вычисляться только своя площадь экрана. Давайте рассмотрим еще более сложную программу, создав несколько объектов класса Telefon, а заодно используем другую схему работы метода Area (), воспользовавшись ключевым словом return.
class Telefon { int w, h, s, n; // конструктор Telefon (int a, int b) { w = a; h = b; } // вычисляет площадь дисплея int Area() { return w*h; } } // class RunTelefon может находится в.файле RunTelefon.java class RunTelefon { public static void main (String[] args) { // создадим объект Siemens Telefon Siemens = new Telefon (101, 8.0); // создадим объект nokia Telefon nokia = new Telefon (128, 128); // сохраним полученную площадь в s s = Siemens.Area(); // сохраним полученную площадь в n n = nokia.Area(); } }
В реализации класса Telefon изменился только метод Area (), использовалось ключевое слово return. С его помощью результат умножения высоты на ширину, то есть результат работы всего метода возвращается для дальнейшего использования в коде программы. А в рабочем цикле программы в методе main (), этот результат сохраняется в двух переменных s и N для каждого из объектов класса Telefon. В данном случае площадь экрана для объекта Siemens равна 101x80=8080, а для объекта nokia 128x128=16384 и оба результата хранятся в различных переменных.
У вас наверно сразу возникает вопрос, а как увидеть получившийся результат? Действительно, просчитать значение не составляет труда, но хотелось бы увидеть полученный результат на дисплее. Для этого в Java существует встроенный метод print In(). Чтобы увидеть на экране результат работы метода Area (), нужно добавить вызов метода print In ().
s = Siemens.Area(); System.out.println("Площадь экрана Siemens" + s) ; n = nokia.Area() System.out.println("Площадь экрана nokia" + n) ;
Метод print (), как уже говорилось, встроенный и принадлежит классу System, поэтому такая запись, out — это поток ввода, связывающий программу с консолью. Реально в программировании телефонов метод printIn () используется, как правило, в диагностических целях, но как логическое завершение примера подойдет. С помощью кавычек ограничивается количество выводимого на экран текста, это необходимое условие. Запись + s, применяет операцию конкатенации на основе оператора +, с помощью которого на экран выводится значение переменной s, то есть целочисленное значение равное площади экрана.
Резюмируя объектно-ориентированное программирование, можно с уверенностью заявить - это не сложно, не страшно, достаточно понятно и, что самое главное, просто в использовании. Создав необходимый класс, объявив объект и воспользовавшись методами созданного класса, вы получаете неограниченные возможности в программировании приложений. Но главное - большое количество необходимых классов и методов уже созданы за вас и собраны в специальные библиотеки, о которых мы поговорим в конце этой главы. Вам же остается только воспользоваться этими готовыми классами, создавая свои объекты этих классов.
Оператор while
Синтаксическая запись оператора while выглядит следующим образом:
while (условие) { // действия }
Также имеет место выполнение определенного предусловия, но в отличие от оператора if/else, данная конструкция построена на циклах проверки условия. Когда программа доходит до оператора while, если предложенное условие истинно, происходит выполнение всех действий в блоке из фигурных скобок {...}. После выполнения этих действий, снова происходит очередная проверка условий после оператора whilе и если условие опять истинно, происходит повторное выполнение действий в блоке. Действия в блоке выполняются до тех пор, пока условие не станет ложным, тогда происходит выход из цикла while. В основном все циклы управляются при помощи так называемых счетчиков. Рассмотрим не большой пример:
int i = 0; while (i < 10) { // действия i + +; }
Сначала переменной i присваивается значение 0, далее происходит проверка условия i<10, если переменная i меньше цифры 10, выполняются все действия в блоке цикла. В конце блока переменная i увеличивается на 1и вновь проверяется условие в цикле. И так ровно десять, раз для нашего примера. Переменная i служит счетчиком для цикла while. Отсутствие операции по увеличению переменной i на единицу приведет к бесконечному циклу, поскольку 0 всегда будет меньше десяти. В циклах так же можно использовать оператор декремента, например:
int. i = 10; while (i>0) { // действия i --; }
Те же действия, но уже в обратную сторону. Но все-таки чаще всего используется оператор декремента.
В цикле while имеется возможность использования булевых переменных, содержащих значения false или true. После оператора while происходит проверка предусловия, то можно воспользоваться булевой переменной, например:
boolean i = true, while (i) { // действия }
Переменная i истинна, ей присвоено значение true, поэтому происходит выполнение цикла whilе. Единственное о чем необходимо позаботиться - это о выходе из такого цикла, поскольку переменная i истинна, то цикл while будет выполняться бесконечно и такие циклы носят названия бесконечных циклов.
Напоследок хочу еще обратить ваше внимание на оператор равно ==. Если записать цикл таким образом:
int i = 0 while (i = = 5) { // действия i + +; }
То получится вполне работоспособный цикл, а вот если вы ошибетесь или по привычке воспользуетесь классическим вариантом оператора равно =, использующимся в математике, то у вас будет проблема в виде бесконечного цикла.
int i =0 while (i = 5) { // действия i++; }
В предусловии происходит присвоение переменной i значения 5, а оттого, что это действие не запрещено, то произойдет выполнение блока цикла. В конце которого значение i увеличится на один, но в предусловии после оператора while, переменной i новь будет присвоено значение пять - это пример простого бесконечного цикла и как следствие, классическая ошибка, случающаяся с начинающими программистами.
Операторы
Операторы языка Java имеют различные назначения. Существуют арифметические операторы, операторы инкремента и декремента, логические операторы и операторы отношения.
Арифметические операторы очень просты и аналогичны операторам умножения «*», деления «/», сложения «+» и вычитания «-» используемые в математике. Существует оператор деления по модулю «%» и слегка запутанная на первый взгляд ситуация с оператором равно «=». Оператор равно в языках программирования называется оператором присваивания:
int х = 3
Здесь вы переменной х присваиваете значение 3. А оператор «равно» в языках программирования соответствует записи двух подряд операторов «равно»: <= = >. Рассмотрим на примере, что могут делать различные арифметические операторы.
int х, у, z; ; х = 5; У = 3 ; Z = 0; z = х + у;
В данном случае z будет иметь значение уже суммы х и у, то есть 8.
x = z*x;
Переменная х имела значение 5, но после такой записи предыдущее значение теряется и записывается произведение z *х (8*5), что равно 40. Теперь, если мы продолжим дальше наш код, то переменные будут иметь такой вид:
// х = 40; // У = 3 ; // z = 8;
Это обязательно необходимо иметь в виду.
Что касается оператора деления, то поскольку Java 2 ME не поддерживает дробных чисел, то результат такого деления:
x = z/y;
что равносильно записи:
х = 8/3;
будет равен 2. Дробная часть просто отбрасывается, то же самое происходит при использовании оператор деления по модулю «%».
Операторы сложения и вычитания имеют те же назначения что и в математике. Отрицательные числа так же родственны.
Операторы декремента «—» и инкремента «++» весьма специфичны, но очень просты. В программировании часто встречаются моменты, когда требуется увеличить или уменьшить значение на единицу. Часто это встречается в циклах. Операция инкремента увеличивает переменную на единицу.
int x = 5; х++; // Здесь х уже равен 6
Операция декремента уменьшает переменную на единицу.
int х = 5; х -- ; //х равен 4
Операции инкремента и декремента могут быть пост и префиксными:
int х = 5; int у = 0; y = х++;
8 последней строке кода сначала значение х присваивается у, это значение 5, и только потом переменная х увеличивается на еденицу. Получается что:
х = 6, у = 5
Префиксный инкремент имеет вид:
int х = 3; int у = 0; у = ++х;
И в этом случае, сначала переменная х увеличивается на один, а потом присваивает уже увеличенное значение у.
у = 4, х = 4
Операторы отношения позволяют проверить равенство обеих частей выражения. Имеется оператор равенства «= =», операторы меньше «<» и больше «>», меньше или равно «<=» и больше или равно «>=», а так же оператор отрицания «!=».
9 = = 10;
Это выражение не верно, девять не равно десяти, поэтому его значение этого выражения равно false.
9 != 10;
Здесь же, наоборот, оператор отрицания указывает на неравенство выражения, и значение будет равно true.
Операторы больше, меньше, больше или равно и меньше или равно аналогичны соответствующим операторам из математики.
Существует два логических оператора. Оператор «И», обозначающийся значками «&&» и оператор «ИЛИ», обозначенный в виде двух прямых слешей «||». Например, имеется выражение:
А*В && В*С;
В том случае, если только обе части выражения истинны, значение выражения считается истинным. Если одна из частей неверна, то значение всего выраже- , ния будет ложным.
В противовес оператору «&&» имеется оператор «I I », не напрасно имеющий название «ИЛИ».
А*В|| В*С;
Если любая из частей выражения истинна, то и все выражение считается истинным. Оба оператора можно комбинировать в одном выражении, например:
А*В || B*C && C*D ||В*А;
С помощью этого выражения я вас ввел, как мне кажется, в затруднение, неправда ли? Дело в том, что в Java, как и в математике существует приоритет или так называемая иерархия операторов, с помощью которой определяется какой из операторов главнее, а, следовательно, и проверяется первым. Рассмотрим с помощью списка приоритет всех операторов языка Java:
[] , . , () , ! , ~, ++, - -, +(унарный), -(унарный), new, *, /, % , +, -, << , >>, >>>, <, <=, >, >=, = = , !=, &, ^, | , &&, || , ?:, = , +=, -=, *=, /=, %=, |=, ^=, <<=, >>=, >>>=.
Не со всеми операторами вы еще знакомы, поэтому пугаться не стоит. Ассоциативность операторов в списке следует слева на право и сверху вниз. То есть все, что находится левее и выше - старше по званию и главнее.
Пакеты
При наличии большого количества своих классов, можно создавать пакеты, для этих классов, коллекционируя их. С помощью ключевого слова package можно создать пакет для класса. Для этого в самом начале файла, где вы пишете исходный код для класса, сделайте запись, например следующую, для созданного ранее в разделе 1.10.1 класса Nokia:
package Nokia;
В последствии вы сможете получить доступ к пакету с этим классом с помощью спецификатора import в начале файла, где вам необходим класс Nokia.
import Nokia.*
Оператор звездочка в конце импорта класса Nokia обозначает доступ ко всем классам этого пакета. Но возможно обращение и к отдельному классу всего пакета, например:
import Nokia..NokiaeSeries60 .Nokia6600;
При условии, конечно, что все эти классы существуют в пакете Nokia. Если вы собираетесь использовать много классов из пакета, то лучше воспользоваться оператором звездочка, чем перечислять каждый класс в отдельной строке кода.
Кроме этого пакеты имеют еще одну ценную возможность - при создании своих классов существует вероятность того, что какой-нибудь программист, собирающий яблоки в Новой Зеландии возьмет и назовет свой созданный класс точно таким же именем. В этом случае возникает конфликт имен вызывающий исключительную ситуацию. Но если пользоваться возможностью создания пакетов, такая вероятность повторения снижается. Даже если названия созданных классов будут одинаковыми, содержаться они будут в разных пакетах. Конфликта не возникнет. Слышу провокационный вопрос: а если названия пакетов совпадут? Да вы правы, есть же сказка про Буратино от двух разных авторов... В таком случае можно воспользоваться рекомендуемой компанией Sun Microsystems, создавшей язык Java, схемой записи по зарезервированному домену в Интернете, например':
package ru.dmk;
Или как в случае упомянутой сказки о деревянном человечке:
package Buratino; package Pinocchio;
И избежать тем самым конфликта имен. Такой способ записи по домену действительно работает и на этой схеме построены все пакеты в Java.
Язык Java имеет огромное количество предопределенных классов, существующих в виде библиотек. Все библиотеки разбиты на пакеты по своему назначению. Платформа Java 2 ME состоит из одиннадцати пакетов:
java.io; java.lang; java.util; javax.microedition.lcdui; javax.inicroedition.lcdui.game; javax.microedition.io; javax.microedition.inedia; javax.microedition.media.control; javax.microedition.pki; javax.microedition.midlet; javax.inicroedition.rms.
Каждый из пакетов содержит множество классов с различной областью применения. Имеются математические классы, классы, отвечающие за работу с сетью, классы ввода-вывода, классы утилит и так далее. Более подробно каждый из пакетов будет рассмотрен в главе 2. Для того чтобы воспользоваться имеющимися классами и методами, необходимо в начале исходного кода импортировать нужный для работы пакет:
import java.lang.*
Затем можно воспользоваться, к примеру методом abs (int а) .класса Math, возвращающим целочисленное значение переменой.
int а = 9; int x = Math.abs(a);
Импортируя пакеты в программу, вы упрощаете разработку приложения, поскольку имеется огромное количество готовых классов и достаточно просто создать объект импортированного класса и пользоваться всеми его методами и возможностями.
В этом приложении мы рассмотрели язык программирования Java вкратце, но изученного материала будет достаточно для прочтения этой книги и освоения азов программирования мобильных телефонов на Java 2 Micro Edition.
Основы языка Java
В приложении ... 1.1. Введение в программирование 1.2. Объектно-ориентированное программирование 1.2.1. Классы 1.2.2. Методы 1.3. Синтаксис и семантика языка Java 2 ME 1.3.1. Комментарии 1.3.2. Типы данных Java 1.3.3. Операторы 1.3.4. Метод main 1.3.5. Закрытые и открытые члены классов 1.4. Конструктор 1.5. Объекты классов 1.6. Условные операторы 1.7. Управляющий оператор 1.8. Циклы 1.8.1. Оператор while 1.8.2. Цикл do/while 1.8.3. Цикл for 1.9. Массивы 1.10. Наследование 1.10.1. Конструктор суперкласса 1.11. Интерфейсы 1.12. Пакеты
Синтаксис и семантика языка Java ME
Для того чтобы говорить и читать на любом иностранном языке, необходимо изучить алфавит и грамматику этого языка. Подобное условие наблюдается и при научении языков программирования, с той лишь разницей, как мне кажется, что этот процесс несколько легче.
Таким образом, как вы знаете из раздела посвященного основам программирования, прежде чем начинать писать исходный код программы, необходимо сначала решить поставленную перед вами задачу в любом удобном для себя виде.
Давайте создадим некий класс отвечающий, например, за телефон, который будет иметь всего два метода: включающий и выключающий этот самый телефон. Поскольку мы сейчас не знаем синтаксис языка Java, то, напишем класс Телефон на абстрактном языке.
Класс Телефон { Метод Включить() { // операции по включению телефона } Метод Выключить() { // операции по выключению телефона } }
Таким вот образом может выглядеть класс Телефон. Заметьте, что фигурные скобки обозначают соответственно начало и конец тела класса, метода, либо всякой последовательности данных. То есть скобки указывают на принадлежность к методу или классу. На каждую открывающую скобку обязательно должна быть закрывающая скобка. Чтобы не запутаться их обычно ставят на одном уровне в коде. А теперь давайте запишем тот же самый класс только уже на языке Java.
class Telefon { void on() { // тело метода оn() } void off() { // тело метода off () } }
Ключевое слово class в языке Java объявляет класс, далее идет название самого класса. В нашем случае это Telefon. Сразу пару слов касательно регистра записи. Почти во всех языках программирования важно сохранять запись названий в том регистре, в котором она была сделана. Если вы написали Telefon, то уже такое написание как telefon или TELefoN выдаст ошибку при компиляции. Как написали первоначально, так и надо писать дальше.
Зарезервированные или ключевые слова записываются в своем определенном регистре, и вы не можете их использовать, давая их названия методам, классам, объектам и так далее.
Пробелы между словами не имеют значения, поскольку компилятор их просто игнорирует, но для читабельности кода они важны.
В теле класса Telefon имеются два метода: on () - включающий телефон и метод off () - выключающий телефон. Оба метода имеют свои тела и в них по идее должен быть какой-то программный код, описывающий необходимые действия обоих методов. Для нас сейчас не важно как происходит реализация этих методов, первостепенное - это синтаксис языка Java.
Оба метода имеют круглые скобки on (), внутри которых могут быть записаны параметры, например on (int time) или on (int time, int time1). С помощью параметров происходит своего рода связь методов с внешним миром. Говорят, что метод on (int time) принимает параметр time. Для чего это нужно? Например, вы хотите, чтобы телефон включился в определенное время. Тогда целочисленное значение в параметре time будет передано в тело метода и на основе полученных данных произойдет включение телефона. Если скобки пусты, то метод не принимает никаких параметров.
Типы данных Java
Чтобы задать произвольное значение, в Java существуют типы данных. Как уже говорилось, Java - язык типиризированный, поэтому каждое значение имеет свой тип. В классе Telefon мы создали два метода. Оба метода не имели параметров, но когда приводился пример метода on (int time) с параметром time, говорилось о передаче значения в метод. Данное значение указывало на время, с помощью которого якобы должен включиться телефон. Спецификатор int как раз и определяет тип значения time. В Java 2 ME шесть типов данных. Посмотрите на табл. 1.1.
Таблица 1.1.
| Тип |
Назначение |
Размер в байтах |
| byte |
маленькое целое |
1 |
| short |
короткое целое |
2 |
| int |
целое |
4 |
| long |
длинное целое |
8 |
| char |
символ |
2 |
| boolean |
логический тип |
  |
Java 2 ME в отличие от Java 2 SE не поддерживает числа с дробной частью в связи с тем, что мобильные устройства имеют небольшие по объему ресурсы.
byte - маленькое цел счисленное значение от-128 до 128; short - короткое целое значение в диапазоне от -32768 до 32767; int- содержит любое целочисленное значение от -2147483648 до 2147483647; long - очень большое целочисленное значение, от -922337203685475808 до 9223372036854775807; char — это символьная константа в формате Unicode! Диапазон данного формата от 0 до 65536, что равно 256 символам. Любой символ этого типа должен записываться в одинарных кавычках: 'G'; boolean - логический тип, имеет всего два значения: false - ложь и true -истина. Этот тип часто используется в циклах о которых чуть позже. Смысл очень прост - если у вас в кармане есть деньги, предположительно это true, а если нет то false. Таким образом, если деньги имеются - идем в магазин за хлебом или пивом (нужное подчеркнуть), если нет денег -остаемся дома. То есть определяется логическая величина, способствующая выбору дальнейших действий вашей программы.
Чтобы объявить какое-то необходимое значение используется запись:
int time; long BigTime; char word;
Оператор точка с запятой необходим после таких записей в конце строки. Можно совместить несколько одинаковых по типу объявлений через запятую:
mt time, timel, time2;
Теперь давайте, усовершенствуем наш класс Telefon, добавив в него несколько значений. Методы on () и off () нам больше не нужны, добавим методы поинтересней.
class Telefon { //s- площадь дисплея //w - высота дисплея //h - ширина дисплея int w, h, s; //метод вычисляющий площадь дисплея vord Area.() { S = w*h; } }
Итак, мы имеем три переменные S, w и h, отвечающие, соответственно, за площадь, высоту и ширину дисплея в пикселях. Метод Area () вычисляет площадь экрана телефона в пикселях. Операция бесполезная, но очень показательная и простая в понимании. Тело метода Area () обрело себя и имеет вид S = w*h. Мы просто перемножаем высоту на ширину и присваиваем или как еще говорят, сохраняем результат в переменной S. Сейчас мы подошли вплотную к операторам языка Java, с помощью которых можно совершать всевозможные операции.
Управляющий оператор
В языке Java существует управляющий оператор switch, который можно в принципе отнести к условным операторам. Он тоже основан на неких условиях, но предоставляет многовариантное ветвление для выбора пути заданных действий. Посмотрите на синтаксический шаблон этого оператора:
switch (условие) { case 1 // действие 1 break; case 2: // действие 2 break; case 20: // действие 20 break; default: //-действие по умолчанию break; }
Вся конструкция оператора switch основана на метках case, имеющих целочисленные значения. Когда условие, проверяющееся оператором switch совпадает с одним из значений метки case, то последующие за меткой действия будут выполнены. Если ни одно из условий не совпало с меткой case, то будут выполнены действия, следующие за меткой default. Оператор break, использующийся в конце всех действий для каждой метки очень важен. Когда условие совпадет с одной из меток и начнется выполнение указанных действий для этой метки, то выходной точкой служит оператор break. Если вы случайно забудете поставить оператор break, то ваша программа начнет выполнять следующую метку, сведя тем самым ваши усилия по выбору заданных действий на ноль. Никогда не забывайте ставить оператор break для каждой из меток!
Условные операторы
Когда мы создавали и использовали класс RunTelefon, с методом main (), я говорил, что программа выполняет прописанный код строка за строкой и это действительно так. В небольших программах, таких, как мы создали, этого вполне достаточно, но в действительно огромных программах такой подход не логичен. Нельзя «прыгать» по программе, надо идти от строки к строке. Но если все же требуется перейти в программе к какому-то методу или месту программы, что тогда? Для этого в языке Java существуют условные операторы.
Рассмотрим ситуацию, которая более наглядно объяснит смысл операторов. Допустим, вы дома, у вас нет хлеба и надо сбегать в булочную за углом. Прежде чем идти в булочную вы обязательно проверите, есть ли у вас деньги на покупку хлеба и только потом отправитесь в магазин за хлебом. Здесь имеет место предусловие наличия денег, выполнение которого приводит вас либо к походу за хлебом, либо к соседу за деньгами. В том случае, если не рассматривать это предусловие, то вы бы вышли и пошли в магазин, а уже придя, стали бы искать по карманам. Вот для этого и существуют условные операторы. В языке Java имеется несколько условных операторов. Первый из них: if /else - представляющий собой такую сдвоенную конструкцию. Синтаксический шаблон условного оператора if /else выглядит следующим образом:
if (условие) { // действие №1 } else { // действие №2 }
Переводя эту конструкцию на русский язык, можно сказать: если (if) некое условие верно, то перейти к действию №1, а иначе (else) выполнить действие №2. Такая сдвоенная конструкция if /else может быть не обязательна, иногда достаточно лишь записи оператора if. Можно использовать вложенные операторы if /else, например:
if (условие 1) { if (условие 2) { } }
Здесь проверяется первое условие и если оно верное, то происходит переход к следующему оператору if, если и это условие верное, то выполняются действия и во втором и в первом условном операторе. Если же условие во втором операторе if не верно, то выполняются действия только первого оператора if. Условные операторы в программировании на Java используются постоянно и важно понимать их общий принцип работы.
В приложении
Это приложение не претендует на роль полного руководства по языку Java (Ява), но данного материала будет достаточно для дальнейшего изучения книги. Предлагаемая к рассмотрению в этом разделе информация содержит основы языка Java и ориентирована на неподготовленного читателя. Также нужно иметь в виду, что обучение языку Java будет происходить в соответствии с контекстом книги, а именно, всей той части языка Java, необходимой для программирования мобильных устройств. То есть такие «продвинутые» темы как аплеты, библиотеки AWT и Swing в этом приложении не рассматриваются, поскольку не применяются в Java 2 Micro Edition.
Введение в программирование
Программирование - это написание исходного кода программы на одном из языков программирования. Существует множество различных языков программирования, благодаря которым создаются всевозможные программы, решающие определенный круг задач. Язык программирования - это набор зарезервированных слов, с помощью которых пишется исходный код программы. Компьютерные системы еще не в силах понимать человеческий язык и логику, поэтому все программы пишутся на языках программирования, которые впоследствии переводятся на язык компьютера, то есть в машинный код. Системы, переводящие исходный код программы в машинный код, очень сложные и их, как правило, создают не один десяток месяцев и не один десяток программистов. Такие системы называются интегрированными средами программирования приложений.
Система программирования представляет собой огромную продуманную визуальную среду, где можно писать исходный код программы, переводить его в машинный код, тестировать, отлаживать и многое другое. Также существуют программы, которые позволяют производить вышеперечисленные действия при помощи командной строки. Язык Java предоставляет такую возможность, но в книге данная проблематика не освещается.
Вы, наверное, не раз слышали термин «программа написана под Windows или под Linux, Unix». Дело в том, что среды программирования при переводе языка программирования в машинный код могут быть двух видов — это компиляторы и интерпретаторы. Говоря про общий вид: компиляция или интерпретация программы задает способ дальнейшего выполнения программы. Программы написанные на языке Java всегда работают на основе интерпретации, тогда как программы написанные на C/C++ - компиляции. В чем разница этих двух способов? Компилятор после написания исходного кода в момент компиляции читает сразу весь исходный код программы и переводит в машинный код. После чего программа существует как одно целое и может выполняться только в той операционной системе, в которой она была написана. Поэтому программы, написанные под Windows, не могут функционировать в среде Linux и наоборот. Интерпретатор осуществляет пошаговое или построчное выполнение программы каждый раз, когда она выполняется. Во время интерпретации создается не выполняемый код, а виртуальный, который впоследствии выполняется виртуальной Java машиной. Поэтому на любой платформе — Windows или Linux, Java-программы могут одинаково выполняться при наличии в системе виртуальной Java машины, которая еще носит название Системы времени выполнения.
Все что сейчас от вас требуется - это изучение синтаксиса языка Java, для того чтобы писать и понимать исходные коды программ, написанные на этом языке. А так же освоить работу с одной из сред программирования, подробное описание которых вы найдете в главе 3. Это приложение содержит теоретический материал, раскрывающий особенности программирования на языке Java.
Закрытые и открытые члены классов
Ключевое слово public, объявленное перед методом main (), показывает на то, что метод main () считается открытым или в любом классе метод main () виден, и к нему можно обратиться. Ключевое слово public может назначаться не только методам, но и объектам класса, переменным, любым членам созданного класса. Все объявленные члены класса с ключевым словом public, будут доступны всем другим существующим в программе классам, поэтому стоит призадуматься, а хорошо ли это? Например, у вас есть какие-то данные, которые не должны быть доступны другим классам, что тогда? Для этого в языке Java существует еще пара ключевых слов: private и protected, благодаря которым вы защищаете свои члены классов от общего доступа.
По умолчанию, если вы не используете ключевые слова, Java назначает всем членам класса спецификатор public. Метод main () всегда должен вызываться с ключевым словом public, чтобы для всех классов программы метод main () был доступен. Как только программа начнет работать, первым делом она ищет метод main () и постепенно, шаг за шагом, а точнее, строка за строкой, выполняет все предписанные действия в методе main ().
