Linuxformat - Вклад участника [ru]

LXF99:Java EE

2008-03-19T07:15:02Z

Maximax: Новая: {{Цикл/Java EE}}

LXF98:Java EE

2008-03-19T07:14:56Z

Maximax: Новая: {{Цикл/Java EE}}

LXF97:Java EE

2008-03-19T07:14:17Z

Maximax: Новая: {{Цикл/Java EE}}

LXF95:Java EE

2008-03-19T07:14:06Z

Maximax: Новая: {{Цикл/Java EE}}

LXF94:Java EE

2008-03-19T07:14:00Z

Maximax: Новая: {{Цикл/Java EE}}

LXF93:Java EE

2008-03-19T07:13:54Z

Maximax: Новая: {{Цикл/Java EE}}

LXF92:Java EE

2008-03-19T07:13:47Z

Maximax: {{Цикл/Java EE}}

LXF91:Java EE

2008-03-19T07:13:33Z

Maximax: Новая: {{Цикл/Java EE}}

LXF90:JavaEE

2008-03-19T07:13:22Z

Maximax: {{Цикл/Java EE}}

LXF96:Java EE

2008-03-19T07:13:02Z

Maximax: {{Цикл/Java EE}}

{{Цикл/Java EE}}
== Java Enterprise Edition: Перекличка серверов ==

''ЧАСТЬ 8, Отыскали пару лишних серверов и готовы написать настоящее распределенное приложение? '''Александр Бабаев''' подскажет подходящий способ.''

На этом уроке наше приложение будет усложнено ровно в два раза. Раньше сервер был один (он обрабатывал запросы пользователей и менял список записей телефонной книги), теперь добавим ему напарника. Предположим, что это выделенный сервер, который хранит данные пользователей – имена, пароли, дополнительную информацию, и мы решили связать web-сервер с этим вторым, чтобы, например, можно было по имени пользователя получить дополнительную информацию о нем.

Для удобства ссылок дадим серверам названия. Пускай наш старый называется Нео, а большой сервер с разной информацией – Матрица.

Прикинем, как все устроить. Для тестов все программы (оба сервера) будут запускаться на одном компьютере. Но, поменяв соответствующие IP-адреса (ниже мы разберемся, какие именно), можно будет запускать Нео и Матрицу на разных компьютерах одной и той же подсети. Правда, если между ними есть всякие-разные устройства вроде маршрутизаторов, шлюзов и мостов, тесты могут и не заработать. Это предупреждение! Реализовать более сложную схему взаимодействия тоже можно, но на это нам, к сожалению, не хватит журнального места, которое вполне конечно.

Итак, получается следующая топология сети:

[[Изображение:LXF96-JavaEE_1.png]]

=== Как докричаться? ===
Классический способ связи двух разных программ – через файлы: одна пишет, другая читает. Например, можно сделать общий файл для записи команд, куда пишет Нео и откуда читает Матрица, и файл ответов, где запись/чтение происходят наоборот.

Способ простой, но плохой: возникает огромное количество проблем, из которых падение производительности – самая маленькая. Рассматривать его не будем.

Другой способ – связь через так называемый «сокет». Сокет – это такая штука, к которой можно присоединиться [англ. socket – «розетка»]. Сервер «открывает» сокет и «слушает» его. Клиент – подключается к серверному сокету, передает/получает данные, отключается. Затем подключается следующий клиент.

Можно представить себе сокет как телефон. Вы получаете номер абонента (открываете сокет), подключаете телефон (теперь вы слушаете сокет), вам звонят – соединяются с вашим сокетом... Ну, вроде бы понятно? Примерно так же соединяются и компьютеры. А чтобы определить, к какому конкретно сокету присоединяться, нужно знать адрес IP-компьютера и номер порта, на котором открыт сокет. Номер порта необходим, потому что на одном и том же компьютере может быть запущено несколько «слушающих» программ (серверов), и нужно, чтобы они не мешали друг другу. А клиент, с другой стороны, должен точно указать, какой именно сервер ему нужен.

Есть еще и третий способ, «каналы», но о нем мы поговорим несколько позже.

=== Сокеты ===
Итак, общая схема работы с сокетами достаточно проста. Сервер создает сокет:
<code>
ServerSocket serverSocket = new ServerSocket();
</code>
Дальше нужно открыть сокет для приема соединений. В Java это делается так:
<code>
serverSocket.bind(new InetSocketAddress(“localhost”, 10000));
</code>
Здесь мы говорим, что сервер будет слушать соединения, в адресе назначения которых указано “localhost” и порт 10000. Сразу отметим: чтобы создать сервер на портах с номерами, меньшими 1024, обычно нужны права суперпользователя.

Далее нужно ловить подключения. Обычно это делается в цикле (получили подключение, обработали, ждем следующее). Например, так:
<code>
while (true) {
Socket socket = serverSocket.accept();
int byteReceived = socket.getInputStream().read();
OutputStream outputStream = socket.getOutputStream();
outputStream.write(byteReceived + 1);
socket.close();
}
</code>
serverSocket.accept() ждет подключения, блокируя текущий поток, и как только оно появится, создает так называемый клиентский сокет, продолжая выполнение потока. Я читаю из потока сокета один байт, записываю в сокет его же плюс единицу и закрываю сокет.

Вот так все несложно. А как устроен клиент? Он создает сокет, пишет в него единицу, читает ответ (двойку) и выводит ее на экран. По Jav’овски это выглядит так:
<code>
Socket socket = new Socket(“localhost”, 10000);
socket.getOutputStream().write(1);
int result = socket.getInputStream().read();
System.out.println(“Result is: “ + result);
socket.close();
</code>
Здесь тоже все предельно просто, но тем не менее, работает. То есть, если создать два класса и в main первого поставить код сервера, запустить (он будет «висеть», слушая соединения), в main второго – код клиента, и запустить... Клиент выдаст 2.

=== NIO ===
Проблемы начинаются, когда соединений больше одного, когда их одновременно больше одного, когда они достаточно длительные, когда нужно принимать/отсылать громадные файлы или протокол работы сложный. Если все делать вручную, как мы сейчас, то получается очень и очень трудоемко: огромное количество потоков (рекомендуется, собственно, по одному на каждый запрос), проблемы отсоединений клиентов, отслеживания этих событий, сериализация (запись в поток и обратно) объектов, и так далее.

Еще один минус блокирующих сокетов в том, что они (простите за тафтологию) блокируют поток в ожидании подключения. А если под ключения нет? Значит, поток заблокирован навсегда. И дело не только в подключениях, но и в записи/чтении в/из сокета: случись что во время этих операций – заблокируют навсегда. Вдобавок при большом количестве соединений/потоков скорость работы сервера уменьшается гораздо быстрее, чем увеличивается количество соединений. То есть имеет место типичная ситуация плохой масштабируемости.

И тут на помощь приходит новый способ обработки соединений – NIO (The new I/O API), хотя и более сложный, но гораздо более масштабируемый. Эта библиотека появилась в Java 1.4, и она позволяет создавать неблокирующие соединения. Рассмотрим тот же сервер и клиент в реализации NIO.. Сначала создадим так называемый «канал»:
<code>
Selector acceptSelector = SelectorProvider.provider().openSelector();
ServerSocketChannel socketChannel = ServerSocketChannel.open();
socketChannel.configureBlocking(false);
</code>
Мы не просто создали канал, но еще и объявили его неблокирующим (работа с блокирующими каналами ничуть не лучше работы с блокирующими сокетами). Теперь нужно «объяснить» каналу, какие события нам интересны (присоединение клиента, чтение, запись, отсоединение). Займемся подсоединением клиента:
<code>
socketChannel.socket().bind(new InetSocketAddress(“localhost”, 10000));
socketChannel.register(acceptSelector, SelectionKey.OP_ACCEPT);
</code>
Теперь начинаем волшебный цикл обработки. В цикле проверяем, есть ли интересующие нас события в «канале», и если есть, итерируем по ним, получая клиентский сокет. Дальше с сокетом работаем так же, как было описано выше.
<code>
while (acceptSelector.select() > 0) {
Set readyKeys = acceptSelector.selectedKeys();
Iterator i = readyKeys.iterator();

while (i.hasNext()) {
SelectionKey key = (SelectionKey) i.next();
i.remove();
ServerSocketChannel nextReady = (ServerSocketChannel) key. channel();
Socket socket = nextReady.accept().socket();
outputInputPlusOne(socket);
}
}
</code>
Функция outputInputPlusOne(socket), как мы делали ранее, читает число, увеличивает его на 1 и записывает результат. При этом поток постоянно крутится в цикле, не блокируясь. Это позволяет использовать достаточно интересные методы обработки подключений: например, создавать только один поток для произволь ного количества подключений, и он один будет их все обрабатывать. Плюс, операции чтения и записи тоже можно сделать неблокирующими, и совсем будет сказка... Если бы не сложность. Переход на неблокирующую обработку подключений – увеличение объема программы в три раза. Неблокирующая запись и чтение – еще больше. В результате получается достаточно громоздкая схема. Увы, только так можно добиться хорошей производительности.

