<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">\documentclass[10pt,twocolumn,a4paper,twoside]{report}
\usepackage[koi8-u]{inputenc}
\usepackage[russian]{babel}
% \usepackage[T1]{fontenc}

\usepackage{fancyhdr}
\usepackage[includehead,includefoot]{geometry}
\geometry{a4paper,top=7mm,bottom=7mm,footskip=1cm,left=15mm,right=7mm,twoside}

% preamble
\pagestyle{fancy}
\title{"Java" кратко обо всём}
\date{\today}
\author{Роман Савоченко}
\newcommand{\mycom}[3]{\rule{1ex}{1ex}\enskip\bf{#1}\it{#2}\rm{#3[5pt]}}
\newcommand{\slh}{\backslash}
%\newcommand{\mycom}[3]{\vspace[5pt] \rule{1ex}{1ex} \bf{#1}\it{#2}\rm{#3[5pt]}}

%\let\underscore=\_
\catcode`_=13
%\def_{\underscore\penalty75\relax}

\begin{document}

\footnotesize
{\setlength{\parskip}{0pt}\maketitle\tableofcontents}

\chapter{Язык ``Java''}

\section{Ключевые особенностии языка} 
\begin{itemize}
\item Приложение Java - это программа, которая выполняется с использованием интерпретатора java.
\item Для комментирования используются символы // - для однострочных комментариев и /* ... */ - для многострочных.
\item Приложение Java - это программа, которая выполняется с использованием интерпретатора java.
\item Обычно, в соответствии с принятым соглашением, все имена классов начинаются с заглавной буквы, как и 
каждое последующее слово, из которых составляется имя класса.
\item Приложение Java - это программа, которая выполняется с использованием интерпретатора java.
\item Идентификатор - это последовательность символов, состоящих из символов, цифр, символов подчеркивания (\_) и символов
доллара (\$). Идентификатор не должен начинаться с цифры и не должен содержать пробелы.
\item Язык чувствителен к регистру символов, т.е. символы верхнего регистра и символы нижнего регистра являются разными.
\item Приложения Java начинают выполнение с метода main. Первая строка метода main должна иметь следующий вид:
\textbf{public static void main( String args[] )}
\item Левая фигурная скобка (\{) открывает тело определения каждого метода. Соответствующая правая фигурная скобка (\}) 
должна заканчивать определение каждого метода.
\item Каждый оператор должен заканчиваться символом ';' (также называемый признаком конца оператора).
\item Многочисленные предопределённые классы Java группируются по категориям связанных классов, и эти группы называются 
пакетами. Все вместе эти пакеты объединяются термином \textbf{библиотека классов Java}, или \textbf{программный интерфейс приложений
Java (API Java)} 
\end{itemize}

\section{Ключевые слова Java} 
\begin{tabular}{|l|l|l|l|}
 \hline
 abstract     &amp; boolean     &amp; break             &amp; byte          \\
 case         &amp; catch       &amp; char              &amp; class         \\
 continue     &amp; default     &amp; do                &amp; double        \\
 else         &amp; extends     &amp; false             &amp; final         \\ 
 finally      &amp; float       &amp; for               &amp; if            \\
 implements   &amp; import      &amp; instanceof        &amp; int           \\ 
 interface    &amp; long        &amp; native            &amp; new           \\
 null         &amp; package     &amp; private           &amp; protected     \\
 public       &amp; return      &amp; short             &amp; static        \\   
 super        &amp; switch      &amp; synchronized      &amp; this          \\ 
 throw        &amp; throws      &amp; transient         &amp; true          \\
 try          &amp; void        &amp; volatile          &amp; while         \\
\hline
\end{tabular}

\section{Постоянные}
\begin{tabular}{|l|l|}
\hline
\multicolumn{2}{|c|}{\textbf{Целые константы}}  \\
\hline
Десятичные   &amp; цифры 0-9;(12,  111,  956)         \\
Восьмеричные &amp; цифры 0-7;(012=10, 011=73, 076=62) \\
Шестнадцатеричные &amp; цифры 0-9,буквы A-F или a-f   \\
                  &amp; (0x12=18, 0x2f=47, 0XA3=163)  \\
\hline
\multicolumn{2}{|c|}{\textbf{Длинные целые константы}}\\
\hline
Десятичная   &amp;  12l=12,  956L=956; \\
Восьмеричные &amp;  012l=10,  076L=62; \\
Шестнадцатеричные &amp; 0x12l=18,  0XA3L=163.\\
\hline
\multicolumn{2}{|c|}{\textbf{Беззнаковые целые константы}}\\
\hline
Десятичная   &amp;  12u=12,  956U=956; \\
Восьмеричные &amp;  012u=10,  076U=62; \\
Шестнадцатеричные &amp; 0x12u=18,  0XA3U=163.\\
\hline
\multicolumn{2}{|c|}{\textbf{Константы с плавающей точкой}}\\
\hline
\multicolumn{2}{|l|}{Всегда представляются типами float, double и long double:}\\ 
\multicolumn{2}{|l|}{345. = 345;  2.1e5 = 210000;  .123E3fL = 123; 4037e-5l = .04037}\\
\hline
\multicolumn{2}{|c|}{\textbf{Символьные константы}}\\
\hline
\multicolumn{2}{|l|}{Состоит из одного символа кода ASCII, заключеного в}\\
\multicolumn{2}{|l|}{апострофы: 'A'; 'a'; '7'; '\$'.}\\
\multicolumn{2}{|l|}{Многобайтовые символы: L'ab'.}\\
\multicolumn{2}{|l|}{Специальные символы:}\\
\verb+\n+    &amp; новая строка\\
\verb+\r+    &amp; перевод каретки\\
\verb+\t+    &amp; горизонтальная табуляция\\
\verb+\'+    &amp; апостроф\\
\verb+\"+    &amp; двойные кавычки\\
\verb+\\+    &amp; обратная дробная черта\\
\verb+\023+  &amp; символ задан восьмеричным числом\\
\hline
\multicolumn{2}{|c|}{\textbf{Строковые константы (литералы)}}\\
\hline
\multicolumn{2}{|l|}{Представляет последовательность символов кода ASCII,}\\ 
\multicolumn{2}{|l|}{заключённой в кавычки: "строка".}\\
\hline
\end{tabular}

\section{Переменные}
\subsection{Основные типы переменных}
\begin{tabular}{|l|l|l|}
 \hline
 Тип      &amp; Битов  &amp; Диапазон значений \\
 \hline
 boolean  &amp; 8  &amp; false, true \\
 char     &amp; 16 &amp; 0\dots65535 \\
 byte     &amp; 8  &amp; 128\dots128 \\
 short    &amp; 16 &amp; -32.768\dots32.767 \\
 int      &amp; 32 &amp; $-2^{31}$ \dots $2^{31}-1$ \\
 long     &amp; 64 &amp; $-2^{63}$ \dots $2^{63}-1$ \\
 float    &amp; 32 &amp; $3.4*10^{38}$ \\
 double   &amp; 64 &amp; $1.79*10^{308}$ \\
 \hline
\end{tabular}

\subsection{Пустой тип (void)}
Если этот тип используется как тип возврата из функции то функция не возвращает значений. Если используется
как список параметров функции, то входные параметры у функции отсутствуют. Если используется указатель на тип
void то его при использовании необходимо приводить к конкретному типу.

\subsection{Тип класс (class)}
\subsubsection{Общие понятия}
Класс имеет имя (тег) и состоит из полей, представляющих его члены. Ключевые слова public, private, protected перед классом и методами определяет 
доступ к классу и методам класса. 
\subsubsection{Наследование}
Наследование это когда производный класс наследует свойства родительского класса. Наследование 
обеспечивает возможность рассмотрения порождённого объекта как базового (но не наоборот).
Наследование может быть множественным. В производном классе допускается переопределение функций базового. 
Наследование выполняется с помощью ключевого слова \textbf{extends}. Реализация интерфейса иного объекта указывается через
ключевое слово \textbf{implements}.
Для обращения к перегруженной функции базового класса(суперкласса) можно записать \textbf{super.getData();}, где
super - ключевое слово указывающее на использование метода из базового класса.
\begin{verbatim}
public class Cover 
{
  int count;
  public void init() { };
};  
class book 
{
  public init() { };
};

class LibraryCard: extends Cover, book 
{
  public init() { };
};
\end{verbatim}

\subsubsection{Полиморфизм}
В классах поддерживается позднее(динамическое) связывание посредством механизма виртуальных функций. 
Динамическое связывание(определение адресов вызываемых в программе функций) происходит во время выполнения 
программы. В программах могут использоваться объектные переменные, или объектные указатели, значения которых 
- указатели на объекты-экземпляры того или иного класса. В языке С++ разрешается использовать объектный 
указатель базового класса для указания объекта производного класса. В языке С++ полиморфизм обеспечивается 
использованием механизма виртуальных функций. Для обращения к членам базового и производного класса имеющим 
одинаковые имена, используется определение виртуальной функции - virtual, что заставляет обращаться к члену 
последнего активизированного класса. Для корректного удаления объектов из памяти можно создавать виртуальный
деструктор который будет вызываться перед вызовом деструктора базового класса. Чистая виртуальная  функция 
(приравнивается 0) является аналогом прототипа, который объявляется в базовом классе а описывается в производном 
классе. Класс в котором хотя бы одна виртуальная функция приравнена 0 - является абстрактной. Абстрактным также
является класс у которого деструктор преравнен к 0, но всёже определён (используется для исключения прямого 
создания объекта данного класса). Конкретным является класс в котором все чисто виртуальные функции базового 
класса переопределены: 
\begin{verbatim}
class Base
{
  public: 
    void base_mess(void) {cout&lt;&lt;"Base\n"; }; 
    virtual void show_mess(void) { cout&lt;&lt;"Base";};  
    virtual void show_reserve(void) = 0;   
};
class Der: public Base
{
  public: 
    void der_mess(void){       }; 
    virtual void show_mess(void) { cout&lt;&lt;"Der";};         
    virtual void show_reserve(void){ cout&lt;&lt;"           ";};  
};
void main(void) 
{ 
  Base *base_pointer = new Base;
  base_pointer-&gt;base_mess();
  base_pointer-&gt;show_mess();
  base_pointer = new Der;
  base_pointer-&gt;der_mess();
  base_pointer-&gt;show_mess();   
}
\end{verbatim}

\subsubsection{Инициализаторы}
Для инициализации членов данных из конструктора можно использовать инициализаторы.
Которые являются единственным способом инициализации константных членов класса:
\begin{verbatim}
class Time
{
  public: 
    Time();   
    const int time;
};
Time::Time() : time(10)
{...};
\end{verbatim}

\subsubsection{Композиция}
Классы допускают композицию т.е включение одного объекта в другой. Включенные объекты
уничтожаются после уничтожения содержащего их объекта.
\begin{verbatim}
class Time
{
  public: 
    Time();   
    const int time;
};
class Date
{
  public
    Date();
  private
    const Time time;
}
Date::Date : time()
{...};
\end{verbatim}
\subsubsection{Ссылка на себя}
В классах есть возможность ссылаться на себя. Эта функция обеспечивается ключевым словом &lt;this&gt;
которое содержит адрес текущего объекта. Может использоваться сцепления путём возврата адреса
или ссылки объекта его членами функциями.
\subsubsection{Proxy классы}
Proxy классами называются классы которые призваны скрывать private члены классов закрытой реализации
библиотеки. Создаются они путем создания указателя на скрываемый класс в private поле proxy класса:\\
\begin{verbatim}
class Sequry
{
  public
    void setValue(int x);
  private: 
    int value;   
};
class Proxy
{
  public
    setValue(int x) {ptr-&gt;setValue(x);};
  private
    Sequry *ptr;
}
\end{verbatim}



\section{Синтаксис}
\subsection{Полезные обороты}
\begin{itemize}
\item Приведение типов:\\
 \verb+long с = (long)a;+ - традиционная запись;\\
 \verb+long с = long(a);+ - функциональная запись;\\
\item Декларация нескольких переменных одного типа:
\begin{verbatim} 
 int x,     // x
     y,     // y
     z;     // z
\end{verbatim}
\item Использование значений параметров функций по умолчанию:
\begin{verbatim}
 void show_values(int one=1, int two=2, int three=3);
 show_value();
 show_value(23);
\end{verbatim}
\item Объявление переменных по месту:
\begin{verbatim}
 for (int count = 0; count &lt; 10;count++)
\end{verbatim}
\end{itemize}

\subsection{Массивы}
Элементы массива имеют один и тот же тип и расположены в памяти друг за другом.
Для любого массива существует аттрибут \textbf{length} указывающий длину массива.
\begin{itemize}
\item Определение массивов:
\begin{verbatim}
 int array[]  = {10,20,30,40,50};
 
 int array1[]; 
 array1 = new int[10];
 
 int array2[] = new int[20];
\end{verbatim}
\item Передача массивов в функцию:
\begin{verbatim}
 int array[]  = {10,20,30,40,50};
 void modifyArray( int b[] ){ };
 modifyArray(array);
\end{verbatim}
\item Многомерные массивы:
\begin{verbatim}
 int array[][] = {{12,13},{14,16}};
 
 int array1[][];
 array1 = new int[3][4];
 
 int array2[][];
 array2 = new int[2][];  //выделение памяти для строк
 array2[0] = new int[5]; //выделение памяти для столбца строки 0
 array2[1] = new int[3]; //выделение памяти для столбца строки 1
\end{verbatim}
\end{itemize}

\subsection{Перегрузка функций}
В языке C++ разрешается иметь множество функций с одним и тем же именем, но отличающиеся типами 
параметров или их количеством:
\begin{verbatim} 
 int sum(int array, int element) {   }
 float sum(float array, int element) {   }
\end{verbatim}

\section{Операции}
\begin{tabular}{|p{14mm}|p{53mm}|p{14mm}|}
 \hline
 \it Символ &amp; \it Описание &amp; \it Направл. \\
 \hline
 \multicolumn{3}{|c|}{Самый высокий приоритет}\\
 \hline
 ()         &amp; Вызов функции     &amp; слева  \\
 \verb+[]+  &amp; Выделение элемента массива &amp; слева \\
 .          &amp; Выделение элемента &amp; слева \\
 \hline 
 ++         &amp; Пост-приращение &amp; справа \\
 -- --      &amp; Пост-декремент  &amp; справа \\
 +          &amp; Унарный плюс    &amp; справа \\
 -          &amp; Унарный минус   &amp; справа \\
 !          &amp; Логическое отрицание           &amp; справа \\
 \verb+~+   &amp; Побитовое отрицание            &amp; справа \\
 (тип)      &amp; Приведение типов &lt; (float)i &gt;  &amp; справа \\
 \verb+*+   &amp; Обращение по адресу переменной &amp; справа \\
 \hline     
 *          &amp; Умножение                      &amp; слева \\
 /          &amp; Деление 			     &amp; слева \\
 \%         &amp; Остаток от деления             &amp; слева \\
 \hline
 +          &amp; Сумма                          &amp; слева \\
 -          &amp; Разность                       &amp; слева \\
 \hline
 &lt;&lt;         &amp; Сдвиг влево                    &amp; слева \\
 &gt;&gt;         &amp; Сдвиг вправо                   &amp; слева \\
 \hline     
 &lt;          &amp; Меньше                         &amp; слева \\ 
 &lt;=         &amp; Меньше и равно                 &amp; слева \\ 
 &gt;          &amp; Больше                         &amp; слева \\
 &gt;=         &amp; Больше и равно                 &amp; слева \\
 \hline     
 ==         &amp; Равно                          &amp; слева \\
 !=         &amp; Неравно                        &amp; слева \\
 \hline  
 \&amp;         &amp; Поразрядный "И"                &amp; слева \\
 \hline
 \verb+^+   &amp; Поразрядный "исключающий ИЛИ"  &amp; слева \\
 \hline  
 |          &amp; Поразрядный "ИЛИ"              &amp; слева \\
 \hline     
 \&amp;\&amp;       &amp; Логический "И"                 &amp; слева \\
 \hline  
 ||         &amp; Логический "ИЛИ"               &amp; слева \\
 \hline 
 ?:         &amp; Условная операция              &amp; справа\\
            &amp; \emph{int i=(val&gt;=0)?val:-val;} &amp;      \\
 \hline     
 =          &amp; Присваивание                   &amp; справа \\
 += -= *= /= \%= |= \&amp;= \^= &lt;= &gt;= &amp; Составное присваивание         &amp; справа \\ 
 \hline
 ,          &amp; Операция последования (последовательность выполнения) &amp; слева \\   
 \hline
\end{tabular}

\section{Операторы}
\mycom{import\\}{}
{Подключение библиотеки расширения.\\
 \textbf{import javax.swing.JOptionPane;} \\} 
\mycom{break\\}
{}
{Прекращает выполнение ближайшего внешнего оператора: do, for, switch или while.\\
  {\bf for(;;) \{ printf("TEST"); break; \} } \\
 Возможно использование метки для прерывание сразу нескольких вложений. 
  {\bf br: for(;;) for(;;) \{ printf("TEST"); break br; \} } \\
}
\mycom{case\\}
{}
{
Оценивает &lt;выражение&gt; и выполняет любое утверждение, связанное с &lt;постоянной-выражением&gt;. 
Если не имеется никакого соответствия с постоянным выражением, утверждение, связанное с 
заданным по умолчанию ключевым словом выполняется. Если заданное по умолчанию ключевое 
слово не используется, управление переходит к утверждению после блока переключателя.\\
}
\mycom{continue\\}
{}
{Передает управление в начало оператора цикла do, for, или while вызывая следующую итерацию.\\
  {\bf for(i=0;i&lt;2;i++)\{printf("test"); continue; exit(1);\} }\\
 Возможно использование метки для вызова слудующей итерации любого уровня вложения. 
  {\bf cnt: for(;;) for(;;) \{ printf("TEST"); continue cnt; \} } \\
}
\mycom{default\\}{}
{Используется в \textbf{switch} для выполнения действий если не выполняется не одно из условий.\\}
\mycom{do\\}
{do оператор while(выражение);\\}
{Выполняет &lt;оператор&gt;, пока &lt;выражение&gt; истинно. Условие проверяется в конце цикла.\\}
\mycom{else\\}{}
{Выполняет &lt;выражение1&gt;, если &lt;выражение&gt; истинно (отлично от нуля); если else присутствует, 
 и &lt;выражение&gt; - ложно (нуль), выполняется &lt;выражение2&gt;. После выполнения &lt;выражение1&gt; или 
 &lt;выражение2&gt;, управление переходит к следующему утверждению.\\}
\mycom{final\\}
{final int CONST_VAL = 10;\\}
{Используется для объявления констант. Последующая модификация константы недопустима.\\}
\mycom{for\\}
{for(init-expr; cond-expr; increment) оператор;\\}
{Выполняет &lt;оператор&gt;, пока инициализированное число &lt;init-expr&gt;, над которым производится операция 
 &lt;increment&gt;, удовлетворяет условному выражению &lt;cond-expr&gt;.\\}
\mycom{if\\}
{if(выражение) выражение1; [else выражение2;]\\} 
{Выполняет &lt;выражение1&gt;, если &lt;выражение&gt; истинно (отлично от нуля); если else присутствует, 
 и &lt;выражение&gt; - ложно (нуль), выполняется &lt;выражение2&gt;. После выполнения &lt;выражение1&gt; или &lt;выражение2 &gt;, 
 управление переходит к следующему оператору.\\}
\mycom{return\\}{}
{Прекращает выполнение текущей функции и возвращает управление вызывающей программе, 
 с возможностью передачи значения выражения.\\}
\mycom{switch\\}
{switch(выражение)\{ \\
 case константа1: выражение1; [break;] \\
 case константа(n): выражение(n); [break;] \\ 
 {[default: выражение(n+1);]} \\ \} \\}
{ Сравнивает &lt;выражение&gt; с константами во всех вариантах case и выполняет оператор связанный с 
 &lt;постоянной-выражением&gt;. Если отсутствует соответствия с постоянных с выражениями то выполняется 
 утверждение, связанное с ключевым словом default. Если ключевое слово default не используется то 
 управление переходит к утверждению после блока переключателя.\\}
\mycom{while\\}
{while(выражение) оператор;\\}
{Выполняет &lt;оператор&gt;, пока &lt;выражение&gt; истинно.\\}

\section{Спецификаторы класса памяти}
\mycom{auto\\}{}
{Указывающий, что переменная имеет локальную (автоматическую) протяженность. Разрушается
 при выходе из функции.\\}
\mycom{register\\}{}
{Определяет, что переменная должна быть ,если возможно, сохранена в машинном регистре.\\} 
\mycom{extern\\}{}
{Определяет переменную которая должна быть видна в других объектных модулях.\\}
\mycom{mutable\\}{}
{Определяет в классе переменную которую можно модифицировать даже из константной функции.\\}
\mycom{static\\}{}
{Объявляет переменную которая будет являться одной для всех экземпляров функции и
 которая инициализируется при запуске программы. Статические функции объектов определяются 
 в одном экземпляре и становятся видимыми за пределы класса владельца. Кроме того статическая 
 функция член не может являться константной и имеют доступ только к статическим полям. Static 
 в глобальном отношении может использоваться для ограничения области действия 
 переменной пределами одного файла.\\
 \textbf{static int getCount();}\\
}

\section{Библиотеки и их функции (указываются через import)}
\subsection{\textbf{java} - Базовые пакеты библиотеки.}

\subsubsection{\textbf{lang} -}
 \begin{itemize}
  \item \textbf{System} - Системная библиотека.
  \begin{itemize}
   \item Функции.\\
    \mycom{exit\\}{void exit( int kz );\\}
    {Выход с кодом завершения &lt;kz&gt;.\\}
   \item \textbf{out} - Объект стандартного вывода.
   \begin{itemize}
    \item Функции.\\
     \mycom{print\\}{}
     {Печать строки текста в командное окно.\\}
     \mycom{println\\}{}
     {Печать строки текста в командное окно с переводом строки.\\}
   \end{itemize}
  \end{itemize}
  \item \textbf{Integer} - Тип: целое.
  \begin{itemize}
   \item Функции.\\
    \mycom{parseInt\\}{}
    {Преобразование строки в целое.\\}
    \mycom{toString\\}{String toString( int val );\\}
    {Преобразование целого в строку.\\}
  \end{itemize}  
  \item \textbf{Double} - Тип: вещественное.
  \begin{itemize}
   \item Функции.\\
    \mycom{parseDouble\\}{}
    {Преобразование строки в вещественное.\\}
  \end{itemize}  
  \item \textbf{String} - Тип: строка.
  \item \textbf{Math} - Объект математических операций.
  \begin{itemize}
   \item Функции.\\
    \mycom{abs\\}{}
    {Абсолютное значение.\\}
    \mycom{ceil\\}{}
    {Округление до наименьшего целого.\\}
    \mycom{cos\\}{}
    {Тригонометрический косинус.\\}
    \mycom{exp\\}{}
    {Экспонента.\\}
    \mycom{floor\\}{}
    {Округление до наибольшего целого.\\}
    \mycom{log\\}{}
    {Натуральный логорифм.\\}
    \mycom{max\\}{}
    {Большее из двух чисел.\\}
    \mycom{min\\}{}
    {Меньшее из двух чисел.\\}
    \mycom{pow\\}{}
    {Возведение в степень.\\}
    \mycom{random\\}{}
    {Генерация случайного числа.\\}
    \mycom{sin\\}{}
    {Тригонометрический синус.\\}
    \mycom{sqrt\\}{}
    {Корень квадратный.\\}
    \mycom{tan\\}{}
    {Тригонометрический тангенс.\\}
  \end{itemize} 
  \item \textbf{io} - Объект манипуляций со входом-выходом.
  \begin{itemize}
   \item \textbf{ObjectOutputStream} - Объект выходных потоков.
    \mycom{writeBytes\\}{writeBytes(String str);\\}
    {Запись в поток байтов.\\}
    \mycom{flush\\}{flush();\\}
    {Сброс буферов потока.\\}
    \mycom{close\\}{close();\\}
    {Закрыть поток.\\}
   \item \textbf{FileOutputStream} - Фыходной файловый поток.
  \end{itemize}
 \end{itemize}
 
\subsubsection{\textbf{awt} - Библиотека графического интерфейса пользователя(GUI).}
 \begin{itemize}
  \item \textbf{Container} - Контейнер графических объектов.\\
    \mycom{add\\}{}
    {Добавить объект в контейнер.\\}
    \mycom{setLayout\\}{}
    {Установка менеджера расположения.\\}
  \item \textbf{Event} - для обработки событий.\\
   \begin{itemize}
    \item \textbf{ActionListener} - Интерфейс ожидания событий.\\
      \mycom{actionPerformed\\}{ public void actionPerformed(ActionEvent actionEvent); }
      {Функция вызываемая по событию &lt;actionEvent&gt;.\\}     
    \item \textbf{ActionEvent} - Объект описывающий события.\\  
      \mycom{getActionCommand\\}{ String getActionCommand(); }
      {Получить команду действия.\\}         
   \end{itemize}
  \item \textbf{Graphics}.\\
    \mycom{drawLine\\}{}
    {Нарисовать линию.\\}
    \mycom{drawOval\\}{}
    {Нарисовать овал.\\}
    \mycom{drawRect\\}{}
    {Нарисовать прямоугольник.\\}
    \mycom{drawString\\}{}
    {Вывести строку в указанную позицию.\\}
    \mycom{paint\\}{}
    {Метод отрисовки, обычно переопределяется.\\}
 \end{itemize}
  
\subsubsection{\textbf{text} - Объект манипуляции с числами, датами, символами и строками.}
 \begin{itemize}
  \item \textbf{DecimalFormat} - Форматирование чисел.
  \begin{itemize}
   \item Функции.\\
    \mycom{format\\}{}
    {Форматирование.\\}
  \end{itemize}   
  \item \textbf{NumberFormat} - Форматирование чисел (денег, даты ....).
  \begin{itemize}
   \item Функции.\\
    \mycom{getCurrencyInstance\\}{}
    {Возвращает ссылку на объект NumberFormat для форматирования чисел как денежную еденицу для указанной локали.\\}
    \mycom{format\\}{}
    {Форматирование.\\}
  \end{itemize}   
 \end{itemize} 
 
\subsubsection{\textbf{net} - для обмена по сети.}
 
\subsubsection{\textbf{util} - Объект утилит.}
 \begin{itemize}
  \item \textbf{Locale} - Локали.
  \begin{itemize}
   \item Константы.\\
    \mycom{US\\}{}
    {США.\\}
  \end{itemize}   
 \end{itemize} 
 
\subsection{\textbf{javax} - Пакеты расширений.}

\subsubsection{\textbf{swing} - Библиотека графического интерфейса пользователя(GUI).}
 \begin{itemize}
   \item \textbf{Event} - Для обработки событий графического интерфейса.\\
   \item \textbf{Font} - Описание шрифта.\\
   \item \textbf{JApplet} - Для создания апплетов. Выступает в роли базового класса.\\
    \mycom{init\\}{public void init();\\}
    {Вызывается при инициализации апплета.\\}
    \mycom{start\\}{public void start();\\}
    {Вызывается при старте апплета.\\}
    \mycom{paint\\}{public void paint( Graphics g );\\}
    {Вызывается при отрисовке апплета.\\}
    \mycom{stop\\}{public void stop( );\\}
    {Вызывается при остановке апплета.\\}
    \mycom{destroy\\}{public void destroy( );\\}
    {Вызывается при уничтожении апплета.\\}
    \mycom{repaint\\}{public void repaint( );\\}
    {Перерисовать апплет.\\}
    \mycom{showStatus\\}{}
    {Отобразить сообщение в строке статуса.\\}
    \mycom{getContentPine\\}{}
    {Возвращает контейнер аплета.\\}
   \item \textbf{JOptionPane} - диалоги ввода-вывода\\
    \mycom{showMessageDialog\\}{}
    {Вывести диалог сообщений.\\}
    \mycom{showInputDialog\\}{}
    {Вывести диалог ввода.\\}
   \item \textbf{JScrollPane} - панель скролинга, подключается к соответствующим объектам\\
   \item \textbf{JTextArea} - область текста.\\
    \mycom{getText\\}{}
    {Получить текст.\\}
    \mycom{setText\\}{}
    {Установить текст.\\}
    \mycom{setFont\\}{ void setFont(Font font);}
    {Установить шрифт исходя из объекта Font.\\}
    \mycom{append\\}{}
    {Добавить текст.\\}
   \item \textbf{JLabel} - Информационная текстовая строка.\\
   \item \textbf{JTextField} - Поле ввода текстовой строки.\\
    \mycom{setEditable\\}{void setEditable(boolean stat);\\}
    {Установка признака редактируемости.\\}
    \mycom{setText\\}{void setText(String text);\\}
    {Установка текста в поле.\\}
    \mycom{getText\\}{String getText( );\\}
    {Получение текста из поля.\\}
    \mycom{addActionListener\\}{void addActionListener(ActionListener act);\\}
    {Указание объекта выполняющего роль интерфейса ActionListener.\\}   
   \item \textbf{JButton} - Кнопка.\\
    \mycom{addActionListener\\}{void addActionListener(ActionListener act);\\}
    {Указание объекта выполняющего роль интерфейса ActionListener.\\}   
   \item \textbf{FlowLayout} - Простейшим менеджер расположения.\\
 \end{itemize}

\end{document}

</pre></body></html>