Преамбула

 На сегодняшний день создание программного обеспечения представляет собой чрезвычайно тяжелое занятие. Трудности связаны с разнообразием архитектур машин, операционных систем, графических оболочек и т.д.. Кроме того, ваши приложения должны работать в распределенных системах. Стремительный рост технологий, связанных с Интернетом, WWW и "электронной коммерцией", дополнительно усложняют эту задачу. Модный ныне объектно-ориентированный подход сам по себе не решает этих проблем, более того, часто привносит новые.
Предлагаемый фирмой Sun Microsystems подход, а именно система программирования на основе языка Java(TM) обладает следующими характеристиками:

• язык программирования объектно-ориентирован, в то же время довольно прост для освоения
• цикл разработки приложений сокращен за счет того, что система построена на основе интерпретатора
• приложение получается автоматически переносимым между множеством платформ и операционных систем
• за счет встроенной системы сборки мусора программист освобождается от необходимости явного управления памятью
• в интерактивном графическом приложении удается достичь высокой производительности (быстрого отклика на ввод пользователя) за счет встроенной в систему многопотоковости
• приложение легко сопровождается и модифицируется, т.к. модули могут быть загружены с сети
• в приложения встроена система безопасности, не допускающая незаконного доступа и проникновения вирусов

 Целью проекта было создание небольшой, надежной, переносимой и распределенной системы реального времени. Исходно в качестве языка планировалось использование языка программирования С++, но постепенно связанные с ним трудности привели к необходимости создания нового языка. Система должна была вобрать в себя лучшие черты из множества современных систем программирования -- Eiffel, Smalltalk, Objective C, Cedar/Mesa и т. д..
Стремительный рост сетевых технологий привел к необходимости нового взгляда на процесс создания и распределения приложений. Современные приложения должны быть безопасны, высокопроизводительны, работать в распределенной среде на множестве машин различной архитектуры.
Требования к переносимости заставили отказаться от традиционного способа создания и доставки бинарных файлов, содержащих машинные коды и, следовательно, привязанных к определенной платформе. Сегодня, чтобы выжить в этих джунглях из архитектур процессоров, операционных систем и графических оболочек, приложение должно быть нейтрально к архитектуре и динамически настраиваемо.
Созданная система разработки Java удовлетворяет всем этим требованиям, а следовательно:

• проста, поэтому может быть использована широким кругом разработчиков
• объектно ориентирована, что соответствует современному взгляду на программирование
• поддерживает многопотоковость, что позволяет выполнять несколько задач одновременно
• интерпретируема, что обеспечивает переносимость и улучшает динамические свойства

Свойства Java, краткий обзор

 Java проста, объектно ориентированна и знакома
Система Java создана на основе *простого* языка программирования, техника использования которого близка к общепринятой и обучение которому не требует значительных усилий.
Java как язык программирования является объектно ориентированной с момента основания. Кроме того программист с самого начала обеспечивается набором *стандартных* библиотек, обеспечивающих функциональность от стандартного ввода/вывода и сетевых протоколов до графических пользовательских интерфейсов. Эти библиотеки легко могут быть расширены.
Несмотря на то, что язык С++ был отвергнут, синтаксис языка Java максимально приближен к синтаксису С++. Это делает язык знакомым широкому кругу программистов. В то же время из языка были удалены многие свойства, которые делают С++ излишне сложным для пользования, не являясь абсолютно необходимыми. В результате язык Java получился более простым и органичным, чем С++.
Надежность и безопасность
Java существенно облегчает создание надежного программного обеспечения. Кроме исчерпывающей проверки на этапе компиляции, система предусматривается анализ на этапе выполнения. Сам язык спроектирован так, чтобы вырабатывать у программиста привычку писать "правильно". Модель работы с памятью, в которой исключено использование указателей, делает невозможными целый класс ошибок, характерных для С и С++.
В силу того, что Java предназначена для работы в распределенной среде, безопасность становится чрезвычайно важной проблемой. Требования безопасности определяют многие черты как языка, так и реализации всей системы.
Независимость от архитектуры и переносимость.
Компилятор Java производит байт-коды, т.е. модули приложения имеют архитектурно-независимый формат, который может быть проинтерпретирован на множестве разнообразных платформ. Это уже не исходные тексты, но еще не платформно-зависимые машинные коды.
Следующий шаг -- "замораживание" стандарта на формат основных встроенных типов данных. Программа, созданная на одной платформе, работает на всех остальных.
Этот стандарт фиксирован в документе, описывающем Java Virtual Machine. Стандарт может быть реализован на любой аппаратно-программной платформе, поддерживающей многопотоковость.
Производительность
Схема работы системы и набор байт-кодов виртуальной машины Java таковы, что позволяют достичь высокой производительности на этапе выполнения программы:

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

