Курсы и курсы по программированию на java

Сибирский Государственный Университет Телекоммуникаций и Информатики

Межрегиональный центр переподготовки специалистов

Описание архитектуры приложения

На рисунке 1 представлена схема работы, которая показывает, как работает наша программа на стороне сервера и клиента.

Курсы и курсы по программированию на java

Для гибкости разработки программы будем взаимодействовать с объектно-ориентированным программированием. На рисунке 2 представлена UML диаграмма классов на стороне сервера.

Курсы и курсы по программированию на java

На рисунке 3 представлена UML диаграмма классов на стороне клиента.

Курсы и курсы по программированию на java

Вступление

Для того, чтобы иметь возможность передавать файлы между клиентом и сервером, существует протокол TCP/IP.

TCP – протокол управления передачей. Он служит для обеспечения и установление надежного соединения между двумя устройствами и надежную передачу данных. При этом протокол TCP контролирует оптимальный размер передаваемого пакета данных, осуществляя новую посылку при сбое передачи.

IP – интернет протокол или адресный протокол – основа всей архитектуры передачи данных. Протокол IP служит для доставки сетевого пакета данных по нужному адресу. При этом информация разбивается на пакеты, которые независимо передвигаются по сети до нужного адресата.

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

Где можно приобрести курсовую по программированию на языке Java?

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

Преимущества нашей компании:

Всего работ 25

Название

Стоимость

Решение системы линейных уравнений методом Гаусса на JAVA

130,00

Игра Судоку Java

700,00

Система учета и регистрации поступления цветов в цветочный магазин JAVA

1 500,00

Метод штрафных функция для поиска условного экстремума + линии уровня + маршрут построения функции

150,00

Исходник java — работа с матрицами и массивами

900,00

Наследование в Java

900,00

Информационная система «Поликлиника» Java

2 599,00

Работа с интерфейсами в Java. Абстрактные классы.

900,00

Защита от SQL-инъекций.

4 000,00

Информационная система Автосервис Java

2 599,00

Java — коллекции, поиск в коллекциях

900,00

Многопоточный чат на Java (Клиент Сервер для обмена сообщениями)
new

2 000,00

Составление расписания с помощью генетического алгоритма Java (ВКР)
new

10 000,00

Мобильное приложение для изучения Английского языка Java

10 000,00

Веб-приложение для удаленной сдачи лабораторных и практических работ Java

8 500,00

Игра пятнашки на Java Fx

2 500,00

Приложение Android для чтения pdf файлов Java

7 000,00

Android приложение «Заметки»

2 500,00

Разработка мобильного приложения для отслеживания активности пользователя

10 000,00

Многопоточное клиент-серверное приложение для обмена файлами Java

2 700,00

Автоматизации учета поставок и оказания услуг сервисного предприятия

7 000,00

База данных «Диспетчерская служба аэропорта» Java+MySQL

3 500,00

Приложение для шифрования данных на ОС Android

1 299,00

Программирование для мобильных приложений на Java

100,00

Учет кадров на предприятии Java Eclipse + SQLite

399,00

Программирование на Java (теория)

1. Динамическая инициализация объектов

2. Чтение и запись файлов

Объекты в Java создаются с помощью зарезервированного слова new, после которого идет конструктор – специальная подпрограмма, занимающаяся созданием объекта и инициализацией полей создаваемого объекта. Для него не указывается тип возвращаемого значения, и он не является ни методом объекта (вызывается через имя класса когда объекта еще нет), ни методом класса (в конструкторе доступен объект и его поля через ссылку this). На самом деле конструктор в сочетании с оператором new возвращает ссылку на создаваемый объект и может считаться особым видом методов, соединяющим в себе черты методов класса и методов объекта.

Если в объекте при создании не нужна никакая дополнительная инициализация, можно использовать конструктор, который по умолчанию присутствует для каждого класса. Это имя класса, после которого ставятся пустые круглые скобки – без списка параметров. Такой конструктор при разработке класса задавать не надо, он присутствует автоматически. Если требуется инициализация, обычно применяют конструкторы со списком параметров.

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

