Учебнометодическое пособие по дисциплинам Объектноориентированное программирование и Технологии программирования

• Название: Учебнометодическое пособие по дисциплинам Объектноориентированное программирование и Технологии программирования
• Анкор: metodichka of the labaratorki
• Дата: 04.02.2023
• Размер: 1.75 Mb.
• Имя файла: metodichka.doc
• Тип: Учебно-методическое пособие; #919790

Министерство образования и науки российской федерации
НОВОСИБИРСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ

______________________________________________________

ТЕХНОЛОГИЯ РАЗРАБОТКИ

ОБЪЕКТНО-ОРИЕНТИРОВАННЫХ ПРОГРАММ

НА JAVA

Учебно-методическое пособие

по дисциплинам «Объектно-ориентированное

программирование» и «Технологии программирования» для студентов для студентов IV курса очной формы обучения и

V курса заочной формы обучения АВТФ

(направление 230100.62 «Информатика и вычислительная техника» и специальность 230101.65 «Вычислительные машины, комплексы, системы и сети»

НОВОСИБИРСК

2012

Составитель: Васюткина И.А., канд. техн. наук, доцент

Рецензенты: Малявко А.А., канд. техн. наук, доцент

Гунько А.В., канд. техн. наук, доцент

Работа подготовлена на кафедре Вычислительной техники

© Новосибирский государственный

технический университет, 2012

ОГЛАВЛЕНИЕ

Предисловие	4
Глава 1. Основы программирования на Java. Создание простейших приложений и апплетов в NetBeans 7.0………………..	5
Глава 2. Обработка событий. Графика………………………..	36
Глава 3: Разработка графического интерфейса………………	56
Глава 4. Классы-коллекции……………………………………	79
Глава 5. Многопотоковые приложения……………………….	101
Глава 6. Потоки данных. Работа с локальными файлами……	119
Глава 7. Сетевые приложения «клент-сервер»……………….	139
Глава 8. Generic-классы в Java…………………………………	152

Предисловие

Данное учебно-методическое пособие содержит теоретический материал, изучаемый студентами IV курса очной формы обучения в дисциплине «Объектно-ориентированное программирование», IV курса очной формы обучения и V курса заочной формы обучения АВТФ в дисциплине «Технологии программирования».

В 8 главах пособия рассмотрены технологии разработки приложений и апплетов на языке Java в среде NetBeans 7.0.; разработки иерархий классов и интерфейсов; проектирования графического интерфейса пользователя, обработки событий; работы с байтовыми и символьными потоками ввода-вывода, сериализации и десериализации объектов; создания многопотоковых и «клиент-серверных» сетевых приложений; использования классов-коллекций для хранения и обработки данных, а также разработки универсальных generic- классов.

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

ГЛАВА 1. ОСНОВЫ ПРОГРАММИРОВАНИЯ НА JAVA. СОЗДАНИЕ ПРОСТЕЙШИХ ПРИЛОЖЕНИЙ И

АППЛЕТОВ В NETBEANS 7.0

При появлении Java двумя основными формами Java-программ являлись приложение и апплет.

Java-приложения выполняются под управлением специального интерпретатора (java.exe). Приложения похожи на программы, созданные, например, с использованием языка C/C++, хотя для своей работы они требуют присутствия Java виртуальной машины (JVM). Это полноправные приложения, которые существуют и выполняются в локальных компьютерных системах пользователей.

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

Инструментальная среда разработки программ на Java

Для создания программ на Java возможно использование нескольких сред разработки. Это может быть Microsoft Visual J++, JBuilder,IntelliJIdea, Eclipse или NetBeansIDE.

Использование среды NetBeans 7.0

1. 
   Создание нового Java-проекта. (File – New Project) (рис. 1.1).
   
2. 
   Настройка проекта (рис. 1.2). Необходимо задать имя проекта (в примере LabWorkN), его расположение и имя главного класса (в примере labworkn.Main). Обратите внимание, что имя разделено точкой. До точки – имя пакета (package), после – имя класса. Названия пакетов принято писать строчными буквами, а заглавные использовать только в именах классов.
   

Рис. 1.1. Создание нового проекта

Рис. 1.2. Задание имен проекта и главного класса
Добавление класса, интерфейса, апплета и т.д. в проект (правая кнопка мыши по пакету) (рис. 1.3).

Рис. 1.3. Добавление новых модулей в проект

3. 
   Если проект не был скомпилирован или был изменен, при запуске (через панель инструментов (см. рис.1.4), меню Run или F6) будет произведена компиляция. Результат выполнения консольного приложения, описание ошибок и исключений выводится в окно Output. Компиляция может быть произведена отдельно, без запуска (Build Main Project или Clean and Build Main Project).
   
4. 
   Для отладки программы устанавливаем точку останова щелчком по полю с номером строки кода. Появится красный квадрат напротив этой строки. При помощи команды Debug Main Project (Ctrl + F5) запускаем программу в режиме отладки (см. рис.1.5).
   
5. 
   Создание простейшего приложения. Java-файл будет содержать следующий код:
   

import java.util.*;
public class Hello {

public static void main(String args[]) {

System.out.println("Hello, world");

Date d=new Date();

System.out.println("Date:"+d.toString());

}

}

Рис. 1.4. Запуск программы

Рис. 1.5.Отладка программы

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

Все классы являются производными (или подклассами) от существующих классов. В случае - если не определен суперкласс, то по умолчанию предполагается, что таким суперклассом является класс Object.

Структура Java-программы

Все Java-программы содержат в себе четыре разновидности блоков: классы (classes), методы (methods), переменные (variables) и пакеты (package).

Классы представляют собой основу объектно-ориентирован-ных свойств языка. Классы содержат переменные и методы. Методы есть не что иное как функции или подпрограммы. В переменных хранятся данные.

Пакеты содержат в себе классы и помогают компилятору найти те классы, которые нужны ему для компиляции пользовательской программы. Классы, входящие в один пакет, особым образом зависят друг от друга. Например, приложение Hello импортирует пакет java.util, в котором содержится класс Date.

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

Переменные

В Java существует два вида переменных:

- примитивные типы(primitive types). К ним относятся стандартные, встроенные в язык типы для представления численных значений, одиночных символов и булевских (логических) значений. Все примитивные типы имеют предопределенный размер занимаемой ими памяти.

- ссылочные типы (reference type) - относятся типы, определенные пользователем (классы, интерфейсы) и типы массивов. Все ссылочные типы являются динамическими типами, для них выделяется память во время работы программы.

Переменные примитивных типов передаются в методы по значению, тогда как ссылочные переменные всегда передаются по ссылке.

Примитивные типы. Всего в Java определено восемь примитивных типов: int (4b), short (2b), byte (1b), long (8b), float (4b), double (8b), boolean (true, false), char (2b).

Первые шесть типов предназначены для хранения численных значений, с ними можно производить арифметические операции. Тип char предназначен для хранения символов в стандарте Unicode (2 байта). Булевские (логические) переменные могут иметь одно из двух допустимых значений: true или false.

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

Типы, определенные пользователем. Язык Java позволяет определять новые типы помощью новых классов. Рассмотрим пример определения и использования нового класса (нового типа) MyType:

Пример 1.1. Файл NewClass.java

class MyType { // объявляется класс

public int myData=5; // переменная-элемент класса

MyType() { // конструктор без параметров

System.out.println("Constructor without parameters");

}

MyType(int v) { // конструктор с одним параметром

System.out.print("Constructor with one parameter");

System.out.println(" Setting myData="+v);

myData=v;

}

public void myMethod() { // метод класса

System.out.print("myMethod!");

System.out.println(" myData="+myData);

}

}
// Реализация объектов и действия с ними

public class NewClass { // первичный класс

public static void main(String[] args) {

// объект obj1 - реализация класса MyType

MyType obj1=new MyType();

obj1.myMethod(); // использование метода

// доступ к открытой переменной

System.out.println("---obj1.myData="+obj1.myData);

// объект obj2 - реализация класса MyType

MyType obj2=new MyType(100);

// доступ к открытой переменной

System.out.println("----obj2.myData="+obj2.myData);

}

}

Класс String (тип строковых переменных). Класс String – это класс неизменяемых строк. Данный класс представляет собой гибрид примитивных и ссылочных типов. В основе своей тип String является ссылочным типом, содержащий в себе методы и переменные. Но в то же время этот тип проявляет некоторые свойства примитивного типа, что выражается, в том, как осуществляется присвоение значение этим переменным при помощи знака операции = (но можно для инициализации создаваемых объектов пользоваться и явным вызовом конструктора), например:

String S1="Hello"; // 1-ый способ инициализации

String S2=new String("Hello"); // 2-ый способ инициализации

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

String S0="Variable ";

int myInt=3;

String S1=S0+"myInt"+myInt;

String S2=new String(S0+"myInt"+myInt);

Несмотря на поддержку таких операций, строковые переменные типа String являются в то же время и объектами, для них можно вызывать методы класса String, например, узнать длину строки:

int len=S1.length();

Итак, тип String является особым - это единственный класс, переменные которого могут объявляться и использоваться без применения оператора new.

Типы массива. Типы массива используются для определения массивов - упорядоченного набора однотипных переменных. Можно определить массив любого существующего типа, включая типы, определенные пользователем. Кроме того, можно пользоваться и массивами массивов или многомерными массивами.

Создание массивов требует использования оператора new, например:

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

int intArray[];

intArray=new int[3]; // создание массива целого типа

// создание двумерного массива вещественного типа

float[][] flArray = new float[2][3];

// создание массива и инициализация

double[] а = {0.01, -3.4, 2.89, 4.5, -6.7};

// создание и инициализация двумерного массива переменных целых

int[][] arrayOfInts = { { 32, 87, 3, 589 }, { 12, 1076, 2000, 8 }, { 622, 127, 77, 955 } };

Массивы Java имеют три важных преимущества перед массивами других языков:

- программисту не обязательно указывать размер массива при его объявлении;

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

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

int len=intArray.length;

Классы

Статические и динамические элементы класса. Если при определении элемента не используется ключевое слово static, то этот элемент по умолчанию является динамическим (dynamic).

Динамические методы и переменные всегда являются элементами объекта класса, и доступ к ним осуществляется через переменную-объект.

ИмяОбъекта.ИмяПеременнойЭкземпляра

ИмяОбъекта.ИмяМетодаЭкземпляра(<Параметры>)

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

ИмяКласса.ИмяПеременнойКласса

ИмяКласса.ИмяМетодаКласса(<Параметры>)

Статические методы класса могут работать только со статическими переменными класса, для которых также не важно наличие реализованного объекта. Эти элементы класса используются всеми объектами класса (для всех объектов существует только один экземпляр статической переменной).
Пример 1.2. Файл TestElements.java

class StaticAndDynamic {

int i=0; // переменная экземпляра

static int j=0; // переменная класса

// статические методы

static void setJ(int k) {

System.out.println("Static Method"); j=k;

}

static int getJ() {

System.out.println("Static Method"); return j;

}

// динамические методы

void setI(int k) {

System.out.println("Dynamic Method"); i=k;

}

int getI() {

System.out.println("Dynamic Method"); return i;

}

int summa() {

// в динамических методах можно использовать статические переменные

System.out.println("Dynamic Method"); return i+j;

}

}

public class TestElements {

public static void main(String args[]) {

int ii,jj;

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

StaticAndDynamic.j=6; jj=StaticAndDynamic.j;

System.out.println("Main, jj="+jj);

// вызов статических методов

StaticAndDynamic.setJ(4);

jj=StaticAndDynamic.getJ();

System.out.println("Main, jj="+jj);
StaticAndDynamic obj=new StaticAndDynamic();

// использование динамической переменной

obj.i=3; ii=obj.i;

System.out.println("Main, ii="+ii);

// вызов динамическим методов

obj.setI(8); ii=obj.getI();

System.out.println("Main, ii="+ii);

ii=obj.summa();

System.out.println("Main, summa="+ii);

}

}

Модификаторы доступа. Модификаторы доступа используются для управления доступностью элементов класса из других частей программы (в других классах).

Элемент, объявленный с ключевым словом public (открытый), доступен во всех классах, как в своем пакете, так и во всех классах в любом другом пакете. Этот модификатор можно использовать при объявлении класса. Тогда этот класс доступен для всех классов других пакетов. В каждом файле должен содержаться только один public класс и имя файла должно совпадать с именем такого класса.

Элемент, объявленный с модификатором protected (защищенный) в некоем классе A, доступен во всех классах, являющихся подклассами класса A.

Модификатор private (закрытый) сильнее всего ограничивает доступность элемента. Он его делает невидимым за пределами данного класса. Даже подклассы данного класса не смогут обращаться к элементу, объявленному как private.

Если тип доступа к элементу не указан (доступ по умолчанию), то он доступен из всех классов, входящих в данный пакет.
Пример 1.3. Файл TestModificators.java

class A {

private int n;

A() { k=2; n=11; }

int summa() { return k+n; }

public int getN() { return n; }

public void setN(int nn) { n=nn; }

}
class TestModificators {

public static void main(String args[]) {

A obj=new A(); // создание объекта класса A

// получить значение переменных

int kk=obj.k; System.out.println("k="+kk);

int nn=obj.getN(); System.out.println("n="+nn);

obj.k=10; obj.setN(15);

int s=obj.summa(); System.out.println("summa="+s);

}

}

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

Наследование (inheritance), упрощает практическое использование классов, так как позволяет расширять уже написанные и отлаженные классы, добавляя к ним новые свойства и возможности. Таким образом создается то, что называется подклассом первоначального класса. Класс, который при этом наследуется (расширяется), называется суперклассом. При расширении класса имеется возможность использования всех написанных и отлаженных методов этого класса. Это свойство, называемое повторным использованием кода (code reuse), является одним из главных преимуществ объектно-ориентированного программирования.

Для задания наследования указывается ключевое слово extends. Например, объявление класса MyClass подклассом класса SuperClass, можно записать так:

class MyClass extends SuperClass { ..}

Специальные переменные

Каждый класс Java содержит три заранее определенные переменные, которыми можно пользоваться: null, this, super. Первые две переменные относятся к типу Object. Коротко говоря, null представляет собой несуществующий объект, this указывает на текущий экземпляр класса, переменная super разрешает доступ к открытым переменным и методам, определенным в суперклассе.
Переменная null. Прежде чем использовать какой-то класс, его нужно реализовать, т.е. создать объект (экземпляр) этого класса. До этого ссылка на объект имеет значение null.
Переменная this. Переменная this используется для указания ссылки на переменную экземпляра. Переменная this всегда указывает на текущий класс, поэтому, чтобы в методе получить доступ к скрытой переменной, объявленной в текущем классе, нужно явным образом указать принадлежность переменной к классу:

this. ИмяПеременной

Еще одна возможность использования этой ссылочной переменной - вызов в конструкторе класса другого конструктора этого же класса:

this(<ПараметрыДругогоКонструктораКласса>);

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

super.ИмяПеременной

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

super.ИмяМетодаСуперкласса(ПараметрыМетодаСуперкласса);

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

super(<ПараметрыКонструктораСуперкласса>;

Этот оператор должен быть первым исполняемым оператором конструктора.

Пакеты и импортирование

Классы являются основными строительными блоками любой Java-программы. Пакеты содержат в себе наборы классов (а также исключения и интерфейсы).

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

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

import ИмяПакета .*;

или

import ИмяПакета.ИмяКлассаПакета;
В этом случае импортирование просто должно предшествовать всем другим строкам программы. Например:

import java.applet.*; // импортируются все public классы пакета

import java.awt.*;

import java.net.URL ; // импортируется только указанный класс

Надо заметить, что импортируются всегда только классы, которые используютсяв программе. После этого классы можно использовать просто по именам, без указания на принадлежность тому или иному пакету, например:

ИмяКласса Obj = new ИмяКласса(<Параметры>);

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

ИмяПакета.ИмяКласса Obj =

new ИмяПакета.ИмяКласса(Параметры);

Создание пакетов. Для создания пакета (т.е. добавления класса в пакет) в первой строке программы указывается следующее предложение:

package ИмяПакета;

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

Апплеты

Апплеты выполняются под управлением виртуальной машины Java, встроенной в браузер. Апплет встраивается в документ HTML и выглядит как окно заранее заданного размера. Он может рисовать в своем окне произвольные изображения или текст. Двоичный файл с исполняемым кодом Java располагается на Web-сервере. В документ HTML с помощью специального оператора организуется ссылка на этот двоичный файл. Когда пользователь загружает в браузер документ HTМL с апплетом, файл апплета переписывается с Web-сервера на локальный компьютер пользователя.
Настройка запуска апплета двойного назначения в NetBeans 7.0

1. 
   Щелкаем правой кнопкой по названию проекта и выбираем Properties.
   
2. 
   В появившемся окне выбираем вкладку Web Start (рис. 1.6).
   

Рис.1.6. Задание параметров апплета
Активируем Enable Web Start. Выбираем в списке Codebase «Local Execution». Выбираем опцию Applet descriptor. Кнопка «Applet Parameters…» открывает окно редактирования параметров.

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

3. 
   Для апплета двойного назначения важно наличие главного класса, т.е. класса содержащего метод public static void main(String[] args). Для настройки в окне Properties выбираем вкладку Run (рис.1.7).
   

Комбобокс Configuration определяет способ запуска. Web Start – для апплета, - обычный запуск.

В строке Main Class необходимо выбрать главный класс. Без этого приложение не сможет запуститься в десктопном режиме.

Поле Arguments задает параметры командной строки. Параметры передаются с метод main через массив строк String[] args.


Рис.1.7. Задание параметров апплета двойного назначения
Исходный текст Java-файла простейшего апплета выглядит следующим образом:
import java.applet.*;

import java.awt.*;
public class Hello extends Applet{

public void init() {

resize(150,150);

}

public void paint(Graphics g) {

g.drawString("Hello, WWW", 10, 20);

}

}
При первом запуске апплета в NetBeans в папке build проекта создается файл HTML-документа со ссылкой на апплет, например:








width=200 height=200>

---

code=AppletWithParam.class name= AppletWithParam

width=320 height=240 >

---

The source.