Базовая система Java

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

• java.lang -- базовый набор типов, отраженных в самом языке. Этот пакет обязательно входит в состав любого приложения. Содержит описания классов Object и Class, а также поддержку многопотоковости, исключительных ситуаций, оболочку для базовых типов, а также некоторые фундаментальные классы.
• java.io -- потоки и файлы произвольного доступа. Аналог библиотеки стандартного ввода-вывода системы UNIX. Поддержка сетевого доступа (sockets, telnet, URL) содержится в пакете java.net.
• java.util -- классы-контейнеры (Dictionary, HashTable, Stack) и некоторые другие утилиты. Кодирование и декодирование. Классы Date и Time.
• java.awt -- Abstract Windowing Toolkit, архитектурно-независимый оконный интерфейс, позволяющий запускать интерактивные оконные Java-приложения на любой платформе. Содержит базовые компоненты интерфейса, такие как события, цвета, фонты, а также основные оконные элементы -- кнопки, scrollbars и т.д..

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

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

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

Основные свойства языка программирования Java

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

• целые числа: 8-бит byte, 16-бит short, 32-бит int, 64-бит long. Все числа со знаком, ключ unsigned из языка удален.
• числа с плавающей точкой. 32-бит float, 64-бит double. Представление должно соответствовать стандарту IEEE 754.

Point myPoints[];

myPoints = new Point[10];

myPoints[2] = new Point();

howMany = myPoints.length;

String hello = "Hello world!";

System.out.println("There are" + num + "characters in the file.");

test:
      for(int i = 0; i < 10; i++)
        for(int j = 0; j < 10; j++)
          if( i > 3)
            break test;

Свойства, присутствующие в С и С++, и удаленные из Java

 Конструкция typedef, препроцессор
Конструкция typedef была унаследована С++ из С. Из Java она выброшена совсем.
Необходимость в макропроцессоре также во многом отпала при написании программ на С++. Почти все, для чего использовались макрорасширения, можно было сделать более элегантным и надежным образом, используя конструкции самого языка.
Система неявно поощряла создание каждым программистом своего собственного подмножества языка, неизвестного остальному миру. По мере разрастания кодов увеличивается тот смысловой контекст, в котором компилятор интерпретирует каждую строку программы. Уже в проектах среднего размера существенно возрастает нагрузка на компилятор, не говоря уже о нагрузке на память программиста.
Единственная оставшаяся важная функция препроцессора -- позволить включение в программу файлы-заголовки с описаниями классом. Эта операция может быть выполнена более просто и эффективно, если позволить компилятору читать подготовленные бинарные файлы с описанием классов. Последний путь был выбран при создании языка Java.
Все эти соображения позволили полностью исключить необходимость использования текстового препроцессора в языке Java.
Struct и union
Структуры не имеют смысла в Java, их роль полностью выполняют классы. Использование конструкций типа union для типизованных объектов также больше не нужно -- язык позволяет определить тип объекта при исполнении программы.
Функции
В этом смысле Java чисто объектно-ориентированная система. Функции и процедуры, не привязанные к контексту какого-либо объекта, больше не присутствуют в системе. В ситуации, когда функция логически не привязана к определенному экземпляру класса, она может быть создана как метод самого класса (т.е. иметь тип static).
Множественное наследование
Последовательная реализация концепции множественного наследования в С++ привела к существенным сложностям как в создании компиляторов, так и в использовании его (множественного наследования) в программах. В качестве альтернативы Java использует понятие интерфейса определяющего набор методов, которые должны быть определены в классе, реализующем этот интерфейс. Интерфейс может также содержать определение некоторых констант.
То, чего интерфейс содержать не может -- это реализации методов или изменяемые поля данных. Классы, которые объявлены, как реализующие тот или иной интерфейс, обязаны реализовать все методы, объявленные в интерфейсе.
Goto
см. выше описание операторов continue и break с меткой.
Перегрузка операторов
Опыт использования перегруженных операторов в С++ показывает, что они имеют смысл в довольно ограниченном наборе ситуаций. С другой стороны, злоупотребление этим свойством может сделать программу абсолютно непонятной. Единственное "встроенное" в язык Java исключение -- возможность использования оператора "+" для склеивания строк (см. выше).
Автоматическое преобразование типов
В языке Java запрещено автоматическое преобразование типов, широко используемое (и рекомендуемое) в С++. Чтобы преобразовать элемент одного типа в другой, необходимо указать это явно, например