1. Создается объект, в котором все поля данных имеют значения по умолчанию (нули на двоичном уровне представления).

2. Вызывается конструктор дочернего класса.

3. Конструктор дочернего класса вызывает конструктор родителя (непосредственного прародителя), а также по цепочке все прародительские конструкторы и инициализации полей, заданных в этих классах, вплоть до класса Object.

4. Проводится инициализация полей родительской части объекта значениями, заданными в декларации родительского класса.

5. Выполняется тело конструктора родительского класса.

6. Проводится инициализация полей дочерней части объекта значениями, заданными в декларации дочернего класса.

7. Выполняется тело конструктора дочернего класса.

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

Как правило, для инициализации полей сложно устроенных объектов используют конструкторы. Но кроме них в Java, в отличие от большинства других языков программирования, для этих целей могут также служить блоки инициализации класса и блоки инициализации объекта. Синтаксис задания классов с блоками инициализации следующий:

тело блока инициализации класса

тело блока инициализации объекта

Задание подпрограмм — методов класса, методов объекта, конструкторов

Блоков инициализации класса и блоков инициализации объекта может быть несколько.

Порядок выполнения операторов при наличии блоков инициализации главного класса приложения (содержащего метод main):

1. инициализация полей данных и выполнение блоков инициализации класса (в порядке записи в декларации класса);

2. метод main;

3. выполнение блоков инициализации объекта;

4. выполнение тела конструктора класса.

Для других классов порядок аналогичен, но без вызова метода main:

2. выполнение блоков инициализации объекта;

3. выполнение тела конструктора класса.

Чем лучше пользоваться, блоками инициализации или конструкторами? Ответ, конечно, неоднозначен: в одних ситуациях – конструкторами, в других – блоками инициализации. Для придания начальных значений переменным класса в случаях, когда для этого требуются сложные алгоритмы, можно пользоваться только статическими блоками инициализации. Для инициализации полей объектов в общем случае лучше пользоваться конструкторами, но если необходимо выполнить какой-либо код инициализации до вызова унаследованного конструктора, можно воспользоваться блоком динамической инициализации.

Приведем несколько примеров. Программа SmallSquares (маленькие квадраты) возвращает квадрат маленького целого числа. SmallSquares имеет две статические переменные и единственную открытую статическую функцию getSquare().

private static final int LIMIT = 10;