=== Минное поле ===
Но есть замечательная библиотека, где все это уже учтено. Внутри она использует NIO, поэтому отлично масштабируется. Зато наружу выходят очень простые и понятные методы, которые можно использовать, получая превосходный результат. Библиотека называется Apache Mina, она достаточно широко распространена (например, Jetty, который мы рассматривали в первой статье цикла, использует именно ее) и неплохо отлажена. Иными словами, ею можно пользоваться в «промышленных» масштабах, не особо беспокоясь о проблемах.
Сервер делается так:
<code>
SocketAcceptorConfig acceptorConfig = new SocketAcceptorConfig();
acceptorConfig.getFilterChain().addLast(“Serializator”, new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
DataServerHandler handler = new DataServerHandler();
SocketAcceptor acceptor = new SocketAcceptor();
acceptor.bind(new InetSocketAddress(“localhost”, 10000), handler, acceptorConfig);
</code>
В первой строчке создается конфигуратор (через него задаются разные параметры подключения), затем в него вставляется фильтр, через который пройдут все данные (фильтр распаковывает объекты Java из потока). В третьей строке создается обработчик событий (о нем чуть ниже), который обрабатывает события Mina, и дальше – инициализируется сервер (опять тот же bind).

Поскольку Mina использует NIO, сервер получается событийный. При подключении клиента вызывается обработчик (Handler), который обслуживает запрос. При поступлении данных – тоже вызывается Handler (уже другой метод). И так далее. Вот как выглядит обработчик - (Handler) в нашем случае:
<code>
public class DataServerHandler extends IoHandlerAdapter {
public void messageReceived(IoSession session, Object message)
throws Exception {
if (message instanceof Integer) {
session.write(((Integer) message) + 1);
session.close();
}
}
}
</code>
Мы переопредили только один метод, который отвечает за получе ние данных. Mina работает не с потоками, а с объектами (преобразованием занимается фильтр, который мы вставляли в конфигуратор). Поэтому наша задача упрощается: читаем Integer, прибавляем единицу, записываем обратно, закрываем сессию. Все.

Предыдущий клиент, правда, не подойдет – нужно создавать другой. Но он не сложнее, чем был. Вот его код:
<code>
SocketConnector connector = new SocketConnector();
SocketConnectorConfig config = new SocketConnectorConfig();
config.getFilterChain().addLast(“Serializator”, new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
ConnectFuture connectFuture = connector.connect(new InetSocketAddress(“localhost”, 10000), new DataClientHandler(), config);
connectFuture.join();
IoSession session = connectFuture.getSession();
session.write(new Integer(1));
</code>
Код клиента – практически точное повторение кода сервера. Даже обработчик есть. Только вместо Acceptor’а создаем Connector. connectFuture – это объект, который позволяет, во-первых, дождаться, пока присоединимся (.join()), а во-вторых, от него получается сессия, куда можно писать всякие объекты (в нашем случае – Integer). Обработчик, как и на сервере, простой:
<code>
public class DataClientHandler extends IoHandlerAdapter {
public void messageReceived(IoSession session, Object message)
throws Exception {
System.out.println(“Result is: “ + message.toString());
}
}
</code>
Все. Сложность в данном конкретном случае – четыре класса вместо двух. Но это оправданно. Mina позволяет гибко настраивать обработку данных, бегающих между клиентом и сервером: количество потоков, обрабатывающих каналы, и так далее. Все это позволяет создавать простые серверы буквально за минуты, а сложные – за считанные часы или за несколько дней.

=== RMI ===
Еще один способ соединения двух Java-программ – RMI (Remote Method Invocation, удаленный вызов метода). Это несколько другой класс соединений, который скрывает сокеты и прочую внутреннюю механику от программиста, но требует понимания совершенно других принципов.

Для работы RMI использует так называемый registry. Это специальная служебная программа, которая аккуратно регистрирует классы, желающие быть серверами. Например, там может зарегистрироваться наш сервер. После чего клиент, зная, где находится registry, подключается к нему и просит выдать ссылку на сервер – и получает ссылку на класс.

После этих магических пассов методы сервера можно вызывать, как будто они находятся прямо в клиенте, в той же Java-машине. А RMI сам понимает, что вызван метод сервера, организует передачу/прием данных, преобразования всего из всего и выдает результат. На Рис. 2 приведена схема работы RMI (исключая registry):

[[Изображение:LXF96-JavaEE_2.png]]

При создании класса, который может быть вызван удаленно (схема, когда обращаются непосредственно к методу, а он скрытыми путями вызывается на удаленной машине, называется удаленным вызовом, Remote Procedure Call), генерируются специальные классы-заглушки (stubs). Они-то и делают все «взмахи волшебными палочками». На самом деле, когда клиент выполняет удаленный вызов, вызывается аналогичный серверному метод заглушки. В этом методе параметры сериализуются и через сокет передаются на сервер, где вновь десериализуются, вызывается сервер, а ответ передается таким же образом (через заглушки) клиенту.
Чтобы RMI заработал, нужно сделать интерфейс для сервера и его реализацию, написать клиент, потом сгенерировать заглушки, все скомпилировать и запустить.
Интерфейс сервера прост:
<code>
public interface IRMIServer extends Remote {
public abstract int increment(int aValue) throws RemoteException;
}
</code>
Он должен наследоваться от интерфейса Remote, и все методы, вызываемые удаленно, должны выбрасывать исключение RemoteException. Реализация сервера не менее проста:
<code>
public class RMIServer implements IRMIServer {
public RMIServer() throws RemoteException {
super();
}

public int increment(int aValue) throws RemoteException {
return aValue + 1;
}
}
</code>
Реализация должна обязательно иметь конструктор по умолчанию, который выкидывает исключение RemoteException и вызывает super(). Метод реализуется как обычно.
Регистрация сервера может быть выполнена, например, в методе main того же сервера:
<code>
public static void main(String[] args) throws Exception {
System.setSecurityManager(new RMISecurityManager());
RMIServer Server = new RMIServer();
Naming.rebind(“RMIServer” , Server);
}
</code>
Здесь устанавливается менеджер безопасности (иначе нам скажут, что нет прав для работы с RMI), создается сервер и регистрируется в registry (rebind). Есть и метод bind, но он выдаст ошибку, если такой сервер уже зарегистрирован. В целях экономии места используем rebind, который проверку на существование такого же сервера не выполняет.

Клиент тоже устанавливает менеджер безопасности, после чего в registry ищет сервер (имя он знает). Как только найдет – просто вызывает метод, как если бы RMI не существовало.
</code>
public class RMIClient {
public static void main(String[] args) throws MalformedURLException,NotBoundException, RemoteException {
System.setSecurityManager(new RMISecurityManager());
String url = “//localhost/RMIServer”;
IRMIServer remoteObject = (IRMIServer) Naming.lookup(url);
System.out.println(“Result is “ + remoteObject.increment(1));
}
}
</code>
Запуск сервера и клиента несколько более сложен, чем обычно. До сих пор мы компилировали и запускали классы «просто так». Теперь создадим заглушки и запустим registry. Это делается так:
<code>
rmic RMIServer
</code>
создаст заглушку сервера (сначала нужно все скомпилировать, а потом выполнить эту команду с полным именем класса сервера). А команда
<code>
rmiregistry &
</code>
запустит RMI Registry с параметрами по умолчанию. Чтобы разрешить менеджеру безопасности делать все что угодно, нужно запустить клиент и сервер с параметром, указывающим на файл политики безопасности. Назовем этот файл open.policy и запишем в него следующее:
<code>
grant {
permission java.security.AllPermission;
};
</code>
Теперь запустим клиент и сервер:
<code>
java -Djava.security.policy=open.policy RMIServer
</code>
и
<code>
java -Djava.security.policy=open.policy RMIClient
</code>
Вот и все. Как можно заметить, чем проще и понятнее код клиента и сервера, тем больше телодвижений нужно сделать для запуска разных вспомогательных приложений. Это общая закономерность. Пока приложения простые, зачастую удобнее использовать просто сокеты; в более тяжелых случаях (например, для работы клиент-серверных приложений уровня предприятия, тех самых Enterprise Applications) проще один раз запустить что-то вроде registry, а потом пользоваться «благами цивилизации».

Стоит отметить, что RMI, создаваемый «по умолчанию», в нормальных приложениях использовать нельзя. Слишком много ограничений, слишком много неразрешимых проблем (например, если клиент и сервер находятся в разных подсетях, соединение становится почти невозможным; или – невозможно внести в registry-сервер, который запущен не на той же машине, где и registry). Но реализации, которые предоставляют так называемые контейнеры приложений (GlassFish, Sun WebSphere, JBoss и другие) – это именно то, что используется для связи клиентов с сервером. Там это все работает, и работает отлично.

LXF87-88:Java

2008-03-19T07:12:00Z

Maximax: ссылка в конце статьи на следующий цикл статей по java

{{Цикл/Java}}

=== Потоки в Java ===
''ЧАСТЬ 4: Завершая курс молодого Java-бойца, '''Антон Черноусов''' научит вас управлять потоками… Жаль, что не денежными.''

C каждым днем появляются все более мощные процессоры, многоядерная архитектура которых стала основной темой ушедшего года, поэтому двухядерный процессор в ноутбуке уже никого не удивляет. С одной стороны — это обстоятельство приближает возможности простого пользователя к возможностям «понастоящему» больших систем. С другой (и рекламные буклеты об этом обычно молчат) — для того, чтобы использовать весь потенциал современных компьютеров, приложение должно «уметь» просчитать задачу фактически на двух или более процессорах.

Создание эффективных алгоритмов для работы на многопроцессорных станциях — это большая и сложная работа. Несмотря на это, для любого программиста актуальна задача организации взаимодействия с медленными ресурсами (например, чтения, записи или копирования файлов, работы с принтером, сетью), так как немногие пользователи смирятся с тем, что их любимая программа «замирает» в момент выполнения какой-либо операции.

Во избежание описанных проблем программа должна использовать потоки или процессы. Под процессом понимается заявка на потребле-
ние всех видов ресурсов системы, кроме одного — процессорного времени, или иначе говоря, процесс — это запущенная на выполнение программа (такое определение дается в [[LXF87/88:Java#Литература|[1]]]). Поток рассматривается как самостоятельная активность внутри процесса, хотя существуют другие трактовки этого понятия, которые зависят от используемой операционной системы (см., например, [[LXF87/88:Java#Литература|[2]]]). Поток получил свое название по аналогии с потоком команд, поступающих в процессор; при выполнении потоки делят адресное пространство и выделенную память внутри одного процесса. Процессорное время распределяется между различными потоками операционной системой, точнее, одним из компонентов ее ядра — планировщиком. Более полно с понятием процессов и потоков и механизмов работы с ними с точки зрения операционной системы вы можете ознакомиться в книге [[LXF87/88:Java#Литература|[3]]].

Давайте завершим наш экскурс в теорию и окунемся в реальность Java. Под процессом здесь принято понимать всеобъемлющий контекст выполнения, обеспечивающий высокий уровень изоляции охватываемых им данных от внешнего мира, а под потоком — более «легковесный» активный агент; в контексте одного процесса может функционировать целое множество потоков [[LXF87/88:Java#Литература|[4]]]. Планирование потоков в Java обеспечивается внутренними механизмами JVM.

=== Поток, он же thread ===
В Java существует два способа работы с потоками: первый заключается в реализации интерфейса Runnable, второй связан с наследованием
класса Thread, который уже реализует данный интерфейс. В обоих случаях класс должен предоставлять реализацию метода run(). Ниже
приведен пример класса, реализующего поток через наследование класса Thread:
<source lang = "java">
public class FirstThread extends Thread {
public void run(){
for (int i = 1 ; i < 30; i++)
System.out.println("It is in thread "+ i);
}
}
</source>
Собственно, метод run() и должен содержать некоторый набор инструкций (разумеется, на языке Java), которые вы хотите выполнить
в отдельном потоке. Например, если вы реализуете функцию копирования файла (а пользователь, скажем, копирует ISO-образ объемом
600 Мб), желательно, чтобы эта операция выполнялась в отдельном потоке, запуск которого можно производить следующим образом:
<source lang = "java">
public class ConsoleToThread {
public static void main(String[] args) {
FirstThread thread = new FirstThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
При выполнении метода main() класса ConsoleToThread создается объект-поток FirstThread, который запускается на выполнение методом start() [заметьте — метод run() никогда не вызывается явно, — прим.ред.]. Метод join() используется в случае, когда необходимо «дождаться» завершения потока. Завершение работы потока происходит при выходе из метода run(), как явном (например, посредством return), так и неявном (если внутри метода возникло и не было обработано какое-то исключение).

Имейте в виду (это важно!): повторный запуск уже отработавшего потока приведет к исключению IllegalThreadStateException.

=== Реализация потока через Runnable ===
Давайте теперь рассмотрим пример работы с потоками через интерфейс Runnable. Если, допустим, класс SameRunnable реализует интерфейс Runnable, то запустить поток на основе этого класса на выполнение можно следующим образом:
<source lang = "java">
Runnable run = new SameRunnable();
Thread thread = new Thread(run);
thread.start();
</source>
В следующем примере в методе main() класса ConsoleToThreadTwo создается массив threadArray, состоящий из объектов-потоков. При
этом используется конструктор класса Thread, принимающий два параметра: ссылку на объект, реализующий интерфейс Runnable и
имя потока:
<source lang = "java">
Thread thread = new Thread(Runnable, ThreadName);
</source>
Метод getName() объекта, реализующего поток, возвращает указанное при создании имя. Обратите внимание, что в нем используется
статический метод Thread.currentThread(), возвращающий ссылку на объект Thread, соответствующий выполняющемуся в текущий момент
потоку:
<source lang = "java">
public class SecondThread implements Runnable {
public String getName() {
return Thread.currentThread().getName();
}
public void run() {
for (int i = 1; i < 100000; i++) {
if ((i % 10000) == 0) {
System.out.println(getName() + " counts " + i / 10000);
}
}
}
}

public class ConsoleToThreadTwo {
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
}
</source>
Проследив за выводом этой программы, можно заметить, что процессорное время распределяется между потоками практически равномерно, однако порядок их выполнения во многом случаен.

=== Приоритеты потоков ===
Для управления величиной процессорного времени, выделяемого потоку, можно воспользоваться приоритетами. Установка приоритетов происходит с помощью метода Thread.setPriority(), узнать текущий приоритет позволяет метод getPriority(). В классе Thread определены
три константы:
<source lang = "java">
MIN_PRIORITY = 1
NORM_PRIORITY = 5
MAX_PRIORITY = 10
</source>
Важно понимать, что значение приоритета потока предназначено для Java-машины и не соответствует реальным приоритетам потоков
в операционной системе.

Давайте немного изменим код метода main() класса ConsoleToThreadTwo:
<source lang = "java">
public static void main(String[] args) {
Thread[] threadArray = new Thread[3];
int pr = 0;
for (int i=0; i<threadArray.length; i++){
threadArray[i] = new Thread(new SecondThread(), "Thread " + i);
if (pr == 10)
pr = 0;
threadArray[i].setPriority(Thread.MIN_PRIORITY + pr);
pr++;
}
for (int i=0; i<threadArray.length; i++){
threadArray[i].start();
System.out.println(threadArray[i].getName() + " started");
}
}
</source>
Анализ результатов работы класса показывает, что потоки, получившие более высокий приоритет, выполняются чаще. Также, благодаря
условию на значение переменной pr, setPriority() никогда не будет передан приоритет, превышающий 10 (MAX_PRIORITY). Если бы это про-
изошло, система выбросила бы исключение IllegalArgumentException.

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

Что же это такое? Демон отличается от «простого смертного» потока вызовом метода setDeamon(true), который необходимо сделать до
начала работы. Например, так:
<source lang = "java">
FirstThread thread = new FirstThread();
thread.setDeamon(true);
thread.start();
</source>
Узнать, является ли поток демоном, можно с помощью метода isDeamon(). Обычно потоки-демоны создаются для обслуживания
некритичных задач, так как при завершении работы программа не дожидается их остановки, а прерывает их самостоятельно.

=== Где искать потоки? ===
В большинстве случаев бывает необходимо отслеживать ранее запущенные на выполнение потоки. Использование массива потоков,
как в предыдущем примере, не всегда оправданно. Для хранения и обработки потоков в Java существует класс ThreadGroup. Группа,
к которой принадлежит создаваемый поток, опять-таки передается конструктору Thread():
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
</source>
Если группа не указана явно, поток будет помещен в тот же ThreadGroup, что и его родитель.
<source lang = "java">
ThreadGroup tg = new ThreadGroup("NameThreadGroup");
Thread thread = new Thread(tg, new SecondThread(), "ThreadName");
Thread thread1 = new Thread(tg, new SecondThread(), "ThreadName2");
Thread thread2 = new Thread(tg, new SecondThread(), "ThreadName3");
System.out.println("active thread in group " + tg.activeCount());
thread.start();
thread1.start();
System.out.println("active thread in group " + tg.activeCount());
Thread[] threads = new Thread[tg.activeCount()];
int m = tg.enumerate(threads);
System.out.println("taked threads from group : " + m);
for (int i = 0; i < threads.length; i++) {
System.out.println(threads[i].getName());
}
</source>
В представленном выше примере в экземпляр класса ThreadGroup помещаются три потока, два из которых запускаются на выполнение.
Количество активных потоков в группе определяется с помощью метода activeCount(), а в результате выполнения метода enumerate() формируется перечень всех активных потоков.

=== Управление потоками ===
При запуске потоков следует учитывать и то, что их иногда приходится останавливать, причем как штатно, так и экстренно. Для того, чтобы
приостановить работу потока изнутри, допустим, в тот момент, когда закончилась доступные для обработки данные, можно использовать
два метода: sleep() и wait().
<source lang = "java">
public class ThirdThread extends Thread {
public void run() {
for (int i = 1; i < 110; i++) {
if (i == 10) {
try {
sleep(10000);
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)");
}
}
if (i == 100) {
try {
synchronized (this) { wait();}
}
catch (InterruptedException e) {
System.out.println("the thread was awaken there (just a moment ago)again");
}
}
}
}
}
</source>
Методу sleep() передается переменная типа long, соответствующая количеству миллисекунд, в течении которых поток будет «спать». В
случае wait() поток ждет пробуждения снаружи. Применение методов sleep() и wait() требует обработки исключительной ситуации, которая возникают при пробуждении потока. В представленном ниже классе ConsoleToThreadThree потоки пробуждаются с помощью метода interrupt():
<source lang = "java">
public class ConsoleToThreadThree {
public static void main(String[] args) {
ThirdThread thread = new ThirdThread();
thread.start();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
for (int i = 1; i < 20; i++) {
System.out.println("It is in main " + i);
}
thread.interrupt();
try {
thread.join();
}
catch (InterruptedException ex) {
System.out.println("Exception in stop thread");
}
}
}
</source>
Отметим, что вызов метода wait() без блока синхронизации (synchronized), о котором мы поговорим чуть ниже, приводит к исключению IllegalMonitorStateException. Возникшая ошибка свидетельствует об отсутствии монитора у объекта (понятие монитора и синхронизация
тесно связаны, о чем мы тоже поговорим ниже). Если для приостановления потока был применен метод wait(), то для «пробуждения» потока
можно воспользоваться методом notify() или notifyAll(). Первый пробуждает один случайно выбранный спящий поток, а второй пытается
пробудить их всех.

Кроме рассмотренных выше методов, иногда бывает целесообразно использовать метод yield(), который приостанавливает работу текущего потока. Метод yield() не переводит поток в режим ожидания, как wait(), но предоставляет другим потокам возможность начать работать
раньше, чем допустила бы Java-машина [фактически, поток, вызвавший yield() добровольно отдает свой квант процессорного времени, -
прим. ред.]. Метод yield() статичный, так что прекратить с его помощью работу другого потока не получится.

Методов остановки потоков тоже нет (ранее присутствовали методы stop(), resume(), suspend(), но сейчас они объявлены как «deprecated» -
то есть нерекомендованными к использованию). На сегодня в Java принят уведомительный стиль остановки потока с помощью пары методов:
уже известного нам interrupt(), применяемого снаружи, чтобы выставить флаг завершения и метода isInterrupted(), вызываемого изнутри
потока, чтобы узнать состояние флага, свидетельствующего о том, что «пора закругляться».

=== Мониторы и синхронизация ===
Что такое «монитор», о котором говорилось выше? Нет, это не дисплей, это — объект, используемый как защелка, то есть в данный момент
времени владеть монитором может только один поток. В случае, если поток завладел монитором, говорят, что он «вошел» в монитор, а все
остальные потоки, пытающиеся это сделать, будут заморожены (часто говорят, что они «ждут» монитора) до тех пор, пока владелец монитора
его не освободит, то есть не покинет.

Если перейти к реалиям Java, то объектов типа монитор в явном виде просто нет! С каждым объектом связан неявный монитор, и чтобы
завладеть им, необходимо вызвать метод или блок, помеченный ключевым словом synchronized. Как только поток входит в такой блок, он
завладевает монитором объекта, переданного synchronized в качестве параметра. Так происходит и в классе ThirdThread, однако, в момент
вызова метода wait(), монитор отпускается. Пример synchronized-метода представлен ниже:
<source lang = "java">
public synchronized boolean sameCheck() {
if (a) {
a = false; return true;
}
else {
a = true;
return false;
}
}
</source>
В целом, синхронизация — это механизм, обеспечивающий монопольный доступ участка кода к некоторому объекту. Одним из первых
способов, предложенных для синхронизации работы потоков, были семафоры, концепцию которых описал Дейкстра [Dijkstra] в 1965 году
(часто говорят, что семафор — это классический синхронизированный примитив). Семафор используется для предоставления доступа к огра-
ниченному количеству ресурсов. Как правило, у семафора есть две операции: P — занять ресурс и V — освободить ресурс. Он может быть
реализован следующим образом:
<source lang = "java">
public class SimpleSemaphore {
int counter;
public SimpleSemaphore() {
this.counter = 1;
}

public synchronized void p() throws InterruptedException {
while (counter == 0) {
wait();
}
counter = counter + 1;
}

public synchronized void v() throws InterruptedException {
counter = counter - 1;
notify();
}
}
</source>
Можно, конечно, реализовывать семафоры самостоятельно, но проще воспользоваться специальной библиотекой java.util.concurrent.
Кроме семафоров, она включает в себя еще много чего интересного.

Отметим, что программа, в принципе, может не использовать ни один из методов синхронизации, обходясь методами wait() и notify().

=== Взаимные блокировки ===
На этом наш рассказ можно было бы и завершить, но чтобы у вас не сложилось впечатление, что в мире многопоточных приложений все
так радужно, мы поговорим о неприятных последствиях синхронизации. Как только количество потоков начинает стремительно расти и
возникает необходимость синхронизированного доступа к ограниченному кругу объектов в различной последовательности, будьте готовы к
ошибкам типа deadlock — взаимным блокировкам.

Взаимная блокировка — это ошибка, которая лучше всего описывается простой формулой: «Поток A держит монитор a и хочет захватить
монитор b, а поток B держит монитор b и хочет захватить монитор a». В результате оба засыпают «мертвым сном».

Ошибка очень противная и возникает обычно в нетривиальных алгоритмах. Лечится взаимная блокировка грамотным проектированием и профилактическими мерами, вроде следующей: всегда захватывайте мониторы в одном и том же порядке.

Сегодня мы поговорили о двух способах создания потоков Java, разобрались с приоритетами, познакомились со средствами управления работой потоков и демонами, а также сделали небольшой обзор методов синхронизации. Для того, чтобы начать практическую работу с потоками, этого вполне достаточно. Желающим разобраться во всем этом глубже я рекомендую ознакомится с книгой «Concurrent Programming in Java: Design Principles and Patterns», автором которой является Дуг Ли [Doug Lea] — она считается одной из лучших по данной тематике.

На этом мы заканчиваем обзор основ программирования на Java и в [[LXF89:Java_EE|следующий раз]] поговорим о серверных приложениях — приготовьтесь
к Java Enterprise Edition!

=== Литература ===
* 1. П. Кью «Использование UNIX», ISBN 5-8275-0019-4
* 2. В. Г. Олифер, Н. А. Олифер «Сетевые операционные системы», ISBN 5-272-00120-6
* 3. Д. Бэкон, Т. Харрис «Операционные системы», ISBN 5-94723-969-8
* 4. М. Фаулер «Архитектура корпоративных программных приложений», ISBN 5-8459-0579-6

LXF86:Java

2008-03-19T07:03:42Z

Maximax: ссылка в конце статьи на следующую статью

{{Цикл/Java}}

=== Хранение данных ===
''ЧАСТЬ 3: Даже самой замечательной программе надо откуда-то черпать данные для своей работы. Данные, как известно, хранятся в файлах. Тему продолжает '''Антон Черноусов'''.''

В предыдущей статье из цикла, посвященного программированию на Java, были рассмотрены вопросы организации простых вычислений, ветвлений, циклов, а также генерации и обработки исключений.

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

=== Файлы — потоки ===
Сказочное королевство под руководством царевны Несмеяны (так как cупруг практически всегда отсутствовал), благодаря талантам и приобретенным навыкам, стало разрастаться, и результаты полюдья просто-напросто перестали помещаться в семейный чулан. Чтобы накапливать и хранить богатства, потребовались дополнительные помещения, роль которых для нас привычно играют файлы.

Отношение к файлам в Java достаточно непростое: если рассматривать файл как устройство для ввода/вывода информации — с этой точ
ки зрения он подобен блоку памяти или экрану, интерфейс доступа к которому унифицирован: это поток. Но несмотря на унифицированный интерфейс, существует большое количество классов сходной функциональности, в которых легко запутаться.

Поток можно представить в виде ленточного конвейера с последовательным размещением или извлечением данных, при использовании
которого задача программиста сводиться к осуществлению операций «поместить/читать» данные, а остальные детали реализации скрыты
от него.

=== Чтение данных ===
Разнообразие классов для работы с файлами позволяет выбрать для себя ту связку, которая больше нравится. Лично я для чтения данных использую BufferedReader, InputStreamReader и FileInputStream. Собственно взаимодействие этих классов для программиста заканчивается в момент создания экземпляра BufferedReader, что делается следующим образом:

<source lang = "java">
BufferedReader br = null;
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile), encoding));
</source>

В процессе создания участвуют строковые переменные, содержащие путь к файлу и кодировку, в которой производится считывание
данных: pathToFile и encoding. В классах, работающих с файлами, считается обязательным создавать переменную для кодировки по умолчанию:

<source lang = "java">
protected static String DEFAULT_ENCODING = "UTF-8";
</source>

Любой текстовый файл можно представить себе в виде набора строк, поэтому давайте реализуем метод для считывания содержимого
файла в массив String[]. Далее представлен метод rippedCurrentFile(path ToFile, encoding) класса FileRipper, который извлекает данные из файла с помощью метода readLine() экземпляра класса BufferedReader:

<source lang = "java">
protected boolean rippedCurrentFile(String pathToFile, String encoding) {
// connecting to file
BufferedReader br = null;
try {
br = new BufferedReader(new InputStreamReader(new FileInputStream(pathToFile),encoding));
}
catch (UnsupportedEncodingException e) {
this.error = FILE_ERROR_UNSUPPORTED_ENCODING; return false;
}
catch (FileNotFoundException e) {
this.error = FILE_ERROR_NO_FILE; return false;
}
// ripping the file
String str = null;
ArrayList allStrings = new ArrayList();
try {
while (!(str = br.readLine()).equals(null)) { allStrings.add(str); }
}
catch (IOException e) {
this.error = FILE_ERROR_IO_READ; return false;
}
catch (NullPointerException e) {
this.error = FILE_ERROR_END_OF_FILE;
}
// free the resources
try {
br.close();
}
catch (IOException e) {
this.error = FILE_ERROR_IO_CLOSE; return false;
}
this.allStrings = (String[]) allStrings.toArray(new String[0]);
return true;
}

</source>
Полный код примера, в том числе код класса ConsoleToFileRipper, применяющий экземпляр класса FileRipper для извлечения данных из файла, можно найти на диске в каталоге '''examples 1'''.

=== Запись данных ===
Процесс записи данных в файл хоть и отличается от чтения, но тоже достаточно похож на организацию конвейера. Для записи
я обычно использую связку BufferedWriter, OutputStreamWriter, FileOutputStream.
<source lang = "java">
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
</source>
Для освобождения ресурсов, которые используют экземпляры классов BufferedReader и BufferedWriter, необходимо вызвать метод
close().

Далее приведу простой пример метода, который записывает строковый массив в файл (полный код метода расположен на диске в
директории '''examples 2'''):
<source lang = "java">
public boolean createCurrentFile(String pathToFile, String[] allStrings, String encoding){
try {
BufferedWriter out;
out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(pathToFile), encoding));
for (int i = 0; i < allStrings.length; i++) {
out.write(allStrings[i]); out.write(‘\n’);
}
out.close();
}
catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
</source>

=== Свободный доступ ===
В представленных ранее примерах доступ к данным осуществляется последовательно, что не всегда удобно (хотя в большинстве случаев именно такой доступ и используется). Для осуществления чтения и записи данных из файла в произвольном порядке существует специальный класс RandomAccessFile, экземпляр которого создается следующим образом:
<source lang = "java">
RandomAccessFile raf = new RandomAccessFile(pathToFile, mode);
</source>
При этом pathToFile — путь до файла, а mode — режим работы. mode может принимать значения: r (только чтение), rw (чтение-запись), rws (чтение-запись с синхронным сохранением содержимого и метаданных), rwd (чтение-запись с синхронным сохранением содержимого файла). К сожалению, кодировку указать нельзя. Огромным преимуществом подхода является то, что с помощью метода getFilePointer() можно узнать текущее месторасположение указателя, а с помощью метода seek() можно передвинуть указатель в необходимое место в файле. Я предпочитаю не использовать данный класс — считайте это личным предубеждением.

=== Протоколирование работы программы ===
Для контроля и анализа работы приложения существуют методы протоколирования. Популярным инструментом для этих целей в мире
Java является библиотека Log4j, которая разрабатывается в Apache Software Foundation. Текущую версию можно загрузить с [http://logging.apache.org/[http://logging.apache.org/]].

Для использования библиотеки необходимо создать конфигурационный файл, который описывает, что, куда и как нужно протоколировать. Log4j имеет три базовые составляющие: logger, appender и layout.

layout — это элементы, определяющие вид и содержание записей. Изначально имеется несколько заранее созданных layout-ов, а в случае необходимости можно создать свой собственный.

Appender — это элемент, определяющий местоположение протокола, с его помощью задается тип протоколирования:
* файловое протоколирование (FileAppender);
* консольное протоколирование (ConsoleAppender);
* протоколирование в базы данных (JDBCAppender);
* протоколирование на SMTP-сервера (SMTPAppender) и др.

Logger — это элемент, который обеспечивает протоколирование какого-либо события. Если обратиться к ранее приведенной аналогии
ленточного конвейера, logger — это и есть тот самый конвейер, вызывая методы которого, мы формируем протокол работы программы.
Элемент logger предусматривает следующие уровни протоколирования: DEBUG, INFO, WARN, ERROR, FATAL; уровням соответствуют методы класса org.apache.log4j.Logger: debug; info; warn; error; fatal.

Ниже представлен пример записей для конфигурационного файла нашего приложения, которые нужно сохранить в файл с названием '''log.properties''' (название файла может быть любым).

<code>
log4j.logger.simple=DEBUG, nameLogAppender
log4j.appender.nameLogAppender=org.apache.log4j.FileAppender
log4j.appender.nameLogAppender.File=nameLogFile.log
log4j.appender.nameLogAppender.layout=org.apache.log4j.SimpleLayout
</code>

Первая строка указывает используемый уровень logger (DEBUG) и appender (nameLogAppender). Далее идут настройки appender: указание типа — FileAppender. В третьей строке указываем путь до файла журнала, а в последней — формат записи. Использовать экземпляр класса Logger можно примерно так (пример протоколирования приведен на диске в каталоге '''examples 3'''):
<source lang = "java">
File propertiesFile = new File("log.properties");
PropertyConfigurator.configure(propertiesFile.toString());
Logger logger = Logger.getLogger("simple");
logger.info("the program has started");
</source>

=== Документы XML ===
Проектируя и создавая ПО, невозможно не столкнутся с миром XML (Extensible Markup Language). XML был создан в недрах World Wide
Web Consortium (W3C) для преодоления ограничений языка HTML. Можно сказать, что HTML — один из самых успешных языков, область
его использования с каждым годом растет (в основном в объемах). Несмотря на это, почему же W3C создал XML, и зачем вам использовать этот язык? В чем ограниченность HTML? Ответ на эти вопросы один:XML был создан для обеспечения взаимодействия разнородных систем.

HTML, как и любой другой текстовый язык, не позволяет перенести смысл тех данных, которые он хранит. XML был разработан для решения этой задачи с прицелом на Web, но получился таким удачным, что его стали использовать практически везде. Суть XML в том, что он хранит семантический смысл данных, поэтому выполнив анализ такого XML-документа, система может «понять» полученные данные. В Интернете существует большое количество информации, посвященной XML (например, [http://www.ibm.com/developerworks/xml/[www.ibm.com/developerworks/xml/]]), поэтому не будем подробно останавливаться на его преимуществах, а сразу приступим к использованию.

<source lang = "xml">
<?xml version="1.0" ?>
<line name="firstLine">
<point id="1" theX="1" theY="1"/>
<point id="2" theX="2" theY="2"/>
</line>
</source>

Выше приведен простой пример XML-документа, содержащего корневой элемент line, который, в свою очередь, содержит два узла с
тремя атрибутами (id, theX, theY) каждый.

=== Создание XML-документа ===
Говоря про создание XML-документа, я подразумеваю создание дерева XML-документа в памяти системы, то есть объекта DOM (Document Object Model). DOM была создана W3C, и это — официальная Рекомендация консорциума. В противовес DOM существует SAX (Simple API for XML). С моделью SAX можно ознакомиться более подробно в
[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp[http://www-128.ibm.com/developerworks/ru/views/xml/libraryview.jsp]]. Основная разница между методами заключается в том, что DOM обеспечивает виртуальное представление XML-файла в памяти системы, в то время как SAX — это событийная модель обработки, в которой в момент встречи определенного элемента вызывается соответствующее событие.

Для создания «отображения» XML-файла в памяти системы необходимо воспользоваться классом Document, экземпляр которого можно получить следующим образом:
<source lang = "java">
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.newDocument();
</source>
Создание корневого узла XML документа можно выполняется так:
<source lang = "java">
Element root = doc.createElement("line");
root.setAttribute("name", "firstLine");
</source>
С помощью метода createElement(name) производится создание элементов, в то время как создание и установка значений атрибутов
элементов производится с помощью метода setAttribute(name, value), где name — имя атрибута, а value — его значение. С помощью метода appendChild можно добавить узел в элемент или произвести запись элемента в документ XML, например, так:
<source lang = "java">
root.appendChild(item);
doc.appendChild(root);
</source>
Более детально процесс создания XML документа на примере класса Line изложен в директории '''examples 4'''. При вызове метода
createDoc() этого класса создается экземпляр класса Document, идентичный приведенному ранее коду XML.

=== Сохранение XML-документа ===
Для сохранения созданного в памяти документа предлагаю воспользоваться методом saveXML(docToSave, pathToFile, charSet). В процессе сохранения участвует уже знакомый нам OutputStreamWriter, а также экземпляр класса Transformer, который обеспечивает преобразование объекта DOMSource в выходной поток.
<source lang = "java">
public void saveXML(Document docToSave, String pathToFile, String charSet) {
try {
Writer target = new OutputStreamWriter(new FileOutputStream(pathToFile), charSet);
Source source = new DOMSource(docToSave);
StreamResult dest = new StreamResult(target);
Transformer t = TransformerFactory.newInstance().newTransformer();
t.setOutputProperty(OutputKeys.ENCODING, charSet);
t.setOutputProperty(OutputKeys.INDENT, "yes");
t.transform(source, dest);
target.flush();
target.close();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
</source>
Реализация этого метода представлена на диске в директории '''examples 5'''.

=== Загрузка XML-документа ===
Подобно сохранению XLM-документа, загрузка также достаточно просто выполняется с помощью экземпляра класса FileInputStream. Используя DocumentBuilderFactory, сгенерируем объект класса Document следующим образом:
<source lang = "java">
FileInputStream fis = new FileInputStream(pathToFile);
Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(fis);
</source>
Фактически, создание документа происходит вследствие выполнения метода parse. Для детально рассмотрения процесса загрузки
XML документа обратитесь к директории '''examples 6''', расположенной на диске.

=== Извлечение данных из XML-документа ===
Итак, что же делать с Document? Работать, естественно! Прежде чем приступить к обработке XML-документа, хочу обратить внимание на одну неприятную особенность: почти всегда XML документ содержит пустые узлы или символы перевода каретки (неизбежное зло форматирования). К сожалению, такая особенность существенно затрудняет процесс обработки XML-документа. Поэтому следует всегда проводить нормализацию с помощью определенного в интерфейсе метода normalize(), или, если реализация Document не имеет такой возможности или нормализация выполняется некорректно — воспользуйтесь методом normalizeDocument класса FileXMLReader (вы найдете его все в той же директории '''examples 6'''). Вызвать данный метод можно следующим образом:
<source lang = "java">
normalizeDocument(doc.getDocumentElement());
</source>
Изложенный выше материал получился несколько другого формата, нежели предыдущие статьи. Статья содержит небольшие примеры
и отсылает на набор сознательно упрощенных готовых решений, благодаря которым вы сможете работать с файлами, производить прото-
колирование деятельности вашего приложения, начать работать с данными в формате XML. Цель приведенных примеров — обеспечить вас
необходимым минимумом информации и дать направление для поиска ответов на Ваши вопросы. В [[LXF88:Java|следующей статье]] мы расмотрим Потоки.

LXF85:Java

2008-03-19T06:59:06Z

Maximax: ссылка в конце статьи на следующую статью

{{Цикл/Java}}
=== Считалочки ===
''ЧАСТЬ 2: Мало сыграть свадьбу — надо еще научиться вести семейный бюджет, выполнять одну и ту же работу каждый день и принимать судьбоносные решения. '''Антон Черноусов''' продолжает учить монархическую чету премудростям Java.''

В предыдущей статье были рассмотрены основы объектно-ориентированного языка программирования Java: инкапсуляция,
наследование, полиморфизм. Мы создали простое приложение, в котором женили короля на царевне Несмеяне.

Сегодня мы поговорим о простых типах (числах), о ветвлениях, циклах, а также об исключениях.

=== Простые числа и их братья ===
Итак, мы оставили нашу царевну Несмеяну в семейном гнезде, где она в скором времени добралась до казны государства. Ей пришлось
освоить нехитрую математику — отнимать и делить: ведь казна требует строго учета, и никакая программа не обходится без вычислений. Без них невозможно создать даже самую простую систему учета и контроля, а мадам необходимо наладить нетривиальный учет бюджетных средств.

Для реализации арифметических операций в Java существует семь арифметических операторов, которые работают с любыми числовыми типами: сложение +, вычитание -, умножение *, деление /, остаток %, унарный минус -val и унарный плюс +val, а также шесть примитивных типов переменных для выполнения арифметических операций:
{| border = "1" cellpadding="2"
!Тип переменной
!Разрядность
!Описание
|-
|Byte||align="center"|8||Целое со знаком
|-
|Short||align="center"|16||Целое со знаком
|-
|Int||align="center"|32||Целое со знаком
|-
|Long||align="center"|64||Целое со знаком
|-
|Float||align="center"|32||Число с плавающей точкой
|-
|Double||align="center"|64||Число с плавающей точкой
|}

Значение типов byte и short при выполнении вычислений переопределяется int, поэтому использование этих типов целесообразно для
хранения небольших значений для уменьшения объема используемой оперативной памяти.
<source lang = "java">
int iA = 10;
byte bB = 12;
int iC = iA + bB;
System.out.println("Сумма А и B = " + iC);
</source>
Выше приведен пример выполнения арифметической операции с использованием переменных различных типов. Результат — целое число типа int. Для преобразования типа переменной, например, в тип с более низкой разрядностью, необходимо воспользоваться специальными языковыми конструкциями:
<source lang = "java">
double dD = 10.2;
double dE = 12.23;
float fF = (float) (dD + dE);
System.out.println(fF);
</source>

=== Логика и выбор ===
Чтобы провести ревизию налоговой службы правильно, Несмеяне пришлось разобраться с налоговым кодексом, а там без поллитра и знаний логических операций не обойтись.

Для представления логических значений в Java присутствует простой тип boolean, который принимает значения true или false. Для проведения различных логических операций можно использовать ниже перечисленные операторы:

{| border = "1" cellpadding="2"
!Тип операторов
!Операторы
|-
|операторы отношений
|align = "center"| <     >     >=     <=     instanceof
|-
|операторы равенства||align = "center"|==     !=
|-
|поразрядное И||align = "center"|&
|-
|поразрядное исключающее ИЛИ||align = "center"|^
|-
|поразрядное включающее ИЛИ||align = "center"|ǀ
|-
|логическое И||align = "center"|&&
|-
|логическое ИЛИ||align = "center"|ǁ
|}

Пока Несмеяна разбирается в дебрях налогового кодекса, мы для иллюстрации работы с логическими выражениями обратимся к методу
primeNumberCheckUp(int numberForCheck), который выясняет, является ли переданное ему число простым.
<source lang = "java">
private boolean primeNumberCheckUp(int numberForCheck) {
boolean result = true;
if (numberForCheck != 1 || numberForCheck != 2 || numberForCheck != 3) {
for (int currentNumber = 2; currentNumber < numberForCheck; currentNumber++) {
if (numberForCheck % currentNumber == 0) {
result = false;
}
}
}
return result;
}
</source>
В primeNumberCheckUp использованы две замечательные конструкции: оператор выбора по условию или условный оператор, и цикл.
Условный оператор if имеет следующий синтаксис:
<source lang = "java">
if (логическое выражение) {
операторы группы 1;
}
else {
операторы группы 2;
}
</source>

В вышеописанном методе использована упрощенная конструкция (без else), а для вычисления логического выражения использованы
операторы: != (не равно) и || (логическое «или»). В полной конструкции в случае истинности логического выражения выполняются операторы группы 1, иначе — группы 2.

Вместо if для управления выполнением кода может быть использована специальная конструкция switch. В рамках этой конструкции
вычисляется целочисленное выражение, и в соответствии с полученным результатом ведется поиск соответствующего значения блока
case.
<source lang = "java">
int flag = 6;
switch (flag) {
case 1: {
System.out.println("Царевна в спальне №1");
break;
}
case 5: {
System.out.println("Царевна в спальне №5");
break;
}
default: {
System.out.println("Кто тут знает, где царевна?");
break;
}
}
</source>
Обратите внимание на оператор break, который обеспечивает немедленный выход из любого блока, а в примере выше прекращает дальнейшую обработку операторов конструкции switch, а также на блок операторов default — этот блок необязательный, он выполняется в случае, если выражение, удовлетворяющие условию, не было найдено среди case.

=== Циклы ===
Разобравшись, как все устроено в королевстве, Несмеяна поняла, что все подчиняется принципу «Украл, выпил, в тюрьму» — точнее, во Дворец до следующего месяца. По кругу.

Для реализации «кругового» процесса в Java существует три вида циклов: for, while и do-while. С циклом for мы уже вы встречались в методе primeNumberCheckUp, продемонстрированном ранее, синтаксис этой конструкции следующий:
<source lang = "java">
for (инициализация; логическое выражение; приращение) {
операторы;
}
</source>
В рамках инициализации производится объявление и установка значений временных переменных. Цикл выполняется до тех пор, пока
логическое выражение истинно. На каждой итерации цикла производится приращение временных переменных.

Две другие конструкции циклов можно назвать однояйцевыми близнецами, если бы не маленькое отличие в их использовании. При
использования цикла while проверка условия осуществляется до выполнения блока операторов, а в конструкции do-while — после него, то есть действия внутри цикла отрабатывают хотя бы раз. Например, процесс одиночной попойки короля от счастья, что он женат, на языке Java можно описать так:
<source lang = "java">
int i = 100;
while (i > 0) {
System.out.println(i + " бутылок пива стояло на столе, одну уговорил");
i--;
}
System.out.println("Все выпил, да!");
int tankard = 1;
int allTankards = 10;
do {
System.out.println(tankard + " стакан помыт");
tankard++;
}
while (tankard <= allTankards);
System.out.println("Ну вот и все стаканы помыл");
</source>

=== Массивы ===
Для организации хранения однотипных данных в Java можно использовать массивы. Массивом называется структура данных, которая
позволяет хранить несколько значений в одной переменной (определение расплывчатое, но суть передает верно). Объявить массив можно несколькими способами, но я предпочитаю следующий как наиболее логичный:
<source lang = "java">
int[] arrayName = new int[length]
</source>
При этом int — это тип переменных массива, а length — его размерность (число элементов). После того, как массив создан,
значения всех переменных равны null.

Многомерный массив — это обыкновенный массив, элементами которого являются массивы, причем совсем не требуется, чтобы они
имели одинаковую размерность, например:
<source lang = "java">
int[][] arrayName = new int[2][];
arrayName[0] = new int[5];
arrayName[1] = new int[2];
</source>
В некоторых задачах требуется создать массив, состоящий из произвольных чисел. Генерация произвольных чисел возможна благодаря
классу Random, который входит в пакет java.util. К слову, пакеты — это иерархически именованные контейнеры, применяемые для изолирования имен классов в некотором пространстве имен, то есть пакеты применяются во избежание конфликтов с именами классов.

Подключение класса Random к программе происходит при использовании зарезервированного слова import и команды import java.util.Random; традиционно объявляемой в начале файла, содержащего разрабатываемый класс.
<source lang = "java">
import java.util.Random;
public class RandomGenerator {
private static Random random = new Random();
private int base;
public RandomGenerator(int base) {
this.base = base;
};
public RandomGenerator() {
this.base = Math.abs(random.nextInt());
};
public int getInt(){
return Math.abs(random.nextInt(this.base));
};
}
</source>
Далее, приведенный код позволяет сгенерировать массив псевдослучайных чисел с использованием класса RandomGenerator, код
которого приведен выше:
<source lang = "java">
int[] newArray = new int[100];
RandomGenerator currentRG = new RandomGenerator(500);
for (int currentNumber = 0; currentNumber < 100; currentNumber++) {
newArray[currentNumber] = currentRG.getInt();
System.out.println("newArray[" + currentNumber + "] = " + newArray[currentNumber]);
}
</source>
Иногда невозможно установить точное количество элементов в массиве, в таком случае на помощь приходят динамические массивы ArrayList. ArrayList — это класс, который входит в Collection API. Объекты, созданные на основе ArrayList, более ресурсоемки. Давайте посмотрим на работу динамических массивов на примере задачи по поиску всех простых чисел в диапазоне от 1 до N:
<source lang = "java">
private Integer[] getAllPrimeNumbers (int numberForCheck){
ArrayList primeNumbers = new ArrayList();
for (int currentNumber = 1; currentNumber <= numberForCheck; currentNumber++) {
if (this.primeNumberCheckUp(currentNumber)) {
primeNumbers.add(currentNumber);
}
}
Integer[] result = (Integer[]) primeNumbers.toArray(new Integer[0]);
return result;
}

public int[] getIntArray(){
Integer[] arrayOfPrimeNumbers = (Integer[]) GetAllPrimeNumder(this.number);
int[] result = new int[arrayOfPrimeNumbers.length];
for (int currentNumber = 0; currentNumber<resault.length; currentNumber++){
result[currentNumber] = arrayOfPrimeNumbers[currentNumber].intValue();
}
return resault;
};

public Integer[] getIntegerArray(){
return this.GetAllPrimeNumder(this.number);
};
</source>
В getAllPrimeNumder формируется динамический массив primeNumbers — объект класса ArrayList (для его использования необходимо подключить пакет java.util.ArrayList). Добавление нового объекта в динамический массив производится методом add(Object). После того, как динамический массив сформирован, из него извлекается простой массив методом toArray(Object[]). Обратите внимание, что из ArrayList извлекается массив объектов типа Integer, несмотря на то, что в него помещаются переменные типа int. Для получения массива состоящего из переменных типа int используется метод getIntArray().

Динамические массивы, как правило, используют лишь до тех пор, пока не установлено точное количество элементов, так как скорость работы с простым массивом выше и обработка простого массива менее трудоемка.

Для логического завершения работы с простыми числами включим ранее описанные методы (primeNumberCheckUp, getAllPrimeNumder,
getIntArray(), getIntegerArray()) в представленный далее класс ArrayOfPrimeNumbers.
<source lang = "java">
import java.util.ArrayList;
public class ArrayOfPrimeNumbers {
private int number;

public ArrayOfPrimeNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
}
</source>
Класс, в зависимости от вызываемого метода, возвращает массив, состоящий из элементов int или Integer.

=== Куча хлама ===
Вернемся к нашей Несмеяне. Так как королевство ей досталось, прямо скажем, маленькое, пришлось ей еще и за порядком следить, что значит знать, где и что. Здесь ей помог HashMap — такая интересная структура для хранения данных, класс который входит в '''java.util.''' Экземпляры класса HashMap позволяют хранить различные именованные объекты, которые хранятся в виде пар «ключ — значение». Снаружи объекта типа HashMap нельзя узнать (как в хорошем бардаке), что же там лежит, однако, зная ключ, можно получить то, что ищешь, ну а если ключ неизвестен, то необходимо начать разбирать бардак до тех пор, пока не будет найдено то, что требуется. HashMap часто используется для хранения параметров системы. Как царевна разбирала бардак
мужа с помощью HashMap, можно посмотреть ниже.
<source lang = "java">
HashMap sameHeap = new HashMap();
sameHeap.put("Key1", "Левый носок");
sameHeap.put("Key2", "Грязная футболка");
sameHeap.put("Key3", "Правый носок");
String sameObj = (String) sameHeap.get("Key1");
System.out.println("Key1 = " + sameObj);
Map.Entry entry = null;
Iterator it = sameHeap.entrySet().iterator();
while (it.hasNext()) {
entry = (Map.Entry) it.next();
System.out.println("For key = " + entry.getKey() + " value = " + entry.getValue());
}
</source>
Для компиляции понадобится подключить java.util.HashMap, java.util.Iterator, java.util.Map — это можно сделать с помощью всего одной строкой вместо трех — import java.util.*;.

Как вы можете убедиться, для помещения объекта в HashMap необходимо использовать метод put, где первым параметром будет ключ, а
вторым — ассоциируемый с ним объект. Извлечение объекта возможно с помощью метода get при передаче ключа или с помощью последовательного перебора записей в HashMap.

После выполнения кода вы можете увидеть, что элементы в куче лежат не в том порядке, в котором вы их туда кинули (как в жизни, и не только короля). Порядок элементов в коллекции также может меняться во времени. HashMap обеспечивает постоянное время доступа для операций put и get. Как для ключей, так и для элементов допускаются значения типа null.

=== Пятый угол ===
В хорошо написанной программе, как и в сказочном королевстве, все должно идти своим чередом, но непредвиденные ситуации все равно бывают, так как программа соприкасается с внешним миром (другими программами, файлами, пользователями). Для решения непредвиденных ситуаций в Java существуют исключения и специальные операторы позволяющие отловить и обработать их.
<source lang = "java">
try{
// небезопасный код
} catch(Exception e) {
// обработка исключительной ситуации
} finally {
// гарантированно выполняющийся блок
}
</source>
Выше представлена структура, с помощью которой производится обработка исключительных ситуаций: в блоке try производятся
потенциально опасные операции, а в блоке catch производится обработка возникшего исключения (блоков catch может быть несколько). Под блоком подразумевается последовательность операторов, объявлений локальных классов или локальных переменных, заключенных в фигурные скобки. Область видимости локальных переменных и классов ограничена блоком, в котором они определены.

Иногда дополнительно, вне зависимости от того, как будет выполнен блок try, необходимо, чтобы выполнились какие-либо действия
(например, освобождение ресурсов), тогда используют оператор finally, который обеспечивает гарантированное выполнение указанного блока операторов.

Исключительная ситуация может быть сгенерирована виртуальной машиной Java, а также программистом. Исключение «выбрасывается»
с помощью оператора throw.
<source lang = "java">
public float calculate(int sameA, int sameB) throws Exception {
float result;
if (sameB != 0) {
result = sameA / sameB;
} else
throw new Exception("Параметр для вычисления не должен быть равным нулю");
return result;
}
</source>
Предложенный метод обеспечивает деление, а так как Царевна и король никогда не делят на ноль, они все делят поровну, то с помощью оператора throw порождается исключение в случае неправильно введенных данных. Это исключение можно «отловить» с помощью catch по месту использования метода.

Жизнь царевны и короля изменилась: пришлось осваивать азы науки и знакомиться с простыми типами (чисел), разбираться в ветвлениях налогового кодекса, использовать все три типа циклов, а также усвоить исключения. Оставим их осмыслять все это до [[LXF86:Java|следующего номера…]]

LXF84:Java

2008-03-19T06:53:06Z

Maximax:

{{Цикл/Java}}
=== Сказка Java ===
''ЧАСТЬ 1: От кофеварок до промышленных серверов и биллинговых систем - Java можно встретить буквально везде. Начните изучение этой технологии вместе с '''Антоном Черноусовым'''.''

Начиная ряд статей о программировании на объектно-ориентированном языке Java, хотел бы выразить свое мнение относительно корпоративного рынка разработки программного обеспечения, на котором в данный момент борются за лидерство два гиганта, две платформы: J2EE и .NET.

В основе платформы J2EE лежит язык программирования Java – приложения, созданные с его помощью, являются кроссплатформенными, сам язык, средства разработки и технология активно поддерживаются многими корпорациями: Sun, Google, IBM, Oracle, BEA. Платформа пользуется большой популярностью и среди компаний, ориентированных на OpenSource, таких как Apache Foundation. В противовес J2EE, корпорация Microsoft предлагает свою технологию .NET, которая является колоссом, построенным на мощи программного обеспечения Microsoft.

Сегодня еще нельзя сказать, какая технология станет доминирующей, и, возможно, от вас зависит скорость распространения современной кроссплатформенной технологии создания приложений J2EE и языка программирования Java.

Предложенные вашему вниманию уроки позволят овладеть основными понятиями Java и создавать различные приложения с его помощью. Рассмотрев основы языка, мы сможем изучить типовые решения (паттерны) в программировании и приступить к изучению J2EE.
В первом уроке мы создадим свое первое приложение и разберемся с основными понятиями: инкапсуляция, наследование и полиморфизм. Для выполнения этого урока нам понадобится пакет Java SDK 1.5, текстовый редактор и немного терпения.
=== Героический объект ===
Приступая к этой серии материалов, я вспомнил, что, как правило, изучение языков программирования начинается с написания приложения "Hello World!", но такой прием настолько изъезжен, что я намереваюсь предложить пример поинтереснее: мы напишем приложение, рассказывающее сказку. Основа приложения – два класса. Каждый класс содержит члены двух видов: атрибуты и методы. Атрибуты – это данные, принадлежащие самому классу. Совокупное значение атрибутов определяет состояние объекта или класса. Метод – это последовательность операторов, изменяющих значения атрибутов и, как следствие, состояние класса или объекта.

В каждой интересной сказке должен быть свой герой. Предлагаю взглянуть на класс, который реализует нашего героя. Итак, по порядку. Следующий код необходимо сохранить в файл '''FirstHero.java.'''
<source lang = "java">
public class FirstHero {
private String quest;
public FirstHero(String Quest) {
this.quest = Quest;
}
public void setQuest(String Quest){
this.quest = Quest;
};
public String getQuest(){
return quest;
};
}
</source>
Расположение одного класса в одном файле считается хорошим тоном среди программистов на Java – так что приучайтесь к нему сразу. Имя файла должно совпадать с названием класса, расширение у файла – '''.java.'''

Первый созданный нами класс содержит один защищенный атрибут (private – модификатор, зарезервированное слово, которое обеспечивает возможность обращения к члену класса только внутри класса) и три открытых метода (public – модификатор, зарезервированное слово, которое обеспечивает возможность обращения к члену класса из любого другого класса.). Хорошо спроектированный класс не имеет открытых атрибутов, что позволяет быть уверенным в правильной работе с ними. Доступ к защищенным атрибутам осуществляется через открытые методы. Такая организация класса позволяет разработчику через методы реализовать различные проверки и исключить неправильное поведение объекта. Класс представляет собой объединение атрибутов и методов в единое целое – подобное объединение называется инкапсуляцией.

Вы можете заметить, что первый метод (третья строка представленного ранее листинга) имеет то же название, что и класс – FirstHero. Такой метод называется конструктором. Конструктор – это метод, который используется при создании экземпляра класса для задания внутреннего состояния объекта, например:
<source lang = "java">
FirstHero ourNewHero = new FirstHero("Спасти царевну");
</source>
Единственный атрибут нашего класса quest имеет тип строка (String). Для установки значения атрибута quest используется метод
setQuest. Метод setQuest является public и не возвращает никакого значения. Для обозначения методов, не возвращающих значение, используется зарезервированное слово void. Для вызова метода setQuest необходим обязательный параметр: Quest типа String. Для получения значения атрибута quest используется метод getQuest, который вызывается без параметров, является открытым и возвращает значение типа String.

Вызов описанных выше методов для объекта ourNewHero осуществляется следующим образом:
<source lang = "java">
ourNewHero.getQuest();
ourNewHero.setQuest("какая-то строка");
</source>
Парные методы, различающиеся приставками set и get, принято создавать для работы с закрытыми атрибутами. Это обязательное
условие для реализации объекта в виде JavaBean. Что такое JavaBean, мы обсудим позже – сейчас запомните, что такое наименование методов позволяет избавиться от ряда проблем в больших системах.

Приступим к написанию самой сказки. Возьмите следующий код и поместите его в файл '''Story.java'''.

<source lang = "java">
public class Story {
public static void main(String[] args) {
FirstHero ourNewHero = new FirstHero("Спасти царевну ");
System.out.println(“Наш герой хочет отправиться в путь и “ + ourNewHero.getQuest());
}
}
</source>

Это класс Story, он имеет всего один метод main, который является статичным (static-методы и переменные принято называть переменными класса и методами класса, т.к. они общие для всех объектов) и используется для работы с классом в целом. Метод main – это стартовая точка для запуска программы, с которой начинается интерпретация кода.

В ходе интерпретации метода main создается новый объект ourNewHero, а также вызывается метод println объекта out, который обеспечивает вывод в стандартный выходной поток строковойпеременной.

Откомпилируем код и увидим, что у нас получилось. Для компиляции переместитесь в каталог, где вы разместили свои файлы и выполните следующую команду:
<source lang = "java">
# javac *.java
</source>
При желании вы можете откомпилировать классы по отдельности, следующим образом:
<source lang = "java">
# javac Story.java
# javac FirstHero.java
</source>
В итоге вы получите два файла '''Story.class''' и '''FirstHero.class'''. Теперь посмотрим на результат:
<source lang = "java">
# java Story
Наш герой хочет отправиться в квест и Спасти царевну
</source>

Первая программа на Java готова и работает! Вы создали два класса и научились выводить информацию в консоль. Но мы забыли о
комментариях...

Комментарии бывают нескольких типов:
*Строчные начинаются с символа // и длятся до окончания строки.
*Многострочные комментарии заключаются между /* и */.
*Комментарии JavaDoc – это многострочные комментарии, заключенные между /** и */, например:

<source lang = "java">
/**
* Класс является прототипом объекта "герой"
* @author Chernousov Anton
* @version 0.1
*/
public class FirstHero {
…
/**
* Метод предназначен для установки внутренней переменной
quest
* в значение Quest.
* У этого метода один параметр
* @param Quest это переменная означает задание для Героя
*/
public void setQuest(String Quest)
…
</source>

Комментарии JavaDoc предназначены для формирования документации к проекту из исходных кодов. Если добавить в файл '''FirstHero.java''' только что приведенные строки, то с помощью команды '''javadoc -author -version *.java''' можно сформировать документацию к нашему проекту.

JavaDoc позволяет создавать подробную документацию, которая просто необходима для любого достаточно крупного проекта.
=== Наследование, интерфейсы и их реализация ===
Наша сказка написана, но что делать, если проект большой и над ним работает много людей? Как реализовать одновременное программирование разных классов так, чтобы результаты, полученные отдельными разработчиками, можно было без труда соединить в единое целое? Для решения этой задачи, а также задачи множественного наследования в Java существуют интерфейсы – interface. Но обо всем по порядку.

Наследование – это одна из парадигм программирования, которая связана с инкапсуляцией. Суть наследования заключается в следующем: если есть класс, инкапсулирующий в себе некоторые атрибуты и методы, то класс, наследующий его, автоматически наследует все его атрибуты и методы.
<source lang = "java">
public class SecondHero extends FirstHero{
public SecondHero(String Quest) {
super(Quest + " Несмеяну");
}
}
</source>
Расположенный выше код объявляет класс SecondHero, который с помощью зарезервированного слова extends наследует (расширяет) класс FirstHero. В Java класс может наследовать (расширять)только один класс. При наследовании класса FirstHero, содержащего
конструктор, обязательно требуется переопределить его (например, как это делается в методе SecondHero). При выполнении оператора super(Quest) будет вызван аналогичный метод из суперкласса (класс-родителя). Строкой super(Quest + “Несмеяну”) мы переопределяем поведение конструктора. Естественно, класс SecondHero может содержать новые атрибуты и методы.

Для проверки механизма наследования сохраните приведенный текст класса SecondHero в файл '''SecondHero.java''' и в файле '''Story.java''' измените имя класса FirstHero на SecondHero. Откомпилируйте и запустите программу, в результате вы должны увидеть следующее:
<source lang = "java">
# java Story
Наш герой хочет отправиться в путь и Спасти царевну Несмеяну
</source>
При разработке программы, перед тем, как приступить к программированию, сначала проводится процесс проектирования (например, через UML-нотации). В результате проектирования появляется документация к проекту, а также спецификации классов. Интерфейс – это явно указанная спецификация набора методов, которые должны быть представлены в классе, реализующий эту спецификацию. В серьезном проекте на момент начала программирования перед программистом оказываются интерфейсы, которые он должен реализовать в классах.

Интерфейс в Java – это специальный класс, в котором отсутствует реализация! Давайте напишем интерфейс для нашего класса FirstHero. Следует скопировать следующий далее код и поместить его в файл '''Hero.java''' – именно этот интерфейс мы будет использован далее. Как вы видите, в отличие от других классов, интерфейс объявляется с помощью зарезервированного слова interface. В нашем случае интерфейс представляет собой следующий набор методов:
<source lang = "java">
public interface Hero {
public void setQuest(String Quest);
public String getQuest();
}
</source>
Чтобы класс FirstHero реализовывал интерфейс Hero, необходимо изменить первую строчку в файле '''FirstHero.java''' на public class FirstHero implements Hero {. Интерфейс может наследовать (расширять) множество других интерфейсов. Наример:
<source lang = "java">
public interface Lord {
public String sendToQuest();
public void setBodyguard(Hero hisHero);
public Hero getBodyguard();
}

public interface King extends Hero, Lord{
public void setWife (String PrincesName);
public String getWife();
}
</source>
Класс может одновременно наследовать класс и реализовывать один или несколько интерфейсов. Например, как в классе LandLord,
который наследует класс FirstHero и реализует интерфейс Lord:
<source lang = "java">
public class LandLord extends FirstHero implements Lord{
private Hero bodyguard;
public LandLord(String Quest, Hero hisHero) {
super(Quest);
this.bodyguard = hisHero;
}
public String sendToQuest() {
bodyguard.setQuest(this.getQuest());
return null;
}
public void setBodyguard(Hero hisHero) {
this.bodyguard = hisHero;
}
public Hero getBodyguard() {
return bodyguard;
}
}
</source>
Чтобы окончательно закрыть тему наследования, необходимо поговорить про абстрактные классы – те, что занимают промежуточное
место между интерфейсами и реальными классами. Объявление абстрактного класса или метода выполняется с помощью специального
слова abstract:
<source lang = "java">
abstract public class Knight
</source>
Абстрактный класс представляет собой неполную реализацию всех объявленных методов, и его можно наследовать, как и любой из классов. Обязательным условием при наследовании является полная реализация абстрактных методов.

=== Полиморфизм ===
Полиморфизм – это концепция, реализованная в Java, которая позволяет одному и тому же объекту выступать в разных формах. Например, экземпляр класс LandLord можно использовать как объект класса FirstHero. Это стало возможным благодаря тому, что класс LandLord наследует класса FirstHero.

=== Перегруженные методы ===
Иногда при создании сложных (и не очень) систем есть необходимость реализовать два различных метода, названых одинаково – это возможно с помощью перегруженных (overloading) методов. Выбор реализации зависит от типа объектов, переданных в качестве параметров.
<source lang = "java">
public class GreatKing extends LandLord implements King{
private String wife;
private boolean theftedWife;

public GreatKing(String Quest, Hero hisHero) {
super(Quest, hisHero);
}

public void setWife(String PrincesName) {
this.wife = PrincesName;
this.theftedWife = false;
}

public String getWife() {
if (theftedWife){return null;}
else{ return wife;}
}

public String getWife(boolean flag) {
if (flag){ this.theftedWife = true;}
return wife;
}
}
</source>
В представленном классе GreatKing существуют две реализации перезагруженного метода getWife, которые можно вызвать следующим образом:
<source lang = "java">
GreatKing ourKing = new GreatKing("Править мудро", (Hero) new FirstHero("Охранять господина"));
String hisWife = ourKing.getWife();
String theftedHisWife = ourKing.getWife(true);
</source>

=== Вместо заключения ===
Ну вот, мы создали всех героев. Разместите интерфейсы Lord, King, а также классы LandLord и GreatKing в соответствующих файлах.
Немного измените класс Story, чтобы завершить сказку:
<source lang = "java">
public class Story {
public static void main(String[] args) {
// создадим наших героев
Hero ourNewHero = (Hero) new FirstHero("Спасити царевну");
GreatKing ourKing = new GreatKing("Править мудро", (Hero) new FirstHero("Охранять господина"));
LandLord ourNewLandLord = new LandLord("Похитить царевну", (Hero) new FirstHero("Охранять господина"));
// Женим нашего короля
ourKing.setWife("Несмеяна");
// И начнем повествование
System.out.println("Жил был мудрый король, и должен был он " + ourKing.getQuest());
System.out.println("Была у него жена, и звали ее " + ourKing.getWife());
System.out.println("Был в королевстве коварный Визирь и хотел он " + ourNewLandLord.getQuest());
System.out.println("И сделал это");
String wife = ourKing.getWife(true);
//
System.out.println("А наш герой жаждал " + ourNewHero.getQuest() + " ..и добился этого");
ourKing.setWife(wife);
System.out.println("Король был счастлив.");
System.out.println("Ну а что случилось дальше вы можете придумать сами...");
}
}
</source>
Откомпилируйте и насладитесь результатом выполнения урока.

В [[LXF85:Java|следующей статье]] мы поговорим о простых числах и других типах, вычислениях, циклах, массивах и списках.

LXF84:Java

2008-03-19T06:37:19Z

Maximax: Что за "ООЯ " ? Я непонял. Поэтому я её убрал.

{{Цикл/Java}}
=== Сказка Java ===
''ЧАСТЬ 1: От кофеварок до промышленных серверов и биллинговых систем - Java можно встретить буквально везде. Начните изучение этой технологии вместе с '''Антоном Черноусовым'''.''

Начиная ряд статей о программировании на объектно-ориентированном языке Java, хотел бы выразить свое мнение относительно корпоративного рынка разработки программного обеспечения, на котором в данный момент борются за лидерство два гиганта, две платформы: J2EE и .NET.

В основе платформы J2EE лежит язык программирования Java – приложения, созданные с его помощью, являются кроссплатформенными, сам язык, средства разработки и технология активно поддерживаются многими корпорациями: Sun, Google, IBM, Oracle, BEA. Платформа пользуется большой популярностью и среди компаний, ориентированных на OpenSource, таких как Apache Foundation. В противовес J2EE, корпорация Microsoft предлагает свою технологию .NET, которая является колоссом, построенным на мощи программного обеспечения Microsoft.

Сегодня еще нельзя сказать, какая технология станет доминирующей, и, возможно, от вас зависит скорость распространения современной кроссплатформенной технологии создания приложений J2EE и языка программирования Java.

Предложенные вашему вниманию уроки позволят овладеть основными понятиями Java и создавать различные приложения с его помощью. Рассмотрев основы языка, мы сможем изучить типовые решения (паттерны) в программировании и приступить к изучению J2EE.
В первом уроке мы создадим свое первое приложение и разберемся с основными понятиями: инкапсуляция, наследование и полиморфизм. Для выполнения этого урока нам понадобится пакет Java SDK 1.5, текстовый редактор и немного терпения.
=== Героический объект ===
Приступая к этой серии материалов, я вспомнил, что, как правило, изучение языков программирования начинается с написания приложения "Hello World!", но такой прием настолько изъезжен, что я намереваюсь предложить пример поинтереснее: мы напишем приложение, рассказывающее сказку. Основа приложения – два класса. Каждый класс содержит члены двух видов: атрибуты и методы. Атрибуты – это данные, принадлежащие самому классу. Совокупное значение атрибутов определяет состояние объекта или класса. Метод – это последовательность операторов, изменяющих значения атрибутов и, как следствие, состояние класса или объекта.

В каждой интересной сказке должен быть свой герой. Предлагаю взглянуть на класс, который реализует нашего героя. Итак, по порядку. Следующий код необходимо сохранить в файл '''FirstHero.java.'''
<source lang = "java">
public class FirstHero {
private String quest;
public FirstHero(String Quest) {
this.quest = Quest;
}
public void setQuest(String Quest){
this.quest = Quest;
};
public String getQuest(){
return quest;
};
}
</source>
Расположение одного класса в одном файле считается хорошим тоном среди программистов на Java – так что приучайтесь к нему сразу. Имя файла должно совпадать с названием класса, расширение у файла – '''.java.'''

Первый созданный нами класс содержит один защищенный атрибут (private – модификатор, зарезервированное слово, которое обеспечивает возможность обращения к члену класса только внутри класса) и три открытых метода (public – модификатор, зарезервированное слово, которое обеспечивает возможность обращения к члену класса из любого другого класса.). Хорошо спроектированный класс не имеет открытых атрибутов, что позволяет быть уверенным в правильной работе с ними. Доступ к защищенным атрибутам осуществляется через открытые методы. Такая организация класса позволяет разработчику через методы реализовать различные проверки и исключить неправильное поведение объекта. Класс представляет собой объединение атрибутов и методов в единое целое – подобное объединение называется инкапсуляцией.

Вы можете заметить, что первый метод (третья строка представленного ранее листинга) имеет то же название, что и класс – FirstHero. Такой метод называется конструктором. Конструктор – это метод, который используется при создании экземпляра класса для задания внутреннего состояния объекта, например:
<source lang = "java">
FirstHero ourNewHero = new FirstHero("Спасти царевну");
</source>
Единственный атрибут нашего класса quest имеет тип строка (String). Для установки значения атрибута quest используется метод
setQuest. Метод setQuest является public и не возвращает никакого значения. Для обозначения методов, не возвращающих значение, используется зарезервированное слово void. Для вызова метода setQuest необходим обязательный параметр: Quest типа String. Для получения значения атрибута quest используется метод getQuest, который вызывается без параметров, является открытым и возвращает значение типа String.

Вызов описанных выше методов для объекта ourNewHero осуществляется следующим образом:
<source lang = "java">
ourNewHero.getQuest();
ourNewHero.setQuest("какая-то строка");
</source>
Парные методы, различающиеся приставками set и get, принято создавать для работы с закрытыми атрибутами. Это обязательное
условие для реализации объекта в виде JavaBean. Что такое JavaBean, мы обсудим позже – сейчас запомните, что такое наименование методов позволяет избавиться от ряда проблем в больших системах.

Приступим к написанию самой сказки. Возьмите следующий код и поместите его в файл '''Story.java'''.

<source lang = "java">
public class Story {
public static void main(String[] args) {
FirstHero ourNewHero = new FirstHero("Спасти царевну ");
System.out.println(“Наш герой хочет отправиться в путь и “ + ourNewHero.getQuest());
}
}
</source>

Это класс Story, он имеет всего один метод main, который является статичным (static-методы и переменные принято называть переменными класса и методами класса, т.к. они общие для всех объектов) и используется для работы с классом в целом. Метод main – это стартовая точка для запуска программы, с которой начинается интерпретация кода.

В ходе интерпретации метода main создается новый объект ourNewHero, а также вызывается метод println объекта out, который обеспечивает вывод в стандартный выходной поток строковойпеременной.

Откомпилируем код и увидим, что у нас получилось. Для компиляции переместитесь в каталог, где вы разместили свои файлы и выполните следующую команду:
<source lang = "java">
# javac *.java
</source>
При желании вы можете откомпилировать классы по отдельности, следующим образом:
<source lang = "java">
# javac Story.java
# javac FirstHero.java
</source>
В итоге вы получите два файла '''Story.class''' и '''FirstHero.class'''. Теперь посмотрим на результат:
<source lang = "java">
# java Story
Наш герой хочет отправиться в квест и Спасти царевну
</source>

Первая программа на Java готова и работает! Вы создали два класса и научились выводить информацию в консоль. Но мы забыли о
комментариях...

Комментарии бывают нескольких типов:
*Строчные начинаются с символа // и длятся до окончания строки.
*Многострочные комментарии заключаются между /* и */.
*Комментарии JavaDoc – это многострочные комментарии, заключенные между /** и */, например:

<source lang = "java">
/**
* Класс является прототипом объекта "герой"
* @author Chernousov Anton
* @version 0.1
*/
public class FirstHero {
…
/**
* Метод предназначен для установки внутренней переменной
quest
* в значение Quest.
* У этого метода один параметр
* @param Quest это переменная означает задание для Героя
*/
public void setQuest(String Quest)
…
</source>

Комментарии JavaDoc предназначены для формирования документации к проекту из исходных кодов. Если добавить в файл '''FirstHero.java''' только что приведенные строки, то с помощью команды '''javadoc -author -version *.java''' можно сформировать документацию к нашему проекту.

JavaDoc позволяет создавать подробную документацию, которая просто необходима для любого достаточно крупного проекта.
=== Наследование, интерфейсы и их реализация ===
Наша сказка написана, но что делать, если проект большой и над ним работает много людей? Как реализовать одновременное программирование разных классов так, чтобы результаты, полученные отдельными разработчиками, можно было без труда соединить в единое целое? Для решения этой задачи, а также задачи множественного наследования в Java существуют интерфейсы – interface. Но обо всем по порядку.

Наследование – это одна из парадигм программирования, которая связана с инкапсуляцией. Суть наследования заключается в следующем: если есть класс, инкапсулирующий в себе некоторые атрибуты и методы, то класс, наследующий его, автоматически наследует все его атрибуты и методы.
<source lang = "java">
public class SecondHero extends FirstHero{
public SecondHero(String Quest) {
super(Quest + " Несмеяну");
}
}
</source>
Расположенный выше код объявляет класс SecondHero, который с помощью зарезервированного слова extends наследует (расширяет) класс FirstHero. В Java класс может наследовать (расширять)только один класс. При наследовании класса FirstHero, содержащего
конструктор, обязательно требуется переопределить его (например, как это делается в методе SecondHero). При выполнении оператора super(Quest) будет вызван аналогичный метод из суперкласса (класс-родителя). Строкой super(Quest + “Несмеяну”) мы переопределяем поведение конструктора. Естественно, класс SecondHero может содержать новые атрибуты и методы.

Для проверки механизма наследования сохраните приведенный текст класса SecondHero в файл '''SecondHero.java''' и в файле '''Story.java''' измените имя класса FirstHero на SecondHero. Откомпилируйте и запустите программу, в результате вы должны увидеть следующее:
<source lang = "java">
# java Story
Наш герой хочет отправиться в путь и Спасти царевну Несмеяну
</source>
При разработке программы, перед тем, как приступить к программированию, сначала проводится процесс проектирования (например, через UML-нотации). В результате проектирования появляется документация к проекту, а также спецификации классов. Интерфейс – это явно указанная спецификация набора методов, которые должны быть представлены в классе, реализующий эту спецификацию. В серьезном проекте на момент начала программирования перед программистом оказываются интерфейсы, которые он должен реализовать в классах.

Интерфейс в Java – это специальный класс, в котором отсутствует реализация! Давайте напишем интерфейс для нашего класса FirstHero. Следует скопировать следующий далее код и поместить его в файл '''Hero.java''' – именно этот интерфейс мы будет использован далее. Как вы видите, в отличие от других классов, интерфейс объявляется с помощью зарезервированного слова interface. В нашем случае интерфейс представляет собой следующий набор методов:
<source lang = "java">
public interface Hero {
public void setQuest(String Quest);
public String getQuest();
}
</source>
Чтобы класс FirstHero реализовывал интерфейс Hero, необходимо изменить первую строчку в файле '''FirstHero.java''' на public class FirstHero implements Hero {. Интерфейс может наследовать (расширять) множество других интерфейсов. Наример:
<source lang = "java">
public interface Lord {
public String sendToQuest();
public void setBodyguard(Hero hisHero);
public Hero getBodyguard();
}

public interface King extends Hero, Lord{
public void setWife (String PrincesName);
public String getWife();
}
</source>
Класс может одновременно наследовать класс и реализовывать один или несколько интерфейсов. Например, как в классе LandLord,
который наследует класс FirstHero и реализует интерфейс Lord:
<source lang = "java">
public class LandLord extends FirstHero implements Lord{
private Hero bodyguard;
public LandLord(String Quest, Hero hisHero) {
super(Quest);
this.bodyguard = hisHero;
}
public String sendToQuest() {
bodyguard.setQuest(this.getQuest());
return null;
}
public void setBodyguard(Hero hisHero) {
this.bodyguard = hisHero;
}
public Hero getBodyguard() {
return bodyguard;
}
}
</source>
Чтобы окончательно закрыть тему наследования, необходимо поговорить про абстрактные классы – те, что занимают промежуточное
место между интерфейсами и реальными классами. Объявление абстрактного класса или метода выполняется с помощью специального
слова abstract:
<source lang = "java">
abstract public class Knight
</source>
Абстрактный класс представляет собой неполную реализацию всех объявленных методов, и его можно наследовать, как и любой из классов. Обязательным условием при наследовании является полная реализация абстрактных методов.

=== Полиморфизм ===
Полиморфизм – это концепция, реализованная в Java, которая позволяет одному и тому же объекту выступать в разных формах. Например, экземпляр класс LandLord можно использовать как объект класса FirstHero. Это стало возможным благодаря тому, что класс LandLord наследует класса FirstHero.

=== Перегруженные методы ===
Иногда при создании сложных (и не очень) систем есть необходимость реализовать два различных метода, названых одинаково – это возможно с помощью перегруженных (overloading) методов. Выбор реализации зависит от типа объектов, переданных в качестве параметров.
<source lang = "java">
public class GreatKing extends LandLord implements King{
private String wife;
private boolean theftedWife;

public GreatKing(String Quest, Hero hisHero) {
super(Quest, hisHero);
}

public void setWife(String PrincesName) {
this.wife = PrincesName;
this.theftedWife = false;
}

public String getWife() {
if (theftedWife){return null;}
else{ return wife;}
}

public String getWife(boolean flag) {
if (flag){ this.theftedWife = true;}
return wife;
}
}
</source>
В представленном классе GreatKing существуют две реализации перезагруженного метода getWife, которые можно вызвать следующим образом:
<source lang = "java">
GreatKing ourKing = new GreatKing("Править мудро", (Hero) new FirstHero("Охранять господина"));
String hisWife = ourKing.getWife();
String theftedHisWife = ourKing.getWife(true);
</source>

=== Вместо заключения ===
Ну вот, мы создали всех героев. Разместите интерфейсы Lord, King, а также классы LandLord и GreatKing в соответствующих файлах.
Немного измените класс Story, чтобы завершить сказку:
<source lang = "java">
public class Story {
public static void main(String[] args) {
// создадим наших героев
Hero ourNewHero = (Hero) new FirstHero("Спасити царевну");
GreatKing ourKing = new GreatKing("Править мудро", (Hero) new FirstHero("Охранять господина"));
LandLord ourNewLandLord = new LandLord("Похитить царевну", (Hero) new FirstHero("Охранять господина"));
// Женим нашего короля
ourKing.setWife("Несмеяна");
// И начнем повествование
System.out.println("Жил был мудрый король, и должен был он " + ourKing.getQuest());
System.out.println("Была у него жена, и звали ее " + ourKing.getWife());
System.out.println("Был в королевстве коварный Визирь и хотел он " + ourNewLandLord.getQuest());
System.out.println("И сделал это");
String wife = ourKing.getWife(true);
//
System.out.println("А наш герой жаждал " + ourNewHero.getQuest() + " ..и добился этого");
ourKing.setWife(wife);
System.out.println("Король был счастлив.");
System.out.println("Ну а что случилось дальше вы можете придумать сами...");
}
}
</source>
Откомпилируйте и насладитесь результатом выполнения урока.

В следующей статье мы поговорим о простых числах и других типах, вычислениях, циклах, массивах и списках.