int myInt;
double myFloat = 3.14159;
myInt = myFloat;                // допустимо в С++, недопустимо в Java
myInt = (int)myFloat;           // допустимо в Java

Итоги

 Итак, мы показали два из основных свойства языка программирования Java

• знакомый -- Java сохраняет стиль программирования C и С++
• простой -- количество конструкций языка в Java существенно сокращено по сравнению с С и С++

Система Java создавалась объектно ориентированной с самого начала. Объектно-ориентированная парадигма наиболее удобна при создании программного обеспечения типа клиент-сервер, а также для организации распределенных вычислений.
Одна из черт, присущих объектам, заключается в том, что объекты обычно переживают процедуру, их создающую. Они затем могут перемещаться по сети, храниться в базах данных и т.д.
Идейными наследниками Java являются такие языки, как C++, Eiffel, Smalltalk и Objective C. За исключением примитивных типов данных, практически все в языке является объектом.

Основные требования к объектно-ориентированной системе
 
 

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

 Классы
Класс есть языковая конструкция, определяющая поля данных объектов данного класса (instance variables) и их поведение (methods). Практически класс в Java сам по себе не является объектом. Это лишь шаблон, который определяет, из каких частей будет состоять объект, созданный с помощью этого класса, и как он будет себя вести.
Простейший пример описания класса

class Point extends Object {
  public double x;
  public double y;
}

Point myPoint;          // объявление переменной типа Point
myPoint = new Point();  // инициализация

myPoint.x = 10.0;
myPoint.y = 25.7;

class Point extends Object {
  Point() {
    x = 0.0;
    y = 0.0;
  }
  Point(double x, double y) {
    this.x = x;
    this.y = y;
  }
  public double x;
  public double y;
}

Point a;
Point b;
a = new Point();
b = new Point(1.0, 2.0);

Pclass Point extends Object {
  private double x;
  private double y;
  public void setX(double x) {
        this.x = x;
  }
  public void setН(double y) {
        this.y = y;
  }
  ...
}

protected void finalize() {
  try {
    file.close();
  } catch (Exception e) {
  }
}

class ThreePoint extends Point {
  protected double z;
  ThreePoint() {
    super();
    z = 0.0;
  }
  ThreePoint(double x, double y, double z) {
    super(x, y);
    this.z = z;
  }
}

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

class Rectangle extends Object {
  static final int version = 2 ;
  static final int revision = 0 ;
}

abstract class Graphical extends Object
{
  protected Point lowerLeft;
  protected Point upperRight;
  ...
  public void setPosition(Point ll, Point ur)
  {
    lowerLeft = ll;
    upperRight = ur;
  }
  abstract void drawMyself();
}
class Rectangle extends Graphical
{
  void drawMyself()
    {
      ....      
    }
}