System.out.println(«3 squared is » +

Откомпилировав и запустив SmallSquares, получим следующий результат:

3 squared is 9 (3 в квадрате будет 9)

В данном коде объект создается при помощи конструктора так называемым статическим методом.

Читайте также:  Севводоканал — личный кабинет

Приведем пример статической инициализации. За словом статический (static) следует блок кода, окруженного фигурными скобками. Можно использовать статический блок для инициализации массива квадратов следующим образом:

Статический блок запрашивается только один раз во время создания класса. Теперь не нужен конструктор, и можно вызывать статическую функцию getSquare() без предшествующего создания класса. Улучшенныйкодвыглядитследующимобразом:

// Нет обработки ошибки, предположим,0<=i<limit

System.out.println(«3 squared is » + getSquare(3));

// no error handling — assume 0<=i<limit

Откомпилируем и запустим ConstructorExample. В итоге получим следующий результат:

Hello Anonymous (привет Безымянный)

Hello Ed (Привет Эд)

5 squared is 25 (5 в квадрате будет 25)

Данный блок инициализаторов выглядит как блок статического инициализатора без статического ключевого слова. Он запускается перед тем, как вызвать конструктор.

Можно разделить конструкторы в примере (ConstructorExample), передвинув следующие строки от конструктора без аргумента:

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

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

инициализация java файл программа

Подавляющее большинство программ обменивается данными с внешним миром. Это, безусловно, делают любые сетевые приложения – они передают и получают информацию от других компьютеров и специальных устройств, подключенных к сети. Оказывается, можно точно таким же образом представлять обмен данными между устройствами внутри одной машины. Так, например, программа может считывать данные с клавиатуры и записывать их в файл, или же наоборот — считывать данные из файла и выводить их на экран. Таким образом, устройства, откуда может производиться считывание информации, могут быть самыми разнообразными – файл, клавиатура, входящее сетевое соединение и т.д. То же касается и устройств вывода – это может быть файл, экран монитора, принтер, исходящее сетевое соединение и т.п. В конечном счете, все данные в компьютерной системе в процессе обработки передаются от устройств ввода к устройствам вывода.

Обычно часть вычислительной платформы, которая отвечает за обмен данными, так и называется – система ввода/вывода. В Java она представлена пакетом java.io (input/output). Реализация системы ввода/вывода осложняется не только широким спектром источников и получателей данных, но еще и различными форматами передачи информации. Ею можно обмениваться в двоичном представлении, символьном или текстовом, с применением некоторой кодировки (только для русского языка их насчитывается более 4 штук), или передавать числа в различных представлениях. Доступ к данным может потребоваться как последовательный (например, считывание HTML-страницы), так и произвольный (сложная работа с несколькими частями одного файла). Зачастую для повышения производительности применяется буферизация.

В Java для описания работы по вводу/выводу используется специальное понятие поток данных (stream). Поток данных связан с некоторым источником, или приемником, данных, способным получать или предоставлять информацию. Соответственно, потоки делятся на входящие – читающие данные и выходящие – передающие (записывающие) данные. Введение концепции stream позволяет отделить основную логику программы, обменивающейся информацией с любыми устройствами одинаковым образом, от низкоуровневых операций с такими устройствами ввода/вывода.

В Java потоки естественным образом представляются объектами. Описывающие их классы как раз и составляют основную часть пакета java.io. Они довольно разнообразны и отвечают за различную функциональность. Все классы разделены на две части – одни осуществляют ввод данных, другие – вывод.

Существующие стандартные классы помогают решить большинство типичных задач. Минимальной «порцией» информации является, как известно, бит, принимающий значение 0 или 1 (это понятие также удобно применять на самом низком уровне, где данные передаются электрическим сигналом; условно говоря, 1 представляется прохождением импульса, 0 – его отсутствием). Традиционно используется более крупная единица измерения – байт, объединяющая 8 бит. Таким образом, значение, представленное одним байтом, находится в диапазоне от 0 до 28-1=255, или, если использовать знак, – от -128 до +127. Примитивный тип byte в Java в точности соответствует последнему – знаковому диапазону.

Базовые, наиболее универсальные, классы позволяют считывать и записывать информацию именно в виде набора байт. Чтобы их было удобно применять в различных задачах, java.io содержит также классы, преобразующие любые данные в набор байт.

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

На рисунке 1 представлены иерархии классов ввода/вывода. Как и говорилось, все типы поделены на две группы. Представляющие входные потоки классы наследуются от InputStream, а выходные – от OutputStream.

Рис. 1. Иерархия классов ввода/вывода.

Классы InputStream и OutputStream

InputStream – это базовый класс для потоков ввода, т.е. чтения. Соответственно, он описывает базовые методы для работы с байтовыми потоками данных. Эти методы необходимы всем классам, которые наследуются от InputStream.

Простейшая операция представлена методом read() (без аргументов). Он является абстрактным и, соответственно, должен быть определен в классах-наследниках. Этот метод предназначен для считывания ровно одного байта из потока, однако возвращает при этом значение типа int. В том случае, если считывание произошло успешно, возвращаемое значение лежит в диапазоне от 0 до 255 и представляет собой полученный байт (значение int содержит 4 байта и получается простым дополнением нулями в двоичном представлении). Обратите внимание, что полученный таким образом байт не обладает знаком и не находится в диапазоне от -128 до +127, как примитивный тип byte в Java. Если достигнут конец потока, то есть в нем больше нет информации для чтения, то возвращаемое значение равно -1.

Если же считать из потока данные не удается из-за каких-то ошибок, или сбоев, будет брошено исключение java.io.IOException. Этот класс наследуется от Exception, т.е. его всегда необходимо обрабатывать явно. Дело в том, что каналы передачи информации, будь то Internet или, например, жесткий диск, могут давать сбои независимо от того, насколько хорошо написана программа. А это означает, что нужно быть готовым к ним, чтобы пользователь не потерял нужные данные.

Метод read() – это абстрактный метод, но именно с соблюдением всех указанных условий он должен быть реализован в классах-наследниках.

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

Чтобы узнать, сколько байт в потоке готово к считыванию, применяется метод available(). Этот метод возвращает значение типа int, которое показывает, сколько байт в потоке готово к считыванию. При этом не стоит путать количество байт, готовых к считыванию, с тем количеством байт, которые вообще можно будет считать из этого потока. Метод available() возвращает число – количество байт, именно на данный момент готовых к считыванию.

Читайте также:  ЛитРес: Самиздат (selfpub.​ru) - вход в личный кабинет, официальный сайт

Когда работа с входным потоком данных окончена, его следует закрыть. Для этого вызывается метод close(). Этим вызовом будут освобождены все системные ресурсы, связанные с потоком.

Точно так же, как InputStream – это базовый класс для потоков ввода, класс OutputStream – это базовый класс для потоков вывода.

Метод write(int) является абстрактным и должен быть реализован в классах-наследниках. Этот метод принимает в качестве параметра int, но реально записывает в поток только byte – младшие 8 бит в двоичном представлении. Остальные 24 бита будут проигнорированы. В случае возникновения ошибки этот метод бросает java.io.IOException, как, впрочем, и большинство методов, связанных с вводом-выводом.

Реализация потока может быть такой, что данные записываются не сразу, а хранятся некоторое время в памяти. Например, мы хотим записать в файл какие-то данные, которые получаем порциями по 10 байт, и так 200 раз подряд. В таком случае вместо 200 обращений к файлу удобней будет скопить все эти данные в памяти, а потом одним заходом записать все 2000 байт. То есть класс выходного потока может использовать некоторый внутренний механизм для буферизации (временного хранения перед отправкой) данных. Чтобы убедиться, что данные записаны в поток, а не хранятся в буфере, вызывается метод flush(), определенный в OutputStream. В этом классе его реализация пустая, но если какой-либо из наследников использует буферизацию данных, то этот метод должен быть в нем переопределен.

Когда работа с потоком закончена, его следует закрыть. Для этого вызывается метод close(). Этот метод сначала освобождает буфер (вызовом метода flush), после чего поток закрывается и освобождаются все связанные с ним системные ресурсы. Закрытый поток не может выполнять операции вывода и не может быть открыт заново. В классе OutputStream реализация метода close() не производит никаких действий.

Итак, классы InputStream и OutputStream определяют необходимые методы для работы с байтовыми потоками данных. Эти классы являются абстрактными. Их задача – определить общий интерфейс для классов, которые получают данные из различных источников. Такими источниками могут быть, например, массив байт, файл, строка и т.д. Все они, или, по крайней мере, наиболее распространенные, будут рассмотрены далее.

Классы-реализации потоков данных

Классы ByteArrayInputStream и ByteArrayOutputStream

ByteArrayInputStream in =

int readedInt = in.read(); // readedInt=1

System.out.println(«first element read is: „

// readedInt=255. Однако

// (byte)readedInt даст значение -1

System.out.println(“second element read is: „

readedInt = in.read(); // readedInt=0

System.out.println(“third element read is: „

Если запустить такую программу, на экране отобразится следующее:

first element read is: 1

second element read is: 255

third element read is: 0

При вызове метода read() данные считывались из массива bytes, переданного в конструктор ByteArrayInputStream. Обратите внимание, в данном примере второе считанное значение равно 255, а не -1, как можно было бы ожидать. Чтобы понять, почему это произошло, нужно вспомнить, что метод read считывает byte, но возвращает значение int, полученное добавлением необходимого числа нулей (в двоичном представлении). Байт, равный -1, в двоичном представлении имеет вид 11111111 и, соответственно, число типа int, получаемое приставкой 24-х нулей, равно 255 (в десятичной системе). Однако если явно привести его к byte, получим исходное значение.

ByteArrayOutputStream out =

В этом примере в результате массив bytes будет состоять из двух элементов: 10 и 11.

Использовать классы ByteArrayInputStream и ByteArrayOutputStream может быть очень удобно, когда нужно проверить, что именно записывается в выходной поток. Например, при отладке и тестировании сложных процессов записи и чтения из потоков. Эти классы хороши тем, что позволяют сразу просмотреть результат и не нужно создавать ни файл, ни сетевое соединение, ни что-либо еще.

Классы FileInputStream и FileOutputStream

Класс FileInputStream используется для чтения данных из файла. Конструктор такого класса в качестве параметра принимает название файла, из которого будет производиться считывание. При указании строки имени файла нужно учитывать, что она будет напрямую передана операционной системе, поэтому формат имени файла и пути к нему может различаться на разных платформах. Если при вызове этого конструктора передать строку, указывающую на несуществующий файл или каталог, то будет брошено java.io.FileNotFoundException. Если же объект успешно создан, то при вызове его методов read() возвращаемые значения будут считываться из указанного файла.

Для записи байт в файл используется класс FileOutputStream. При создании объектов этого класса, то есть при вызовах его конструкторов, кроме имени файла, также можно указать, будут ли данные дописываться в конец файла, либо файл будет перезаписан. Если указанный файл не существует, то сразу после создания FileOutputStream он будет создан. При вызовах методов write() передаваемые значения будут записываться в этот файл. По окончании работы необходимо вызвать метод close(), чтобы сообщить системе, что работа по записи файла закончена. Пример:

String fileName = “d:\test.txt»;

FileOutputStream outFile = new FileOutputStream(fileName);

System.out.println(«Файл открыт для записи»);

// Записать массив

System.out.println(«Записано: » + bytesToWrite.length + » байт»);

// По окончании использования должен быть закрыт

System.out.println(«Выходной поток закрыт»);

FileInputStream inFile = new FileInputStream(fileName);

System.out.println(«Файл открыт для чтения»);

// Узнать, сколько байт готово к считыванию

int bytesAvailable = inFile.available();

System.out.println(«Готово к считыванию: » + bytesAvailable + » байт»);

int count = inFile.read(bytesReaded,0,bytesAvailable);

System.out.println(«Считано: » + count + » байт»);

for (int i=0;i<count;i++)

System.out.println(«Входной поток закрыт»);

System.out.println(«Невозможно произвести запись в файл: » + fileName);

System.out.println(«Ошибка ввода/вывода: » + e.toString());

Результатом работы программы будет:

Записано: 3 байт

Готово к считыванию: 3 байт

Считано: 3 байт

При работе с FileInputStream метод available() практически наверняка вернет длину файла, то есть число байт, сколько вообще из него можно считать. Но не стоит закладываться на это при написании программ, которые должны устойчиво работать на различных платформах,– метод available() возвращает число байт, которое может быть на данный момент считано без блокирования. Тот факт, что, скорее всего, это число и будет длиной файла, является всего лишь частным случаем работы на некоторых платформах.

В приведенном примере для наглядности закрытие потоков производилось сразу же после окончания их использования в основном блоке. Однако лучше закрывать потоки в finally блоке.

Такой подход гарантирует, что поток будет закрыт и будут освобождены все связанные с ним системные ресурсы.

Классы PipedInputStream и PipedOutputStream

Классы PipedInputStream и PipedOutputStream характеризуются тем, что их объекты всегда используются в паре – к одному объекту PipedInputStream привязывается (подключается) один объект PipedOutputStream. Они могут быть полезны, если в программе необходимо организовать обмен данными между модулями (например, между потоками выполнения).

Читайте также:  Вход в личный кабинет superjob по номеру телефона

Эти классы применяются следующим образом: создается по объекту PipedInputStream и PipedOutputStream, после чего они могут быть соединены между собой. Один объект PipedOutputStream может быть соединен с ровно одним объектом PipedInputStream, и наоборот. Затем в объект PipedOutputStream записываются данные, после чего они могут быть считаны именно в подключенном объекте PipedInputStream. Такое соединение можно обеспечить либо вызовом метода connect() с передачей соответствующего объекта PipedI/OStream (будем так кратно обозначать пару классов, в данном случае PipedInputStream и PipedOutputStream), либо передать этот объект еще при вызове конструктора. Использование связки PipedInputStream и PipedOutputStream показано в следующем примере:

int countRead = 0;

PipedInputStream pipeIn = new PipedInputStream();

PipedOutputStream pipeOut = new PipedOutputStream(pipeIn);

// Считывать в массив, пока он полностью не будет заполнен

// Записать в поток некоторое количество байт

// Считать из потока доступные данные,

// добавить их к уже считанным.

int willRead = pipeIn.available();

//Нужно считать только до предела массива

willRead = toRead.length-countRead;

countRead += pipeIn.read(toRead, countRead, willRead);

System.out.println («Impossible IOException occur: „);

Данный пример носит чисто демонстративный характер (в результате его работы массив toRead будет заполнен случайными числами). Более явно выгода от использования PipedI/OStream в основном проявляется при разработке многопоточного приложения. Если в программе запускается несколько потоков исполнения, организовать передачу данных между ними удобно с помощью этих классов. Для этого нужно создать связанные объекты PipedI/OStream, после чего передать ссылки на них в соответствующие потоки. Поток выполнения, в котором производится чтение данных, может содержать подобный код:

// inStream — объекткласса PipedInputStream

int bytesAvailable = inStream.available();

// обработка полученных данных из readedBytes

/* IOException будет брошено, когда поток inStream, либо

связанный с ним PipedOutputStream, уже закрыт, и при этом

производится попытка считывания из inStream */

System.out.println(“работа с потоком inStream завершена»);

Иногда бывает удобно работать с текстовой строкой String как с потоком байт. Для этого можно воспользоваться классом StringBufferInputStream. При создании объекта этого класса необходимо передать конструктору объект String. Данные, возвращаемые методом read(), будут считываться именно из этой строки. При этом символы будут преобразовываться в байты с потерей точности – старший байт отбрасывается (напомним, что символ char состоит из двух байт).

Класс SequenceInputStream объединяет поток данных из других двух и более входных потоков. Данные будут вычитываться последовательно – сначала все данные из первого потока в списке, затем из второго, и так далее. Конец потока SequenceInputStream будет достигнут только тогда, когда будет достигнут конец потока, последнего в списке.

В этом классе имеется два конструктора – принимающий два потока и принимающий Enumeration (в котором, конечно, должны быть только экземпляры InputStream и его наследников). Когда вызывается метод read(), SequenceInputStream пытается считать байт из текущего входного потока. Если в нем больше данных нет (считанное из него значение равно -1), у него вызывается метод close() и следующий входной поток становится текущим. Так продолжается до тех пор, пока не будут получены все данные из последнего потока. Если при считывании обнаруживается, что больше входных потоков нет, SequenceInputStream возвращает -1. Вызов метода close() у SequenceInputStream закрывает все содержащиеся в нем входные потоки.

FileInputStream inFile1 = null;

FileInputStream inFile2 = null;

SequenceInputStream sequenceStream = null;

FileOutputStream outFile = null;

inFile1 = new FileInputStream(«file1.txt»);

inFile2 = new FileInputStream(«file2.txt»);

sequenceStream = new SequenceInputStream(inFile1, inFile2);

outFile = new FileOutputStream(«file3.txt»);

int readedByte = sequenceStream.read();

System.out.println(«IOException: » + e.toString());

В результате выполнения этого примера в файл file3.txt будет записано содержимое файлов file1.txt и file2.txt – сначала полностью file1.txt, потом file2.txt. Закрытие потоков производится в блоке finally. Поскольку при вызове метода close() может возникнуть IOException, необходим try-catch блок. Причем, каждый вызов метода close() взят в отдельный try-catch блок — для того, чтобы возникшее исключение при закрытии одного потока не помешало закрытию другого. При этом нет необходимости закрывать потоки inFile1 и inFile2 – они будут автоматически закрыты при использовании в sequenceStream — либо когда в них закончатся данные, либо при вызове у sequenceStream метода close().

Объект SequenceInputStream можно было создать и другим способом: сначала получить объект Enumeration, содержащий все потоки, и передать его в конструктор SequenceInputStream:

Vector vector = new Vector();

vector.add(new StringBufferInputStream(«Begin file1
»));

vector.add(new StringBufferInputStream(»
End of file1, begin file2
«));

vector.add(new StringBufferInputStream(»
End of file2″));

Enumeration en = vector.elements();

sequenceStream = new SequenceInputStream(en);

Если заменить в предыдущем примере инициализацию sequenceStream на приведенную здесь, то в файл file3.txt, кроме содержимого файлов file1.txt и file2.txt, будут записаны еще три строки – одна в начале файла, одна между содержимым файлов file1.txt и file2.txt и еще одна в конце file3.txt.

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

1. Арнольд К., Гослинг Дж. «Язык программирования Java»

2. Хорстманн К.С., Корнелл Г. « Java 2. Том 1. Основы», 7-е изд.

По дисциплине

Выполнил: Забулдыга А.В.

Новосибирск, 2015 г

Реализуйте простейший Калькулятор. Имеется набор кнопок, циферблат. Калькулятор позволяет вычислять (сумму, разность, произведение и частное). Предусмотреть обработку ситуации деления на ноль.

Нарисуйте светофор. На нем разместите несколько шаров, которые будут медленно менять цвет с разной скоростью. Обработку изменения цвета реализовать с помощью потоков.

Прыгающий кубик. Начальная позиция появления объекта определяется нажатием пальца по экрану. Объект падает с ускорением вниз, отражаясь от нижней границы экрана, и с незначительным смешением вправо. С каждым разом высота отскока объекта уменьшается, и когда объект практически остановится, он пропадает с экрана. Объектов может быть несколько, поэтому каждый должен обрабатываться в отдельном потоке приложения.

Дополните Задание 3 возможностью изменения настроек (цвета объекта, ускорения, цвет/рисунок фона). Добавьте кнопку настройки в основное меню программы. Отскок объекта от границы экрана должен сопровождаться звуком (любым на ваше усмотрение).

Исходный код модуля MainActivity.java:

//описание элементов управления

Button task1 = (Button)findViewById(R.id.button_task1);

Button task2 = (Button)findViewById(R.id.button_task2);

Button task3 = (Button)findViewById(R.id.button_task3);

Button task4 = (Button)findViewById(R.id.button_task4);

//назначение событий элементам управления

Intent task_calc = new Intent(getApplicationContext(), CalcActivity.class);

Intent task_draw = new Intent(getApplicationContext(), ActivityDraw.class);

Руководство пользователя

Поскольку наше приложение по архитектуре клиент-сервер, то в первую очередь нам нужно запустить сервер, который в свою очередь открывает локальное соединение и работает на порту 8030. На рисунке 4 приведена форма сервера.

Курсы и курсы по программированию на java

Рассмотрим сторону клиента, главная форма клиентского приложения представлена на рисунке 5.

Курсы и курсы по программированию на java

В отчете находятся все необходимые диаграммы к нашей программе, такие как:

Также, присутствуют все скриншоты с описанием каждого действия пользователя в программе.

Курсы и курсы по программированию на java

Как мы можем увидеть из сриншота, в пояснительной записке содержится 27 страниц.

Курсовая работа (Задание)

Разработка клиент-серверного приложения для обмена файлами на языке программирования Java.

Постановка задачи

Задачей проекта является разработка клиент-серверного приложения для обмена файлами на языке программирования Java.

Цели и функции приложения:

Скриншот архива с проектом

Курсы и курсы по программированию на java

Оцените статью
Добавить комментарий