Итоги

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

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

Нейтральность к архитектуре

 Достигается прежде всего стандартизацией "бинарного формата кодов". Промежуточный код не зависит от конкретной аппаратной платформы, операционной системы и типа оконного интерфейса. Для того, чтобы программы, написанные на Java, могли работать на данной аппаратно-программной платформе, достаточно, чтобы для нее была создана лишь соответствующая виртуальная машина.
Байт-коды
Компилятор Java производит не "машинные коды" подобно тому, как это делает, например, компилятор языка С. Вместо этого генерируются так называемые байт-коды: высокоуровневые машиннонезависимые коды для абстрактной машины, которая должна быть реализована в виде интерпретатора Java и run-time системы.
Сама по себе идея байт-кодов не нова, они широко используются в различных системах начиная с середины семидесятых годов. Особенности Java байт-машины следующие:

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

 Кроме независимости кодов от конкретной архитектуры Java жестко специфицирует формат базовых типов данных. Без этого одна и та же программа, скомпилированная для разных аппаратных платформ, вела бы себя по-разному. Например, стандарт С/С++ не предусматривает конкретного представления для целого типа int. Предполагается, что этому типу соответствует основной формат машинного слова для данной архитектуры. В результате программа, написанная для 32-разрядного процессора, чаще всего переносится на 16-разрядную архитектуру с очень большими усилиями.
Таким образом, решение зафиксировать форматы базовых типов данных в Java вполне естественно. Каждая Java-машина обязана реализовать их следующим образом:

byte            8-bit two's complement
short           16-bit two's complement
int             32-bit two's complement
long            64-bit two's complement
float           32-bit IEEE 754 floating point
double          64-bit IEEE 754 floating point
char            16-bit Unicode character

Интеллектуальность

 Система Java предназначена для создания программного обеспечения, которое должно быть интеллектуальным, предельно надежным и безопасным по множеству параметров. Особое внимание уделяется как ранней диагностике возможных проблем, так и поздней, во время выполнения кодов.
Жесткая проверка на этапе компиляции и во время выполнения
Компиляция с языка Java предусматривает жесткую проверку исходных текстов, множество ошибок может быть выявлено уже на этом этапе.
Одним из преимуществ языка С++ как строго типизованного языка является возможность раннего выявления некоторых категорий ошибок. Однако во многом этот язык наследует свойства С, позволяя нарушать требования строгого объявления функций и методов. Язык Java требует явного объявления прототипов и не поддерживает характерных для С неявных преобразований.
Значительное число проверок, производимых компилятором, повторяются виртуальной машиной непосредственно перед выполнением приложения. Линкер получает всю информацию о прототипах методов и на основе ее производит такую же проверку, как и компилятор, позволяя избежать расхождений в версиях между отдельными модулями.
Наиболее существенное отличие языка Java от С или С++ заключается в том, что архитектура Java не позволяет случайно или намеренно повредить память программы. Вместо арифметики указателей Java использует полноценные объекты для массивов и строк, что позволяет контролировать индексы доступа к ним во время выполнения. Кроме того, невозможны превращения между целыми числами и указателями.
Естественно, что все это не может полностью гарантировать программиста от любых ошибок, однако, Java устраняет целый класс их, существенно облегчая задачу разработчика.

Для разработчика, использующего в своей работе обычные компилируемые языки, цикл разработки обычно выглядит следующим образом: редактировать текст -- скомпилировать его -- собрать программу линкером -- загрузить -- довести ее до "падения" -- рассмотреть обломки -- начать все с начала.
Кроме того, приходится постоянно следить за тем, какие из исходных текстов подлежат перекомпиляции. Для этого обычно используются дополнительные инструменты (например, популярная утилита make), часто не связанные с конкретным языком программирования и использующие крайне консервативный подход -- перекомпилировано должно быть все, что теоретически могло быть затронуто изменением. По мере того, как исходные тексты приложения разрастаются до сотен тысяч строк, взаимозависимости связывают части проекта крепче и крепче, скорость разработки приближается к нулю.
Система Java в силу своей интерпретируемой и динамической природы значительно более подходит для целей быстрой разработки надежных программ.
Как уже было отмечено выше, на выходе компилятора Java мы получаем байт-коды для Виртуальной Машины Java. Полная спецификация виртуальной машины открыта и общедоступна. Она может быть реализована практически на любой из современных программно-аппаратных платформ. После этого программы на языке Java могут быть собраны из любых мест в сети и работать на этой платформе так же, как и на любой другой.
Процесс сборки программы (linking) существенно ускорен по сравнению с обычными компилируемыми системами. Он представляет собой подгрузку необходимых классов и производится инкрементально, т.е. недостающие части подгружаются по мере надобности, что также приводит к сокращению времени цикла разработки.

Динамическая загрузка и связывание

 То, что Java является интерпретатором, позволяет расширять систему динамически. Отдельные классы загружаются лишь по мере необходимости и могут быть собраны из различных мест в сети. Перед запуском на выполнение коды проходят жесткую проверку.
В настоящее время объектно-ориентированный подход стал общепринятым. В качестве языка программирования при этом обычно выбирают С++. Однако этот язык обладает определенным недостатком, который известен под названием "проблемы хрупкости базового класса" (fragile superclass problem).
"Проблема хрупкости базового класса" в С++
Эта проблема возникает как побочный эффект реализации модели С++. Каждый раз, когда Вы добавляете новый метод или переменную в класс, все остальные модули приложения, использующие этот класс, требуют перекомпиляции. В противном случае программа успешно собирается, а при запуске так же успешно разваливается. Даже при использовании специальных утилит типа make неточное отслеживание взаимозависимостей между классами является неиссякающим источником ошибок. Эта проблема "хрупкости базового класса" также часто именуется как проблема "постоянной перекомпиляции". Избежать ее можно путем разнообразных уловок, обычно связанных с отказом от прямого использования объектно-ориентированных свойств языка.
Решение "проблемы хрупкости базового класса"
В системе программирования Java эта проблема решается в несколько этапов. Во-первых, компилятор не разрешает ссылок вплоть до численных значений. Напротив, символьная информация передается вместе с байт-кодами для проверки и интерпретации. Окончательное связывание имен производится интерпретатором в момент загрузки класса. После этого ссылки уже "прописаны", как непосредственные указатели, и интерпретатор может работать с нормальной скоростью.
Во вторых то, как объект должен выглядеть в памяти машины, определяется не компилятором, а самим интерпретатором. Добавление в класс новых переменных или методов не требует изменений в остальных кодах.
Понятие интерфейса в языке Java
Под интерфейсом (interface) в Java понимается спецификация дополнительного набора методов, которые "обязан знать" объект. Идея заимствована из языка Objective C, где такая спецификация называется протоколом (protocol). Интерфейс не включает в себя модифицируемых переменных или выполняемых кодов. Класс может реализовать любое количество интерфейсов, без всех трудностей организации иерархии классов при множественном наследовании в С++.
Представление в исполняемом модуле
Классы в Java реально представлены в работающей системе. Существует выделенный класс по имени Class, экземпляры которого создаются виртуальной машиной и содержат информацию о всех классах в системе. Для любого объекта возможно найти соответствующий ему объект, представляющий его класс. Класс может сообщить свое имя и ссылку на своего непосредственного предшественника в иерархии. Возможен также поиск классов по имени.

Итоги

 Интерпретируемая и динамическая природа языка Java предоставляет разработчику определенные преимущества:

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

По мере стремительного роста использования глобальных сетей в спектре услуг, простирающемся от электронного распространения программного обеспечения и объектов multimedia до электронных платежей, безопасность становится ключевой проблемой. Мы коснемся того, как компилятор Java и run-time предотвращают создание и проникновение "диверсионных" кодов.
Компилятор и run-time включают в себя несколько уровней обороны против потенциально опасных программ. В общем случае система исходит из предположения, что доверять нельзя никому. Следующие несколько секций касаются проблемы более детально.

Резервирование и распределение памяти

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

Процесс проверки байт-кодов

 Несмотря на то, что компилятор гарантирует, что коды не нарушают требований безопасности, если они были получены из других точек сети возникает следующая проблема: коды могут быть созданы не компилятором Java, а другими средствами. Или они могут быть намеренно модифицированы после создания. Поэтому run-time система подвергает полученные коды тщательной проверке.
Проверка включает в себя несколько этапов, начиная с контроля целостности формата полученного файла до анализа каждого фрагмента кодов на предмет выполнения следующих правил:

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

• не может произойти переполнение или "исчерпание" стека
• параметры для инструкций байт-машины имеют нужный тип
• доступ к полям и методам объектов не нарушает объявленных в классе правил (public, private, protected)

 В ходе выполнения программы может потребоваться загрузка дополнительных классов. После того как, полученный код прошел проверку на валидность байт-кодов, он поступает в загрузчик кодов. Для загрузчика все пространство имен загружаемых классов может быть подразделено на отдельные области (name spaces). Причем классы, полученные локально (заслуживающие безусловного доверия), и классы, присланные по сети из остального мира (и потенциально враждебные), находятся в разных пространствах имен.
При разрешении ссылки на какой-либо класс он ищется прежде всего в локальном пространстве. Это не позволяет "внешним" кодам подменить один из базовых классов в системе.

Безопасность в сетевом пакете

 Сетевой пакет Java включает в себя поддержку различных сетевых протоколов (FTP, HTTP, Telnet и т.д.). Это -- передовая линия защиты от вторжения по сети.
Осторожность при установке прав сетевого доступа в локальную систему может быть доведена до параноидальной. Вы можете

• запретить сетевой доступ вообще
• разрешить доступ только к тому узлу, с которого был получен код
• разрешить доступ только к узлам за пределами firewall, если код также получен с той стороны firewall
• разрешить любой сетевой доступ

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

Современного пользователя компьютера все чаще раздражает ситуация, когда программа способна выполнять в один момент времени лишь одну задачу. Реальный мир наполнен событиями, происходящими одновременно и независимо. Пользователь требует от компьютера адекватной реакции.
К сожалению, написание программ, отвечающих этим требованиям, значительно сложнее, чем написание программ, выполняющихся последовательно. Они могут быть созданы с использованием С или С++, однако делать это сложнее, т.к. отсутствует поддержка в самом языке, а также большинство существующих на сегодняшний день внешних библиотек часто не могут быть использованы в таких программах в силу того, что они не удовлетворяют так называемому thread-safe условию.
Термин thread-safe означает, что каждая функция данной библиотеки может быть использована одновременно несколькими потоками.
Основная проблема при прямом управлении потоками состоит в том, что Вы никогда не можете быть полностью уверены, что поставили все нужные замки (locks) и вовремя их освободили. При преждевременном завершении процедуры или при возникновении исключительной ситуации замок может остаться неснятым, что обычно приводит к блокировке программы (deadlock).
Встроенная многопотоковость -- существенная черта архитектуры Java. Стандартная библиотека включает в себя класс Thread, с методами, позволяющими стартовать новый поток, завершить его работу и проверить текущее состояние потока.
Интеграция примитивов синхронизации непосредственно в язык упрощает работу с ними.
Потоки в Java вытесняющие (pre-emptive), а также могут выполняться в режиме разделения времени (time-sliced), но только на платформах, которые поддерживают это. В системах, в которых такая поддержка отсутствует, после того, как поток был запущен, он может быть прерван только другим потоком с более высоким приоритетом. Если ваше приложение требует больших периодов вычислений, рекомендуется явно отдавать управление другим потокам (вызовом Thread.yield()).

Интегрированная синхронизация потоков

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