Отличия java от c


Содержание

Java сильно отличается от C#?

22.06.2020, 13:52

Head First Java , чем отличается первое издание от второго?
мб глупый вопрос , но быстро его загуглить не получилось. второе изданием как продолжение первой.

Сильно ли отличается IDEA Ultimate от IDEA Community?
Хочу изучить java, решил для изучения выбрать IDE Intellij IDEA, т.к. денег нет скачал бесплатную.

Чем отличается простой проект на Java от апплета
Чем отличается простой проект на Java от апплета?И как сделать апплет? Знаю,что апплет можно.

Сильно ли похожа Java на С# Windows Form
мне надо сделать программу под Linux, Java подойдет думаю. Подскажите есть ли графическая.

Сильно ли i5 отличается от i7 в играх?
Сейчас для некоторых игр на максимальных настройках написано что необходим i7. Это значит что i5.

В чём разница?

Разница между C# и Java

Основное отличие между C# (Си шарп) и Java (Ява) заключается в том, что программы на C# работают в среде Common Language Runtime (CLR), а на Java работают в виртуальной машине Java (JVM).

C# и Java являются популярными языками программирования, которые имеют много общего. Оба поддерживают объектно-ориентированное программирование, которое помогает легко моделировать реальные сценарии. Используя C# и Java, программист может реализовать многопоточность для повышения производительности приложения. У них также есть автоматические сборщики мусора для эффективного управления памятью. Кроме того, оба языка основаны на языке Си.

Содержание

  1. Обзор и основные отличия
  2. Что такое C# — определение, функциональность
  3. Что такое Java — определение, функциональность
  4. Сходства между C # и Java
  5. В чем разница между C# и Java
  6. Заключение

Что такое C#

C# — это современный язык программирования общего назначения, разработанный Microsoft и принадлежащий .NET Framework. Он помогает в разработке различных приложений, включая Windows, веб, распределенные приложения и веб-сервисы. Кроме того, .NET Framework состоит из Common Language Runtime (CLR). Он управляет и выполняет код, написанный на любом языке программирования .NET. Следовательно, программы на C# требуют CLR для их выполнения.

В целом, на языке C# существуют различные концепции программирования. Он поддерживает делегаты, которые являются указателями на безопасный тип метода. Индексатор позволяет индексировать объект как массив. Кроме того, есть также свойства LINQ и многие другие функции.

Что такое Java

Подобно C#, Java также является языком программирования общего назначения высокого уровня. Он используется для разработки различных приложений, таких как веб, мобильные и высокопроизводительные распределенные системы. Существуют различные версии, доступные на Java. Стандартная версия помогает разрабатывать настольные приложения, в то время как Enterprise Edition (Java EE) используется для веб-разработки, а Java Mobile Edition (Java ME) — для разработки мобильных приложений.

Кроме того, когда программист пишет исходный код на Java, он преобразуется в промежуточный язык, называемый байт-кодом. И этот код работает на любой машине с виртуальной машиной Java (JVM). Таким образом, это делает Java платформно-независимым языком.

Сходства между C# и Java

  • Во-первых, оба поддерживают объектно-ориентированное программирование (ООП).
  • Во-вторых, у обоих есть автоматические сборщики мусора.
  • В-третьих, языки C# и Java поддерживают многопоточность.
  • В-четвертых, оба языка основаны на языке Си.
  • Кроме того, можно подключить приложения C# и Java к системам управления базами данных, таким как MySQL и MSSQL.

В чем разница между C# и Java

Определение

C# — это многоцелевой язык программирования общего назначения, включающий строгую типизацию и поддерживающий объектно-ориентированное программирование. Напротив, Java является языком программирования общего назначения, который является параллельным, объектно-ориентированным и разработан специально, чтобы иметь как можно меньше зависимостей реализации. Таким образом, это принципиальная разница между C # и Java.

Разработчик

C# был разработан Microsoft, тогда как Java была разработана Sun Microsystem.

Рабочая среда программы

Основное различие между C# и Java заключается в том, что программы на C# работают в среде Common Language Runtime (CLR), а программы Java — на виртуальной машине Java (JVM).

Перегрузка оператора

Кроме того, важное отличие между C# и Java состоит в том, что C# поддерживает перегрузку операторов, тогда как Java не поддерживает перегрузку операторов.

Свойства класса

В языке C# есть свойства класса. Однако в Java нет свойств класса.

Делегаты

Кроме того, C# поддерживает делегаты, но Java не поддерживает делегаты.

Основные IDE

Основной IDE для разработки на C# является Visual Studio, а основными IDE для разработки на Java являются Eclipse и NetBeans.

Оператор goto

C# поддерживает оператор goto, и в Java нет оператора goto.

Структуры и объединения

Наконец, C# поддерживает структуры и объединения, в то время как в Java нет концепции структур и объединений.

Заключение

Вкратце, Java и C# являются двумя основными языками программирования высокого уровня. Основное отличие между C# и Java заключается в том, что программы на C# работают в среде Common Language Runtime (CLR), а Java — в виртуальной машине Java (JVM). В целом, программист может выбрать любой из этих языков в соответствии с приложением для разработки.

Отличия java от c

сЪЩЛ РТПЗТБННЙТПЧБОЙС Java УПЪДБО Ч 1995 З. ЖЙТНПК Sun Microsystems (Java — ОБЪЧБОЙЕ МАВЙНПЗП УПТФБ ЛПЖЕ ТБЪТБВПФЮЙЛПЧ). пУОПЧОБС ГЕМШ — УПЪДБФШ ОЕУМПЦОЩК СЪЩЛ ДМС РТПЗТБННЙТПЧБОЙС Ч Internet. пФУАДБ ЧЩФЕЛБАФ ЕЗП ЗМБЧОЩЕ УЧПКУФЧБ.

рТЙНЕЮБОЙЕ. дБМЕЕ ВХДЕФ РПЛБЪБОП, ЮФП Java — ЧЕУШНБ РТЙЧМЕЛБФЕМШОЩК СЪЩЛ ДМС ДМС ОПЧПЙУРЕЮЕООЩИ РТПЗТБННЙУФПЧ-«ЮБКОЙЛПЧ». рТПЖЕУУЙПОБМШОЩИ РТПЗТБННЙУФПЧ (a-la д. лОХФ) Ч ОЕН НПЗХФ РТЙЧМЕЮШ Ч ПУОПЧОПН УТЕДУФЧБ УПЪДБОЙС УЙУФЕНОПЗП-ОЕЪБЧЙУЙНПЗП ЗТБЖЙЮЕУЛПЗП ЙОФЕТЖЕКУБ РПМШЪПЧБФЕМС.

пУОПЧОЩЕ ЬМЕНЕОФЩ СЪЩЛБ — ПВЯЕЛФЩ , СЧМСАЭЙЕУС ЬЛЪЕНРМСТБНЙ ЛМБУУПЧ. лМБУУ — УПЧПЛХРОПУФШ ДБООЩИ Й НЕФПДПЧ (ЖХОЛГЙК, РТПГЕДХТ) ПВТБВПФЛЙ ЬФЙИ ДБООЩИ. лМБУУЩ ПТЗБОЙЪПЧБОЩ Ч ЙЕТБТИЙА Ч ЧЙДЕ «УФТПЗП» ДЕТЕЧБ (НОПЦЕУФЧЕООПЗП ОБУМЕДПЧБОЙС Ч ДХИЕ C++ Ч Java ОЕФ). лПТОЕН ЙЕТБТИЙЙ УМХЦЙФ ЛМБУУ Object. оЕПВЯЕЛФЩ Ч Java — ЬФП ФПМШЛП РТПУФЩЕ ЮЙУМПЧЩЕ, УЙНЧПМШОЩЕ Й ВХМЕЧЩ ФЙРЩ. мАВБС РТПЗТБННБ Ч Java — ЬФП ЛМБУУ (ОБРТЙНЕТ, У НЕФПДПН main ДМС РТЙМПЦЕОЙС). еДЙОЙГЕК ЛПНРЙМСГЙЙ Й ЧЩРПМОЕОЙС ФБЛЦЕ СЧМСЕФУС ЛМБУУ.

лМБУУЩ Ч Java ПВЯЕДЙОЕОЩ Ч РБЛЕФЩ (package), ПВМЕЗЮБАЭЙЕ ТБЪТБВПФЛХ РТПЗТБНН ФПК ЙМЙ ЙОПК ЖХОЛГЙПОБМШОПУФЙ. пВЩЮОП Ч РБЛЕФ РПРБДБАФ ЛМБУУЩ ЙЪ ТБЪОЩИ ЧЕФЧЕК ДЕТЕЧБ ЙЕТБТИЙЙ ЛМБУУПЧ. рТЙНЕТЩ РБЛЕФПЧ: java.io — ЛМБУУЩ ЧЧПДБ-ЧЩЧПДБ; java.awt — ЛМБУУЩ ЛПНРПОЕОФПЧ ЗТБЖЙЮЕУЛПЗП ЙОФЕТЖЕКУБ РПМШЪПЧБФЕМС; java.net — ЛМБУУЩ ДМС ПТЗБОЙЪБГЙЙ УЕФЕЧПЗП ЧЪБЙНПДЕКУФЧЙС.

йУИПДОЩК ФЕЛУФ РТПЗТБННЩ (ЛМБУУБ) ПВТБВБФЩЧБЕФУС ЛПНРЙМСФПТПН Java (javac), ПДОБЛП, Ч ПФМЙЮЙЕ ПФ ФТБДЙГЙПООЩИ ЛПНРЙМСФПТПЧ (ФБЛЙИ, ЛБЛ C Й C++), ПО УПЪДБЕФ ОЕ ПВЯЕЛФОЩК ЖБКМ (ОБРТЙНЕТ, ЖПТНБФБ ELF), УПДЕТЦБЭЙК НБЫЙООЩЕ ЛПНБОДЩ, Б ЖБКМ У РПУМЕДПЧБФЕМШОПУФША ВБКФ-ЛПДПЧ . оБ ЬФБРЕ ЧЩРПМОЕОЙС РТПЗТБННЩ ВБКФ-ЛПДЩ УЮЙФЩЧБАФУС Й ЙОФЕТРТЕФЙТХАФУС ЧЙТФХБМШОПК Java-НБЫЙОПК (JVM — Java Virtual Machine). фБЛЙН ПВТБЪПН, ПФЛПНРЙМЙТПЧБООБС Java-РТПЗТБННБ НПЦЕФ ВЩФШ ЧЩРПМОЕОБ ОБ ФЕИ ЧЩЮЙУМЙФЕМШОЩИ БТИЙФЕЛФХТБИ, ДМС ЛПФПТЩИ ТЕБМЙЪПЧБОБ JVM (Ч ОБУФПСЭЕЕ ЧТЕНС УРЕЛФТ ФБЛЙИ ЧЩЮЙУМЙФЕМШОЩИ УТЕДУФЧ — ПФ УХРЕТ-ьчн ДП НПВЙМШОЩИ ФЕМЕЖПОПЧ).

рТЙНЕЮБОЙЕ. оЙ ЮФП ОЕ ЪБРТЕЭБЕФ JVM ДМС ЧЩРПМОЕОЙС Java-РТПЗТБННЩ ПФЛПНРЙМЙТПЧБФШ ЕЕ ВБКФ-ЛПДЩ Ч НБЫЙООЩЕ ЛПНБОДЩ.

пЗТПНОЩК ЧЛМБД Ч РЕТЕОПУЙНПУФШ Java-РТПЗТБНН ЧОПУЙФ ОЕЪБЧЙУЙНПУФШ ПФЛПНРЙМЙТПЧБООЩИ ВБКФ-ЛПДПЧ ПФ БТИЙФЕЛФХТЩ ЧЩЮЙУМЙФЕМШОЩИ УТЕДУФЧ ЙУРПМОЕОЙС. оП Java ЙДЕФ ДБМШЫЕ, ПВЕУРЕЮЙЧБС ПФУХФУФЧЙЕ ЪБЧЙУСЭЙИ ПФ ТЕБМЙЪБГЙЙ БУРЕЛФПЧ Ч УРЕГЙЖЙЛБГЙЙ СЪЩЛБ. оБРТЙНЕТ, ЛБЛ НЩ ЪОБЕН, Ч у (Й C++) РЕТНЕООБС ФЙРБ int НПЦЕФ ЙНЕФШ ТБЪНЕТ 2, 4 ЙМЙ 8 ВБКФ, РЕТЕНЕООБС ФЙРБ char НПЦЕФ ВЩФШ ВЕЪ- ЙМЙ ЪОБЛПЧПК, Ч Java ЦЕ СЧОП Й УФТПЗП ПРТЕДЕМЕОЩ ТБЪНЕТЩ Й УЧПКУФЧБ ЛБЦДПЗП РТПУФПЗП ФЙРБ ДБООЩИ. фБЛЦЕ УХЭЕУФЧЕООП, ЮФП Java ПВЕУРЕЮЙЧБЕФ ЕДЙОЩЕ УТЕДУФЧБ УПЪДБОЙС ЗТБЖЙЮЕУЛПЗП ЙОФЕТЖЕКУБ РПМШЪПЧБФЕМС ДМС ТБЪОЩИ ПРЕТБГЙПООЩИ УТЕД (UNIX, Windows, MacOS), РТПРПЧЕДХАЭЙИ УПЧЕТЫЕООП РТПФЙЧПРПМПЦОЩЕ ЙДЕПМПЗЙЙ ЗТБЖЙЮЕУЛПЗП ЙОФЕТЖЕКУБ.

рТЙ РПДЗПФПЧЛЕ Й ЪБРХУЛЕ Java-РТПЗТБНН ОБ ЧЩРПМОЕОЙЕ ПФУХФУФЧХЕФ ФТБДЙГЙПООЩК ЬФБР ЛПНРПОПЧЛЙ — ПВЯЕДЙОЕОЙС ЛПДБ РТПЗТБННЩ У ЛПДПН ЧУЕИ ЙУРПМШЪХЕНЩИ ЕЕ ЖХОЛГЙК ( Ч C) Й ЛМБУУПЧ (Ч C++). йОФЕРТЕФБФПТ Java (JVM) ЪБЗТХЪЛХ ОЕПВИПДЙНЩИ ЛМБУУПЧ ПУХЭЕУФЧМСЕФ ДЙОБНЙЮЕУЛЙ Ч НПНЕОФ ЧПЪОЙЛОПЧЕОЙС РПФТЕВОПУФЙ Ч ОЙИ. вПМЕЕ ФПЗП, Ч Java УХЭЕУФЧХЕФ ЧПЪНПЦОПУФШ (РБЛЕФ java.lang.reflect) ДЙОБНЙЮЕУЛЙ РПМХЮБФШ ЙУЮЕТРЩЧБАЭХА ЙОЖПТНБГЙА П МАВПН ЛМБУУЕ (РЕТЕНЕООЩЕ, ЛПОУФТХЛФПТЩ, НЕФПДЩ).

рТЙНЕЮБОЙЕ. оЕПВИПДЙНП, РТБЧДБ, ПФНЕФЙФШ, ЮФП ДЙОБНЙЮЕУЛПЕ УЧСЪЩЧБОЙЕ — ЬФП, Ч ОБУФПСЭЕЕ ЧТЕНС, УФБОДБТОЩК БФТЙВХФ МАВПК ЧЩЮЙУМЙФЕМШОПК УТЕДЩ (ЧУРПНОЙН «.so» Ч UNIX Й «.dll» Ч Windows).

чП-РЕТЧЩИ, Java РПДДЕТЦЙЧБЕФ УЕФЕЧПК ПВНЕО, ЙУРПМШЪХС ЛБОПОЙЮЕУЛЙК socket -ЙОФЕТЖЕКУ.

чП-ЧФПТЩИ, Java (ЮЕТЕЪ РБЛЕФ java.net) ПВЕУРЕЮЙЧБЕФ УТЕДУФЧБ ЧЩУПЛПХТПЧОЕЧПЗП ДПУФХРБ РП УЕФЙ, РПЪЧПМСАЭЙЕ, ОБРТЙНЕТ, ЮЙФБФШ ХДБМЕООЩК ЖБКМ ФБЛ ЦЕ РТПУФП, ЛБЛ Й ЖБКМ МПЛБМШОЩК.

ч-ФТЕФШЙИ (ЮФП ОБЙВПМЕЕ ЙОФЕТЕУОП), УТЕДУФЧБ ДЙОБНЙЮЕУЛПК ЪБЗТХЪЛЙ ЛМБУУПЧ, РПЪЧПМСАФ JVM ЪБЗТХЦБФШ Й ЪБРХУЛБФШ ОБ ЧЩРПМОЕОЙЕ НЕФПДЩ ХДБМЕООЩИ ПВЯЕЛФПЧ. дПУФЙЗБЕФУС ФБЛБС ЧПЪНПЦОПУФШ ЙУРПМШЪПЧБОЙЕН УТЕДУФЧ RMI (Remote Method Invocation), УПВТБООЩИ Ч РБЛЕФЩ java.rmi.*.

Java — РТПУФПК СЪЩЛ, РПУЛПМШЛХ ПО МЕЗПЛ ДМС ЙЪХЮЕОЙС, ЮФП ПВЯСУОСЕФУС ДЧХНС ЖБЛФПТБНЙ: ОЕВПМШЫПЕ ЛПМЙЮЕУФЧП СЪЩЛПЧЩИ ЛПОУФТХЛГЙК ( ЮФП ЧБЦОП ДМС «ЮБКОЙЛПЧ»), «РПИПЦЕУФШ» ОБ УБНЩЕ ХРПФТЕВМСЕНЩЕ СЪЩЛЙ C Й C++ (ЮФП ЧБЦОП ДМС НЙЗТБГЙЙ ОБ Java). оБРТЙНЕТ, Ч Java ОЕФ ЛПОУФТХЛГЙК struct Й union (ЙЪ C), Ф.Л. ПО ПВЯЕЛФОП-ПТЙЕОФЙТПЧБООЩК СЪЩЛ, ОП Ч ОЕН ОЕФ НОПЦЕУФЧЕООПЗП ОБУМЕДПЧБОЙС Й РЕТЕЗТХЪЛЙ ПРЕТБГЙК (ЙЪ C++). оП УБНПЕ ЗМБЧОПЕ — Ч Java ОЕФ ХЛБЪБФЕМЕК!

тБЪТБВПФЮЙЛЙ СЪЩЛБ Java УФБЧЙМЙ РЕТЕД УПВПК ЪБДБЮХ РПЧЩУЙФШ ОБДЕЦОПУФШ (ХУФПКЮЙЧПУФШ) ТБЪТБВБФЩЧБЕНЩИ У ЕЗП РПНПЭША РТПЗТБНН. дМС ЬФПЗП ПОЙ, Ч ЮБУФОПУФЙ, УФТПЗП ФЙРЙЪЙТПЧБМЙ СЪЩЛ Й РТЕДХУНПФТЕМЙ УТЕДУФЧБ ЛПОФТПМС ЧЩРПМОЕОЙС ТСДБ ДЕКУФЧЙК (ОБРТЙНЕТ, ДПРХУФЙНПУФШ РТЙЧЕДЕОЙС ФЙРПЧ ДБООЩИ). йУЛМАЮЕОЙЕ ЙЪ СЪЩЛБ ХЛБЪБФЕМЕК Й БТЙЖНЕФЙЮЕУЛЙИ ПРЕТБГЙК ОБД ОЙНЙ ХУФТБОЙМП Й ГЕМЩК ЛМБУУ ПЫЙВПЛ, УЧСЪБООЩК У ОЕРТБЧЙМШОЩИ ЙИ РТЙНЕОЕОЙЕН.

бЧФПНБФЙЮЕУЛЙК УВПТ НХУПТБ (garbage collection) РТЕДПФЧТБЭБЕФ «ХФЕЮЛЙ» РБНСФЙ. рПЧЩЫЕОЙА ХУФПКЮЙЧПУФЙ РТПЗТБНН ОБ Java УРПУПВУФЧХЕФ ФБЛЦЕ ЙУРПМШЪПЧБОЙЕ ЛПОУФТХЛГЙЙ try/catch/finally, РПЪЧПМСАЭЕК УЗТХРРЙТПЧБФШ ЛПД, ПФЧЕФУФЧЕООЩК ЪБ ПВТБВПФЛХ ЙУЛМАЮЕОЙК (exceptions), Ч ФПН ЮЙУМЕ ПЫЙВПЛ ЧЩРПМОЕОЙС, Ч ПДОПН НЕУФЕ РТПЗТБННЩ.

пВЕУРЕЮЕОЙЕ ЧЩУПЛПЗП ХТПЧОС ВЕЪПРБУОПУФЙ РТПЗТБНН — ПУОПЧОПЕ ФТЕВПЧБОЙЕ Л СЪЩЛХ УЕФЕЧПЗП РТПЗТБННЙТПЧБОЙС, ЙУРПМШЪХЕНПНХ ДМС ЙИ ТБЪТБВПФЛЙ. Java ТЕБМЙЪХЕФ ОЕУЛПМШЛП ХТПЧОЕК ЪБЭЙФЩ ПФ РТЕДОБНЕТЕООПЗП ЙМЙ ОЕХНЩЫМЕООПЗП ОБТХЫЕОЙС ТБВПФЩ ГЕМЕЧПК ЧЩЮЙУМЙФЕМШОПК УЙУФЕНЩ.

рЕТЧЩК ХТПЧЕОШ — ЬФП ЙУЛМАЮЕОЙЕ ЧПЪНПЦОПУФЙ РТСНПЗП ДПУФХРБ Л РБНСФЙ Ч РТПЗТБННБИ ОБ Java ЮЕТЕЪ ХЛБЪБФЕМЙ.

чФПТПК ХТПЧЕОШ — РТПЧЕТЛБ ОБ ЛПТТЕЛФОПУФШ ВБКФ-ЛПДБ, ЪБЗТХЦБЕНПЗП Ч ЧЙТФХБМШОХА Java-НБЫЙОХ.

фТЕФЙК ХТПЧЕОШ — ТЕБМЙЪБГЙС НПДЕМЙ «РЕУПЮОЙГЩ» (sandbox). уПЗМБУОП ЬФПК НПДЕМЙ РТПЗТБННЩ, ОЕ ЪБУМХЦЙЧБАЭЙЕ ДПЧЕТЙС (ОБРТЙНЕТ, ЪБЗТХЦЕООЩЕ РП УЕФЙ БРРМЕФЩ) РПНЕЭБАФУС Ч «РЕУПЮОЙГХ», ЗДЕ ПОЙ НПЗХФ «ЙЗТБФШ», ОЕ ОБОПУС ХЭЕТВБ УТЕДЕ Java Й МПЛБМШОПК ПРЕТБГЙПООПК УЙУФЕНЕ. пЮЕЧЙДОЩН РТЙНЕТПН ПЗТБОЙЮЕОЙК «РЕУПЮОЙГЩ» УМХЦЙФ ЪБРТЕФ ДПУФХРБ Л МПЛБМШОПК ЖБКМПЧПК УЙУФЕНЕ. рПДПВОЩЕ ПЗТБОЙЮЕОЙС ОБЛМБДЩЧБАФУС ЛМБУУПН SecurityManager.

у ДТХЗПК УФПТПОЩ, Java-РТПЗТБННЩ (ФЕ ЦЕ БРРМЕФЩ) НПЗХФ УОБВЦБФШУС ЬМЕЛФТПООЩНЙ РПДРЙУСНЙ ДПЧЕТЕООЩИ МЙГ Й ПТЗБОЙЪБГЙК, ЮФП РПЪЧПМСЕФ РПМОПУФША ЙМЙ ЮБУФЙЮОП УОЙНБФШ ПЗТБОЙЮЕОЙС ОБ ЙИ ЧЩРПМОЕОЙЕ.

оБДП ФБЛЦЕ ПФНЕФЙФШ, ЮФП УТЕДУФЧ ЪБЭЙФЩ ПФ DOS-БФБЛ (ПФЛБЪ Ч ПВУМХЦЙЧБОЙЙ) Ч Java ОЕФ.

лПОЕЮОП ЦЕ, РТПЗТБННЩ ОБ Java, ЛБЛ ОБ ЙОФЕТРТЕФЙТХЕНПН СЪЩЛЕ, ОЕ НПЗХФ ВЩФШ УФПМШ ЬЛПОПНЙЮОЩ, ЛБЛ ОБ ЛПНРЙМЙТХЕНЩИ C Й C++. пДОБЛП ЛПНРЙМСГЙС Ч ВБКФ-ЛПДЩ ДЕМБЕФ Java-РТПЗТБННЩ ВПМЕЕ ВЩУФТЩНЙ, ЮЕН РТПЗТБННЩ ОБ ДТХЗЙИ ЙОФЕТРТЕФЙТХЕНЩИ СЪЩЛБИ (sh/bash, csh, Tcl Й ДБЦЕ Perl Й PHP). вПМЕЕ ФПЗП, УПЧТЕНЕООЩЕ JVM ПВМБДБАФ УРПУПВОПУФША ЛПНРЙМЙТПЧБФШ ВБКФ-ЛПДЩ Ч НБЫЙООЩЕ ЛПНБОДЩ ГЕМЕЧПК ьчн «ОБ МЕФХ», Б ЬФП ХЦЕ ДЕМБЕФ УЛПТПУФШ ЧЩРПМОЕОЙС Java-РТПЗТБНН УПРПУФБЧЙНПК УП УЛПТПУФША РТПЗТБНН, ОБРЙУБООЩИ ОБ C Й C++. лТПНЕ ЬФПЗП Java ПВЕУРЕЮЙЧБЕФ ЧПЪНПЦОПУФШ ДМС ЛТЙФЙЮЕУЛЙИ ХЮБУФЛПЧ РТПЗТБННЩ УПЪДБЧБФШ ЛПД ОБ C ЙМЙ C++.

у ДТХЗПК УФПТПОЩ, Java — СЪЩЛ ДМС УПЪДБОЙС УЕФЕЧЩИ ЙОФЕТБЛФЙЧОЩИ РТПЗТБНН Й БРРМЕФПЧ (Ч ЛПФПТЩИ МШЧЙОБС ДПМС ЧТЕНЕОЙ ХИПДЙФ ОБ ПЦЙДБОЙЕ ПФЧЕФПЧ РП УЕФЙ ЙМЙ ТЕБЛГЙЙ РПМШЪПЧБФЕМС). ъДЕУШ РТПЙЪЧПДЙФЕМШОПУФШ JVM ЧРПМОЕ БДЕЛЧБФОБ ТЕЫБЕНПК ЪБДБЮЕ.

рТЙ РТПЗТБННЙТПЧБОЙЙ ОБ C Й C++ НОПЗПРПФПЮОПУФШ ЪБДБЮЙ ПВЕУРЕЮЙЧБЕФУС УТЕДУФЧБНЙ ГЕМЕЧПК пу Й ВЙВМЙПФЕЛПК УППФЧЕФУФЧХАЭЙИ УЙУФЕНОЩИ УЙУФЕНОЩИ ЧЩЪПЧПЧ Й ЖХОЛГЙК. ч Java РПДДЕТЦЛБ НОПЗПРПФПЮОПУФЙ ТЕБМЙЪПЧБОБ СЪЩЛПЧЩНЙ УТЕДУФЧБНЙ. фБЛ, Ч РБЛЕФЕ java.lang УПДЕТЦЙФУС ЛМБУУ Thread, ПВЕУРЕЮЙЧБАЭЙК НЕФПДЩ ЪБРХУЛБ Й ЪБЧЕТЫЕОЙС РПФПЛПЧ. йНЕЕФУС ФБЛЦЕ ЛПОУФТХЛГЙС synchronized, РПЪЧПМСАЭБС ПФНЕЮБФШ ХЮБУФЛЙ РТПЗТБННЩ Й ГЕМЩЛ НЕФПДЩ, ЛПФПТЩЕ ДПМЦОЩ ПДОПЧТЕНЕООП ЧЩРПМОСФШУС ФПМШЛП ПДОЙН РПФПЛПН.

рТЙНЕЮБОЙЕ . уПЪДБОЙЕ СЛПВЩ РБТБММЕМШОП ЧЩРПМОСАЭЙИУС РПФПЛПЧ — ФТЙЧЙБМШОБС ЪБДБЮБ Ч МАВПК УТЕДЕ РТПЗТБННЙТПЧБОЙС. рТПВМЕНБ — ЪБУФБЧЙФШ ЙИ ТЕБМШОП ЧЩРПМОСФШУС РБТБМММЕМШОП Ч НОПЗПРТПГЕУУПТОПК УЙУФЕНЕ. Б ХЦ ЛХДБ ВПМЕЕ УМПЦОБС РТПВМЕНБ — ЬЖЖЕЛФЙЧОП ЙИ ЪБУЙОИТПОЙЪПТБЧБФШ (ФХФ ПФ ЧЪБЙНПЙУЛМАЮБАЭЙИ ВМПЛЙТПЧПЛ, УЕНБЖПТПЧ Й Ф. Р. ОЙЛХДБ ОЕ ДЕФШУС).

еУФЕУФЧЕООП, ЮФП ЖХОДБНЕОФБМШОПЕ ПФМЙЮЙЕ Ч ФПН, ЮФП Java — ЬФП ПВЯЕЛФОП-ПТЙЕОФЙТПЧБООЩК СЪЩЛ. оП пп-УЧПКУФЧБ Java ПВУХДЙН РПЪЦЕ, УТБЧОЙЧБС ЕЗП У СЪЩЛПН C++.

Java-РТПЗТБННБ УПУФПЙФ ЙЪ ПДОПЗП ЙМЙ ОЕУЛПМШЛЙИ ПРТЕДЕМЕОЙК ЛМБУУПЧ, ТБЪНЕЭЕООЩИ Ч ПДОПН ЙМЙ ОЕУЛПМШЛЙИ ЖБКМБИ (УХЖЖЙЛУ ЙНЕОЙ ЖБКМБ — .java). дМС ЛПНРЙМСГЙЙ РТПЗТБНН ЙУРПМШЪХЕФУС java-ЛПНРЙМСФПТ javac, ОБРТЙНЕТ,
javac FirstExample.java

ч ТЕЪХМШФБФЕ ДМС ЛБЦДПЗП ЛМБУУБ ЙЪ ЙУИПДОПЗП ЙЪ ЙУИПДОПЗП ЖБКМБ УПЪДБЕФУС ЖБКМ ЛМБУУБ, УПДЕТЦБЭЙК ВБКФ-ЛПДЩ ЛМБУУБ. пУОПЧБ ЙНЕОЙ ЖБКМБ ЛМБУУБ УПЧРБДБЕФ У ЙНЕОЕН ЛМБУУБ, Л ОЕК ДПВБЧМСЕФУС УХЖЖЙЛУ .class.

пДЙО ЙЪ ЛМБУУПЧ РТПЗТБННЩ ДПМЦЕО ВЩФШ ПФЛТЩФЩН (public) ЛМБУУПН Й УПДЕТЦБФШ НЕФПД main, У ЛПФПТПЗП ОБЮЙОБЕФУС ЧЩРПМОЕОЙЕ РТПЗТБННЩ.

дМС ЧЩРПМОЕОЙС РТПЗТБННЩ ОЕПВИПДЙНП ЪБРХУФЙФШ ЙОФЕТРТЕФБФПТ java, ХЛБЪБЧ ЕНХ ЙНС ЛМБУУБ, УПДЕТЦБЭЕЗП НЕФПД main, ОБРТЙНЕТ,
java FirstExample

оЕПВИПДЙНП ЪБНЕФЙФШ, ЮФП БРРМЕФ Java — ЬФП ОЕ РТЙМПЦЕОЙЕ, Б ЛМБУУ Java, ЛПФПТЩК ДЙОБНЙЮЕУЛЙ ЪБЗТХЦБЕФУС Й ЧЩРПМОСЕФУС ЧОХФТЙ ХЦЕ ЪБРХЭЕООПЗП РТЙМПЦЕОЙС, ФБЛПЗП ЛБЛ appletviewer ЙМЙ web-ВТПХЪЕТ.

Java-РТПЗТБННБ ЪБЧЕТЫБЕФ УЧПА ТБВПФХ ПРЕТБФПТПН return Ч НЕФПДЕ main ЙМЙ РПУМЕ ЧЩРПМОЕОЙС РПУМЕДОЕЗП ПРЕТБФПТБ НЕФПДБ main. пДОБЛП, НОПЗПРПФПЛПЧБС РТПЗТБННБ ЪБЛБОЮЙЧБЕФУС У ЪБЧЕТЫЕОЙЕН РПУМЕДОЕЗП РПФПЛБ.

рТПФПФЙР НЕФПДБ main

рТПФПФЙР ЖХОЛГЙЙ main Ч C/C++ ЙНЕЕФ УМЕДХАЭЙК ЧЙД: ЗДЕ argc — ЛПМЙЮЕУФЧП БТЗХНЕОФПЧ ЛПНБОДОПК УФТПЛЙ, argv — НБУУЙЧ ХЛБЪБФЕМЕК ОБ БТЗХНЕОФЩ ЛПНБОДОПК УФТПЛЙ, envp — НБУУЙЧ ХЛБЪБФЕМЕК ОБ УТЕДХ ЧЩРПМОЕОЙС (НОПЦЕУФЧП РБТ » ЙНС = ЪОБЮЕОЙЕ «).

нЕФПД main Ч Java ЙНЕЕФ УМЕДХАЭЙК РТПФПФЙР: ЗДЕ argv — ЬФП НБУУЙЧ УФТПЛ, РТЕДУФБЧМСАЭЙИ УПВПК БТЗХНЕОФЩ ЛПНБОДОПК УФТПЛЙ ЧЩЪПЧБ ЙОФЕТРТЕФБФПТБ Й ТБУРПМБЗБАЭЙИУС Ч ОЕК РПУМЕ ЙНЕОЙ ЛМБУУБ. рПДЮЕТЛОЕН, ЮФП argv[0] Ч Java — ЬФП ОЕ ЙНС ЛМБУУБ, ЛБЛ НПЗ ВЩ ПЦЙДБФШ РТПЗТБННЙУФ у/у++, Б ДЕКУФЧЙФЕМШОП РЕТЧЩК БТЗХНЕОФ НЕФПДБ.

рТЙЧЕДЕООБС ОЙЦЕ Java-РТПЗТБННБ ТЕБМЙЪХЕФ ЖХОЛГЙА ЛПНБОДЩ echo ЙЪ UNIX — ЧЩЧПДЙФ УЧПЙ БТЗХНЕОФЩ

оЕПВИПДЙФШ ПВТБФЙФШ ЧОЙНБОЙЕ, ЮФП НЕФПД main ОЕ РПЪЧПМСЕФ ЧЕТОХФШ ЛБЛПК-МЙВП ЛПД ЪБЧЕТЫЕОЙС У РПНПЭША ПРЕТБФПТБ return (УН. void Ч РТПФПФЙРЕ). рТЙ ОЕПВИПДЙНПУФЙ ЬФП НПЦОП УДЕМБФШ, ЧЩЪЧБЧ НЕФПД System.exit (), ЛБЛ ЬФП РПЛБЪБОП Ч РТЙНЕТЕ. нЕФПД System.exit () ОЕНЕДМЕООП Й ВЕЪХУМПЧОП РТЕЛТБЭБЕФ ТБВПФХ РТПЗТБННЩ.

йЪ Java-РТПЗТБННЩ (Ч ПФМЙЮЙЕ ПФ C/C++-РТПЗТБНН) РЕТЕНЕООЩЕ УТЕДЩ (environment), ЧП НОПЗПН ПРТЕДЕМСЕНЩЕ пу, ОЕДПУФХРОЩ. ч ЛБЮЕУФЧЕ БМШФЕТОБФЙЧЩ Ч Java ПРТЕДЕМЕО ОЕЪБЧЙУЙНЩК ПФ ЧЩЮЙУМЙФЕМОПК РМБФЖПТНЩ НЕИБОЙЪН, ОБЪЩЧБЕНЩК УРЙУЛПН УЙУФЕНОЩИ РЕТЕНЕООЩИ (system properties list). дМС РПМХЮЕОЙС ЪОБЮЕОЙС УЙУФЕНОПК РЕТЕНЕООПК ЙУРПМШЪХЕФУС НЕФПД System.getProperty(), ОБРТЙНЕТ:

Java-ЙОФЕТРТЕФБФПТ РТЙ ЪБРХУЛЕ БЧФПНБФЙЮЕУЛЙ ПРТЕДЕМСЕФ ТСД УФБОДБТФОЩИ УЙУФЕНОЩИ РЕТЕНЕООЩИ. рПМШЪПЧБФЕМШ ЙНЕЕФ ЧПЪНПЦОПУФШ ДПРПМОЙФЕМШОП ПРТЕДЕМЙФШ УПВУФЧЕООЩЕ УЙУФЕНОЩЕ РЕТЕНЕООЩЕ, ЙУРПМШЪХС ПРГЙА -D ЛПНБОДОПК УФТПЛЙ ЙОФЕТРТЕФБФПТБ, ОБРТЙНЕТ

пВМБУФЙ ЧЙДЙНПУФЙ ЙНЕО

сЧМССУШ СЪЩЛПН, РПДДЕТЦЙЧБАЭЙН ДЙОБНЙЮЕУЛХА ЪБЗТХЪЛХ НЕФПДПЧ ЮЕТЕЪ Internet, Java ЪБВПФЙФУС П РТЕДПФЧТБЭЕОЙЙ ЛПОЖМЙЛФПЧ ЙНЕО. рПЬФПНХ, Ч ЮБУФОПУФЙ, Ч Java ОЕФ ЗМПВБМШОЩИ РЕТЕНЕООЩИ , ЧУЕ РЕТЕНЕООЩЕ Й ЖХОЛГЙЙ (НЕФПДЩ) — ЮБУФЙ ЛМБУУБ, л ФПНХ ЦЕ, ЛБЦДЩК ЛМБУУ — ЮБУФШ РБЛЕФБ.

оБ ЛБЦДХА РЕТЕНЕООХА ЙМЙ НЕФПД Ч Java УУЩМБАФУС У РПНПЭША РПМОПЗП ЙНЕОЙ, УПУФПСЭЕЗП ЙЪ ЙНЕОЙ РБЛЕФБ, ЙНЕОЙ ЛМБУУБ Й ЙНЕОЙ ЮМЕОБ ЛМБУУБ, ТБЪДЕМЕООЩИ ФПЮЛПК. йНС РБЛЕФБ ПВЩЮОП УПУФПЙФ ЙЪ НОПЗЙИ УПУФБЧМСАЭЙИ, ФБЛЦЕ ТБЪДЕМЕООЩИ ФПЮЛБНЙ. тБЪТБВПФЮЙЛЙ Java ДМС ПВЕУРЕЮЕОЙС ХОЙЛБМШОПУФЙ ЙНЕО РБЛЕФПЧ Ч ТБНЛБИ Internet РТЕДМБЗБАФ ЙУРПМШЪПЧБФШ Ч ЙНЕОБИ РБЛЕФПЧ ДПНЕООЩЕ ЙНЕОБ ПТЗБОЙЪБГЙК-ТБЪТБВПФЮЙЛПЧ РБЛЕФПЧ, ОБРТЙНЕТ

жБКМЩ ЛМБУУПЧ ИТБОСФУС Ч ЛБФБМПЗБИ, ПРТЕДЕМСЕНЩИ ЙНЕОЕН РБЛЕФБ. оБРТЙНЕТ, ЧУЕ ЙЗТПЧЩЕ ЛМБУУЩ УФХДЕОФБ йЧБОПЧБ ИТБОСФУС Ч ЛБФБМПЗЕ У ПФОПУЙФЕМШОЩН ЙНЕОЕН

дМС ПРТЕДЕМЕОЙС РПМОПЗП РХФЕЧПЗП ЙНЕОЙ ЛБФБМПЗБ, УПДЕТЦБЭЕЗП ЖБКМЩ ЛМБУУПЧ РБЛЕФБ, Java-ЙОФЕРТЕФБФПТ java ЙУРПМШЪХЕФ УЙУФЕНОХА РЕТЕНЕООХА CLASSPATH, ХУФБОБЧМЙЧБФШ ЛПФПТХА НПЦОП, ОБРТЙНЕТ, Ч bash, ЛПНБОДПК

рХФЙ Л УЙУФЕНОЩН ЛМБУУБН ЧЛМАЮБФШ Ч CLASSPATH ОЕФ ОЕПВИПДЙНПУФЙ, ФБЛ ЛБЛ ЙОФЕТРТЕФБФПТ Java ЬФЙ РХФЙ РТЙУПЕДЙОСЕФ Л УРЙУЛХ УРТБЧБ УБНПУФПСФЕМШОП.

рПИПЦХА, ОП ОЕ УПЧУЕН БОБМПЗЙЮОХА ТПМШ ЙЗТБЕФ РБТБНЕФТ -classpath ЙОФЕТРТЕФБФПТБ java.

дМС ЧЛМАЮЕОЙС ЛМБУУБ Ч РБЛЕФ ЙУРПМШЪХЕФУС ПРЕТБФПТ ЛПФПТЩК ПВСЪБФЕМШОП ДПМЦЕО ВЩФШ РЕТЧЩН ПРЕТБФПТПН ЙУИПДОПЗП ЖБКМБ. еУМЙ ПРЕТБФПТ package ПФУХФУФЧХЕФ Ч ЙУИПДОПН ФЕЛУФЕ ЛМБУУБ, ФП ЛМБУУ УЮЙФБЕФУС РТЙОБДМЕЦБЫЙН РБЛЕФХ «РП ХНПМЮБОЙА», ЖБКМЩ ЛМБУУПЧ ЛПФПТПЗП ТБЪНЕЭБАФУС Ч ФЕЛХЭЕН ЛБФБМПЗЕ, ЮФП ХДПВОП ДМС ТБЪТБВПФЛЙ.

ъБ ОЕПВСЪБФЕМШОЩН ПРЕТБФПТПН package НПЦЕФ УМЕДПЧБФШ МАВПЕ ЛПМЙЮЕУФЧП ПРЕТБФПТПЧ import, ЙНЕАЭЙИ ДЧЕ ЖПТНЩ ЪБРЙУЙ:

оБЪОБЮЕОЙЕ ПРЕТБФПТБ import — ДБФШ ЧПЪНПЦОПУФШ ЙУРПМШЪПЧБОЙС Ч ФЕЛУФЕ РТПЗТБНН «ХЛПТПЮЕООЩИ» ЙНЕО ЛМБУУПЧ Й ЙИ ЮМЕОПЧ (ВЕЪ РТЕЖЙЛУОПК ЮБУФЙ Ч ЧЙДЕ ЙНЕОЙ РБЛЕФБ). чБЦОП РПОЙНБФШ, ЮФП ПРЕТБФПТ import ОЙЛБЛПК ЪБЗТХЪЛЙ ПФДЕМШОЩИ ЛМБУУПЧ ЙМЙ РБЛЕФПЧ ГЕМЙЛПН ЪБ УПВПК ОЕ ЧМЕЮЕФ (Ч ЬФПН ЕЗП ПФМЙЮЙЕ ПФ #include Ч C Й C++). еЭЕ ТБЪ — ЛМБУУЩ Ч Java ЪБЗТХЦБАФУС ДЙОБНЙЮЕУЛЙ ФПМШЛП Ч НПНЕОФ ЧПЪОЙЛОПЧЕОЙС РПФТЕВОПУФЙ Ч ОЙИ !

дПУФХР Л РБЛЕФБН, ЛМБУУБН Й ЮМЕОБН ЛМБУУПЧ ХРТБЧМСЕФУС ЙУРПМШЪПЧБОЙЕН ЛМАЮЕЧЩИ УМПЧ-НПДЙЖЙЛБФПТПЧ public (ПФЛТЩФЩК), protected (ЪБЭЙЭЕООЩК) Й private (ЪБЛТЩФЩК) Й ТЕЗМБНЕОФЙТХЕФУС УМЕДХАЭЙНЙ РТБЧЙМБНЙ.

  • рБЛЕФ ДПУФХРЕО, ЕУМЙ ДПУФХРОЩ УППФЧЕФУФЧХАЭЙЕ ЖБКМЩ Й ЛБФБМПЗЙ (ОБРТЙНЕТ, ЕУМЙ МПЛБМШОЩЕ ЖБКМЩ ЙНЕАФ УППФЧЕФУФЧХАЭЙЕ ТБЪТЕЫЕОЙС ОБ ЮФЕОЙЕ ЙМЙ НПЗХФ ВЩФШ ЪБЗТХЦЕОЩ РП УЕФЙ).
  • лБЦДЩК ЛМБУУ Й ЙОФЕТЖЕКУ РБЛЕФБ ДПУФХРЕО ЧУЕН ПУФБМШОЩН ЛМБУУБН Й ЙОФЕТЖЕКУБН ФПЗП ЦЕ РБЛЕФБ. оЕЧПЪНПЦОП ПРТЕДЕМЙФШ ЛМБУУЩ Java, ЧЙДЙНЩЕ ФПМШЛП Ч ПДОПН ЖБКМЕ У ЙУИПДОЩН ФЕЛУФПН.
  • лМБУУ, ПВЯСЧМЕООЩК ЛБЛ public Ч ПДОПН РБЛЕФЕ, ДПУФХРЕО ЙЪ ДТХЗПЗП РБЛЕФБ, ЕУМЙ ДПУФХРЕО УБН РБЛЕФ. лМБУУЩ, ОЕ ПВЯСЧМЕООЩЕ ЛБЛ public, ОЕДПУФХРОЩ ЪБ РТЕДЕМБНЙ ДБООПЗП РБЛЕФБ.
  • юМЕОЩ ЛМБУУБ ДПУФХРОЩ ЙЪ ДТХЗПЗП ЛМБУУБ ФПЗП ЦЕ РБЛЕФБ, ЕУМЙ ПОЙ ОЕ ПВЯСЧМЕОЩ ЛБЛ private. юМЕОЩ ЛМБУУБ, ПВЯСЧМЕООЩЕ ЛБЛ private, ДПУФХРОЩ ФПМШЛП Ч УЧПЕН ЛМБУУЕ.
  • юМЕО ЛМБУУБ A ДПУФХРЕО ЙЪ ЛМБУУБ B, ЧИПДСЭЕЗП Ч ДТХЗПК РБЛЕФ, Ч ФЕИ УМХЮБСИ, ЛПЗДБ ЛМБУУ A, ТБЧОП ЛБЛ Й ЕЗП ЮМЕО, ПВЯСЧМЕОЩ ЛБЛ public ЙМЙ ЛПЗДБ ЛМБУУ A ПВЯСЧМЕО ЛБЛ public, ЮМЕО ЛМБУУБ ПВЯСЧМЕО ЛБЛ protected, Б ЛМБУУ B СЧМСЕФУС РПДЛМБУУПН ЛМБУУБ A.
  • чУЕ ЮМЕОЩ ЛМБУУБ ЧУЕЗДБ ДПУФХРОЩ ЧОХФТЙ ЛМБУУБ.

ч Java РПДДЕТЦЙЧБАФУС ЛПННЕОФБТЙЙ ФТЕИ ЧЙДПЧ.

  1. ч УФЙМЕ СЪЩЛБ C (ПФ «/*» ДП «*/»).
  2. ч УФЙМЕ СЪЩЛБ C++ (ПФ «//» ДП «\n»).
  3. уРЕГЙБМШОЩЕ ЛПННЕОФБТЙЙ «ДМС ДПЛХНЕОФЙТПЧБОЙС» (ПФ «/**» ДП «*/»), ЙУРПМШЪХЕНЩЕ РТПЗТБННПК javadoc ДМС УПЪДБОЙС РТПУФПК ЙОФЕТБЛФЙЧОПК ДПЛХНЕОФБГЙЙ ЙЪ ЙУИПДОЩИ ЖБКМПЧ ОБ СЪЩЛЕ Java.

ч Java ПФУХФУФЧХЕФ РТЕРТПГЕУУПТ, РПДПВОЩК РТЕРТПГЕУУПТХ cpp Ч C/C++. б ЪОБЮЙФ Й ОЕФ #-ДЙТЕЛФЙЧ ФБЛЙИ, ЛБЛ #define, #include, #ifdef. дЕМП Ч ФПН, ЮФП Ч Java ОЕФ ОЕПВИПДЙНПУФЙ Ч ОЙИ .

ьЛЧЙЧБМЕОФПН ЛПОУФБОФЩ, ПВЯСЧМЕООПК Ч C/C++ ЮЕТЕЪ #define, УМХЦЙФ РЕТЕНЕООБС, ПВЯСЧМЕООБС Ч ЛМБУУЕ Java ЛБЛ static final, ОБРТЙНЕТ java.lang.Math.PI. рТЕЙНХЭЕУФЧБ ФБЛПЗП РПДИПДБ: УФТПЗБС ФЙРЙЪБГЙС ЛПОУФБОФ Й ХОЙЛБМШОПУФШ ЙЕТБТИЙЮЕУЛЙИ ЙНЕО, ЮФП ЙУЛМАЮБЕФ ЛПОЖМЙЛФЩ (ФП ЦЕ PI ОЕМШЪС РЕТЕПРТЕДЕМЙФШ).

нБЛТПУЩ (ДТХЗПЕ ЙУРПМШЪПЧБОЙЕ #define) ЪБНЕОЕОЩ inline-РПДУФБОПЧЛПК, ПУХЭЕУФЧМСЕНПК ЛПНРЙМСФПТПН Java ДМС «ЛПТПФЛЙИ» ЙЕФПДПЧ БЧФПНБФЙЮЕУЛЙ.

оЕОХЦОПУФШ #include ПВЯСУОСЕФУС ДЧХНС ЖБЛФПТБНЙ. чП-РЕТЧЩИ, ЖБКМ ЛМБУУБ (У УХЖЖЙЛУПН .class) ПДОПЧТЕНЕООП СЧМСЕФУС Й ПВЯСЧМЕОЙЕН ЛМБУУБ, Й ЕЗП ПРТЕДЕМЕОЙЕН (ТЕБМЙЪБГЙЕК), ЪОБЮЙФ, ПФРБДБЕФ ОЕПВИПДЙНПУФШ Ч ЪБЗБМПЧПЮОЩИ h-ЖБКМБИ. чП-ЧФПТЩИ, УФБОДБТФЙЪПЧБООПУФШ Ч ТБЪНЕЭЕОЙЙ ЖБКМПЧ ЛМБУУПЧ РП ЛБФБМПЗБН ДРЕФ ЧПЪНПЦОПУФШ ЙОФЕРТЕФБФПТХ Java ПДОПЪОБЮОП ПРТЕДЕМСФШ НЕУФПРПМПЦЕОЙЕ ЪБЗТХЦБЕНПЗП ЛМБУУБ, ЪОБЮЙФ ПФРБДБЕФ ОЕПВИПДЙНПУФШ ДЙТЕЛФЙЧОПЗП ЧЛМАЮЕОЙС ЖБКМПЧ ЙУИПДОПЗП ФЕЛУФБ.

рТЙНЕЮБОЙЕ. л УПЦБМЕОЙА, ПФУХФУФЧЙЕ ЧЛМАЮЕОЙС ЖТБЗНЕОФПЧ ЙУИПДОПЗП ФЕЛУФБ НПЦЕФ УДЕМБФШ ЙУИПДОЩЕ ЖБКМЩ ЛМБУУПЧ ЮТЕЪНЕТОП ВПМШЫЙНЙ. ьФП ПУПВЕООП БЛФХБМШОП Ч УЧСЪЙ У ФЕН, ЮФП Java ДПРХУЛБЕФ ПРТЕДЕМЕОЙЕ ЛМБУУПЧ Ч ЛМБУУЕ, П ЮЕН ТЕЮШ ОЙЦЕ.

хУМПЧОБС ЛПНРЙМСГЙС (ДМС ОХЦОЩ #ifdef/#endif Ч C/C++) Ч Java ЧЩРПМОСЕФУС ОЕСЧОП. дЕМП Ч ФПН, ЮФП ОПТНБМШОЩК Java-ЛПНРЙМСФПТ (ОБРТЙНЕТ, javac) ПРТЕДЕМСЕФ ХЮБУФЛЙ ЙУИПДОПЗП ФЕЛУФБ, ЛПФПТЩЕ ОЙЛПЗДБ ОЕ ВХДХФ ЧЩРПМОСФШУС, Й ЙЗОПТЙТХЕФ ЙИ, ОЕ ЗЕОЕТЙТХС ДМС ОЙИ ВБКФ-ЛПДБ. ьФП ЪОБЮЙФ, ЮФП ЛПОУФТХЛГЙС C/C++ Ч ЧЙДЕ

  • #ifdef DEBUG . ПФМБДПЮОЩК ЛПД . #endif НПЦЕФ ВЩФШ УНПДЕМЙТПЧБОЙБ Ч Java ЛПОУФТХЛГЙЕК
  • private static final boolean DEBUG = true/false; if ( DEBUG ) < . ПФМБДПЮОЩК ЛПД . >;

    рПУЛПМШЛХ DEBUG — ЛПОУФБОФБ, ЛПНРЙМСФПТ ЕЭЕ ДП ЬФБРБ ЙОФЕТРТЕФБГЙЙ ЪОБЕФ, ВХДЕФ ЛПД ПФМБДЛЙ ЛПЗДБ-ОЙВХДШ ЧЩРПМОСФШУС ЙМЙ ОЕФ.

    уЙНЧПМЩ, УФТПЛЙ Й ЙДЕОФЙЖЙЛБФПТЩ (Ф.Е. ЙНЕОБ ЛМБУУПЧ, РЕТЕНЕООЩИ НЕФПДПЧ) Ч Java ЖПТНЙТХАФУС 16-ВЙФПЧЩНЙ УЙНЧПМБНЙ Unicode. ьФП ПВЕУРЕЮЙЧБЕФ, ОБРТЙНЕТ, ЧПЪНПЦОПУФШ ДБЧБФШ ЛМБУУБН Й Й ЙИ ЮМЕОБН ТХУУЛЙЕ ЙНЕОБ.

    рТЙНЕЮБОЙЕ. рТЕДУФБЧМЕОЙЕ Ч Unicode УЙНЧПМПЧ МБФЙОУЛПЗП БМЖБЧЙФБ УПЧРБДБЕФ У ЙИ РТЕДУФБЧМЕОЙЕН Ч ASCII Й ISO8859-1 (Latin-1).

    оП, Л УПЦБМЕОЙА, Unicode ЧЛМАЮБЕФ Ч УЕВС ЛПДЙТПЧЛХ ЛЙТЙММЙГЩ УПЧРБДБАЭХА УП УФБОДБТФПН ISO8859-5, ОЕ РПМШЪХАЭЙНУС Х ОБУ РПРХМСТОПУФША (ИПФС ЧУЕ UNIX-УЙУФЕНЩ ЕЗП РПДДЕТЦЙЧБАФ).

    дМС РТЕДУФБЧМЕОЙС Ч ЙУИПДОЩИ ФЕЛУФБИ Java УЙНЧПМПЧ, ОЕ ЙНЕАЭЙИ ЗТБЖЙЮЕУЛПЗП РТЕДУФБЧМЕОЙС (ОБРТЙНЕТ, ЙЪ-ЪБ ПФУХФУФЧЙС УППФЧЕФУФЧХАЭЙИ ЫТЙЖФПЧ) ЙУРПМШЪХЕФУС УМЕДХАЭБС esc-РПУМЕДПЧБФЕМШОПУФШ \u xxxx , ЗДЕ x — ЫЕУФОБДГБФЙТЙЮОБС ГЙЖТБ. оБРТЙНЕТ, \u044E РТЕДУФБЧМСЕФ УФТПЮОХА ТХУУЛХА ВХЛЧХ «А».

    рТПУФЩЕ ФЙРЩ ДБООЩИ

    л УРЙУЛХ РТПУФЩИ ФЙРПЧ ДБООЩИ C Ч Java ДПВБЧМЕОЩ byte Й boolean. л ФПНХ ЦЕ ЮЕФЛП ПРТЕДЕМЕОЩ ТБЪНЕТ, ЪОБЛПЧПУФШ, ДЙБРБЪПО РТЕДУФБЧМЕОЙС Й ЪОБЮЕОЙЕ «РП ХНПМЮБОЙА». рТЙЧЕДЕООБС ОЙЦЕ ФБВМЙГБ УПДЕТЦЙФ ЬФЙ ИБТБЛФЕТЙУФЙЛЙ ДМС ЧУЕИ РТПУФЩИ ФЙРПЧ.

    фЙР уПДЕТЦЙНПЕ хНПМЮБОЙЕ тБЪНЕТ дЙБРБЪПО
    boolean true/false false 1 ВЙФ false . true
    char УЙНЧПМ Unicode \u0000 16 ВЙФПЧ \u0000 . \uFFFF
    byte ГЕМПЕ УП ЪОБЛПН 8 ВЙФПЧ -128 . 127
    short ГЕМПЕ УП ЪОБЛПН 16 ВЙФПЧ -32768 . 32767
    int ГЕМПЕ УП ЪОБЛПН 32 ВЙФБ -2147483648 . 2147483647
    long ГЕМПЕ УП ЪОБЛПН 64 ВЙФБ -9223372036854775808 . 9223372036854775807
    float ЮЙУМБ У РМБЧБАЭЕК ФПЮЛПК Ч ЖПТНБФЕ IEEE 754 0.0 32 ВЙФБ +/-3.40282347E+38 . +/-1.40239846E-45
    double ЮЙУМБ У РМБЧБАЭЕК ФПЮЛПК Ч ЖПТНБФЕ IEEE 754 0.0 64 ВЙФБ +/-1.7976933486231570E+308 . +/-4.94065645841246544E-324

    рТЙНЕЮБОЙЕ. чБЦОП ПФНЕФЙФШ, ЮФП ЙУЛМАЮЙЧ ВЕЪЪОБЛПЧЩЕ ГЕМЩЕ ФЙРЩ, ТБЪТБВПФЮЙЛЙ Java ЧРБМЙ Ч НБТБЪН (ВЕЪ ЧУСЛЙИ ЛБЧЩЮЕЛ). рПРТПВХКФЕ ВЩУФТЕОШЛП ЧУРПНОЙФШ ЛБЛПЕ-МЙВП ПФТЙГБФЕМШОПЕ ГЕМПЕ ЮЙУМП ЙЪ ТЕБМШОПЗП НЙТБ ЙМЙ РТЕДУФБЧЙФШ Ч ЧЙДЕ, ХДПВОПН ДМС ПРЕТЙТПЧБОЙС ЙН, IP-БДТЕУ 212.156.0.0.

    фЙР boolean. ъОБЮЕОЙС ЬФПЗП ФЙРБ ОЕ СЧМСАФУС ГЕМЩНЙ Й ОЕ НПЗХФ ВЩФШ РТЕПВТБЪПЧБОЩ ЙЪ ДТХЗПЗП ФЙРБ ЙМЙ Ч ДТХЗПК ФЙР. дМС «РТЙЧЕДЕОЙС» Л ГЕМПНХ Й ПВТБФОП НПЦОП ЙУРПМШЪПЧБФШ ЛПД, РПДПВОЩК РТЙЧЕДЕООПНХ ОЙЦЕ:
    boolean b; int i; i = (b) ? 1 : 0; // ЙЪ boolean Ч int b = (i != 0); // ЙЪ int Ч boolean

    фЙР char. ъОБЮЕОЙС ЬФПЗП ФЙРБ УМХЦБФ ДМС РТЕДУФБЧМЕОЙС УЙНЧПМПЧ Ч ЛПДЙТПЧЛЕ Unicode, уЙНЧПМШОЩЕ МЙФЕТБМЩ (ЛБЛ Й Ч C/C++) ЪБЛМАЮБАФУС Ч ПДЙОБТОЩЕ ЛБЧЩЮЛЙ (БРПУФТПЖЩ), ОБРТЙНЕТ, char c = ‘A’; .

    рПДДЕТЦЙЧБАУС ЧУЕ esc-РПУМЕДПЧБФЕМШОПУФЙ C Й Unicode, ОБРТЙНЕТ:
    char newline = ‘\n’; char apostrophe = ‘\»; char delete = ‘\377’; char aleph = ‘\u05D0’; фЙР char — ГЕМЩК ФЙР, ОЕ ЙНЕАЭЙК ЪОБЛБ, РТЙ РТЕПВТБЪПЧБОЙЙ Л ФЙРХ byte ЙМЙ short ТЕЪХМШФБФ НПЦЕФ ПЛБЪБФШУС ПФТЙГБФЕМШОЩН.

    гЕМЩЕ ФЙРЩ. л ОЙН Ч Java ПФОПУСФУС byte, short, char, int, long. йЪ ОЙИ ВЕЪЪОБЛПЧЩН СЧМСЕФУС ФПМШЛП char. нПДЙЖЙЛБФПТБ unsigned Ч Java ОЕФ. ч ПУФБМШОПН ПОЙ РПМОПУФША БОБМПЗЙЮОЩ ГЕМЩН ФЙРБН СЪЩЛБ C.

    бТЙЖНЕФЙЮЕУЛЙЕ ПРЕТБГЙЙ ОБД ГЕМЩНЙ ЮЙУМБНЙ ДЕМЕОЙС ОБ ОХМШ ЙМЙ ЧЪСФЙС ПУФБФЛБ РП ПУОПЧБОЙА ОХМШ ЗЕОЕТЙТХАФ ЙУЛМАЮЕОЙЕ ArithmeticException.

    фЙРЩ ДБООЩИ У РМБЧБАЭЕК ФПЮЛПК ЧЛМАЮБАФ Ч УЕВС ФЙРЩ float Й double. мЙФЕТБМЩ ЬФЙИ ФЙРПЧ ЙНЕАФ ФПФ ЦЕ УЙОФБЛУЙУ, ЮФП Й Ч СЪЩЛЕ C.

    ч ТБВПФЕ У ЮЙУМБНЙ У РМБЧБАЭЕК ФПЮЛПК Java РТЙДЕТЦЙЧБЕФУС УФБОДБТФБ IEEE 754. рТЙ ЧЩРПМОЕОЙЙ ОЕЛПТТЕЛФОЩИ БТЙЖНЕФЙЮЕУЛЙИ ПРЕТБГЙК ЧПЪНПЦОП РПМХЮЕОЙЕ ПУПВЩИ ЪОБЮЕОЙК: РМАУ ВЕУЛПОЕЮОПУФШ , НЙОХУ ВЕУЛПОЕЮОПУФШ , ОЕ ЮЙУМП , НЙОХУ ОХМШ . ч ЛМБУУБИ java.lang.Float Й java.lang.Double ДМС ОЕЛПФПТЩИ ЙЪ ОЙИ ПРТЕДЕМЕОЩ УЙНЧПМШОЩЕ ЛПОУФБОФЩ: POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN.

    чЕМЙЮЙОБ NaN — ПУПВЕООБС, ЕЕ УТБЧОЕОЙЕ У ДТХЗЙНЙ ЧЕМЙЮЙОБНЙ, ЧЛМАЮБС ЕЕ УБНХ, ЧУЕЗДБ ДБЕФ false. дМС РТПЧЕТЛЙ «ОБ ТБЧЕОУФЧП» ЧЕМЙЮЙОЕ NaN ЙУРПМШЪХАФУС НЕФПДЩ Float.isNaN() Й Double.isNaN().

    уФТПЛЙ Ч Java ОЕ СЧМСАФУС НБУУЙЧБНЙ УЙНЧПМПЧ, Б СЧМСАФУС ПВЯЕЛФБНЙ ЛМБУУБ String. пДОБЛП, ДМС РТЕДУФБЧМЕОЙС УФТПЛПЧЩИ МЙФЕТБМПЧ Ч Java ЪБЙНУФЧПЧБО УЙОФБЛУЙУ СЪЩЛБ C, ОБРТЙНЕТ,
    String str = «Short string»;

    уУЩМПЮОЩЕ ФЙРЩ ДБООЩИ

    л ОЕ РТПУФЩН ФЙРБН ДБООЩИ Ч Java ПФОПУСФУС ПВЯЕЛФЩ Й НБУУЙЧЩ. ьФЙ ФЙРЩ ЮБУФП ОБЪЩЧБАФ УУЩМПЮОЩНЙ , РПУЛПМШЛХ ДПУФХР Л ОЙН ПУХЭЕУФЧМСЕФУС РП УУЩМЛЕ (Ф.Е. РП БДТЕУХ ПВМБУФЙ РБНСФЙ, ЪБОЙНБЕНПК ПВЯЕЛФПН ЙМЙ НБУУЙЧПН). ч ФП ЧТЕНС ЛБЛ РТПУФЩЕ ФЙРЩ ДБООЩИ ПВТБВБФЩЧБАФУС РП ЪОБЮЕОЙА .

    рПСУОЙН ТБЪОЙГХ ОБ УМЕДХАЭЕН РТЙНЕТЕ. рТЙ РЕТЕДБЮЕ ОЕЛПФПТПНХ НЕФПДХ ГЕМПЗП ЮЙУМБ ФЙРБ byte (РТПУФПК ФЙР) Ч УФЕЛ БТЗХНЕОФПЧ ВХДЕФ ЪБЗТХЦЕОБ ЛПРЙС ЪОБЮЕОЙС ЬФПЗП ЮЙУМБ. рТЙ РЕТЕДБЮЕ Ч ЛБЮЕУФЧЕ БТЗХНЕОФБ НЕФПДХ НБУУЙЧБ ЙЪ ЧУЕЗП МЙЫШ ДЧХИ ГЕМЩИ ЮЙУЕМ ФЙРБ byte Ч УФЕЛ ВХДЕФ ЪБЗТХЦЕОБ ЛПРЙС БДТЕУБ ЬФПЗП НБУУЙЧБ.

    еЭЕ ПДЙО РТЙНЕТ. дМС ПВЯЕЛФПЧ (УУЩМПЮОЩК ФЙР):

  • Button p, q; p = new Button; q = p; p.setLabel(«QQ»); String s = q.getLabel(); // фЕРЕТШ s УПДЕТЦЙФ «QQ» дМС ПВЯЕЛФПЧ РТПУФПЗП ФЙРБ:
  • int i, j; i = 1; j = i; i = 2; // ъДЕУШ i = 2, Б j = 1

    й ЕЭЕ ПДЙО РТЙНЕТ.
    public vo (swap) ДЧБ ПВЯЕЛФБ ЛМБУУБ Object, ОП СУОП, ЮФП ЕЗП ХУЙМЙС ХЫМЙ ЧРХУФХА.

    лПРЙТПЧБОЙЕ ДБООЩИ УУЩМПЮОПЗП ФЙРБ — ОЕ УФПМШ ФТЙЧЙБМШОБС ЪБДБЮБ, ЛБЛ ЛПРЙТПЧБОЙЕ РТПУФЩИ ДБООЩИ. дМС ЛПРЙТПЧБОЙС ДБООЩИ ПДОПЗП ПВЯЕЛФБ Ч ДТХЗПК ПВЯЕЛФ ОЕПВИПДЙНП ЙУРПМШЪПЧБФШ НЕФПД clone(), ОБРТЙНЕТ:
    Vector a, b; a = new Vector; b = a.clone(); рПУМЕ ЧЩРПМОЕОЙС ЬФПЗП ЖТБЗНЕОФБ b ВХДЕФ УУЩМБФШУС ОБ ДХВМЙЛБФ ПВЯЕЛФБ a. уМЕДХЕФ ПФНЕФЙФШ, ЮФП НЕФПД clone() РПДДЕТЦЙЧБЕФУС ФПМШЛП ФЕНЙ ЛМБУУБНЙ, ЛПФПТЩЕ ТЕБМЙЪХАФ ЙОФЕТЖЕКУ Cloneable (ПВ ЙОФЕТЖЕКУБИ РПЪЦЕ).

    уТБЧОЕОЙЕ ДБООЩИ УУЩМПЮОПЗП ФЙРБ ТЕБМЙЪХЕФУС, ЛПОЕЮОП, ОЕ ПРЕТБФПТПН «==», Б НЕФПДПН equals(), ТЕБМЙЪПЧБООПН Ч ТСДЕ ЛМБУУПЧ (Ч C/C++ УФТПЛЙ, ОБРТЙНЕТ, ФПЦЕ УТБЧОЙЧБАФУС ОЕ У РПНПЭША «==», Б У РПНПЭША strcmp()).

    хЛБЪБФЕМЙ (pointers), ЕЭЕ ТБЪ РПДЮЕТЛОЕН, Ч Java ПФУХФУФЧХАФ Й ЪБРТЕЭЕОЩ МАВЩЕ ДЕКУФЧЙС У БДТЕУБНЙ, Б ЙНЕООП:

    • РТЕПВТБЪПЧБОЙЕ УУЩМПЛ Ч ГЕМПЕ Й ПВТБФОП;
    • БТЙЖНЕФЙЛБ БДТЕУПЧ (ХЛБЪБФЕМЕК);
    • ЧЩЮЙУМЕОЙЕ ТБЪНЕТПЧ ФЙРПЧ Й ПВЯЕЛФПЧ.

    null Ч Java — ЬФП ЪБТЕЪЕТЧЙТПЧБООПЕ ЛМАЮЕЧПЕ УМПЧП, ПЪОБЮБАЭЕЕ ПФУХФУФЧЙЕ УУЩМЛЙ . йНЕООП null СЧМСЕФУС ЪОБЮЕОЙЕН «РП ХНПМЮБОЙА» ДМС ЧУЕИ УУЩМПЮОЩИ ФЙРПЧ. ъОБЮЕОЙЕ null ОЕМШЪС РТЙЧЕУФЙ Л ЛБЛПНХ-МЙВП РТПУФПНХ ФЙРХ, ЕЗП ОЕМШЪС УЮЙФБФШ ТБЧОЩН 0 (ЛБЛ РПНОЙН, Ч C/C++ NULL ПРТЕДЕМЕО ЮЕТЕЪ #define ЛБЛ 0).

    ъДЕУШ ПЮЕОШ ЛТБФЛП, РПДТПВОП ПВЯЕЛФЩ ПРЙУЩЧБАФУС Ч УМЕДХАЭЕН ТБЪДЕМЕ.

    уПЪДБОЙЕ ПВЯЕЛФБ ПУХЭЕУФЧМСЕФУС ПРЕТБФПТПН new Ч ФПЮОПУФЙ ФБЛ ЦЕ, ЛБЛ Ч C++, ОБРТЙНЕТ:
    ComplexNumber c = new ComplexNumber(1.0, 1.414);

    уХЭЕУФЧХЕФ ЕЭЕ ФТЙ УРПУПВБ УПЪДБОЙС ПВЯЕЛФПЧ. чП-РЕТЧЩИ, ЙУЛМАЮЙФЕМШОП ДМС ХДПВУФЧБ РПМШЪПЧБФЕМС УПЪДБОЙЕ ПВЯЕЛФБ ЛМБУУБ String НПЦЕФ ВЩФШ ТЕБМЙЪПЧБОП ЪБЛМАЮЕОЙЕН ФЕЛУФБ УФТПЛЙ Ч ДЧПКОЩЕ ЛБЧЩЮЛЙ, ОБРТЙНЕТ:
    String s = «This is a string»;

    чП-ЧФПТЩИ, ДМС УПЪДБОЙС ПВЯЕЛФБ НПЦОП ЙУРПМШЪПЧБФШ ЧЩЪПЧ НЕФПДБ newInstance() ПВЯЕЛФБ ЛМБУУБ Class. ьФПФ УРПУПВ ЙУРПМШЪХЕФУС РТЙ ДЙОБНЙЮЕУЛПК ЪБЗТХЪЛЕ ЛМБУУПЧ.

    ч-ФТЕФШЙИ, ПВЯЕЛФЩ УПЪДБАФУС РХФЕН ЙИ ДЕУЕТЙБМЙЪБГЙЙ , Ф.Е. РХФЕН ЙИ ЧПУУПЪДБОЙС ЙЪ УПУФПСОЙС ИТБОЕОЙС (ОБРТЙНЕТ, ОБ ДЙУЛЕ), Ч ЛПФПТПЕ ПОЙ ВЩМЙ РЕТЕЧЕДЕОЩ РХФЕН УЕТЙБМЙЪБГЙЙ .

    рБНСФШ ДМС ПВЯЕЛФПЧ Ч Java ЧЩДЕМСЕФУС ДЙОБНЙЮЕУЛЙ, ОП ПРЕТБФПТПЧ ФЙРБ delete (C++) ЙМЙ НЕФПДПЧ ФЙРБ free() (СЪЩЛ C) ДМС СЧОПЗП ПУЧПВПЦДЕОЙС УФБЧЫЕК ОЕОХЦОПК РБНСФЙ ОЕФ.

    ч Java ДМС ПУЧПВПЦДЕОЙС ОЕЙУРПМШЪХЕНПК РБНСФЙ ХРПФТЕВМСЕФУС НЕИБОЙЪН БЧФПНБФЙЮЕУЛПК УВПТЛЙ НХУПТБ (garbage collection), ТЕБМЙЪПЧБООЩК Ч ЧЙДЕ ОЙЪЛПРТЙПТЙФЕФОПЗП РПФПЛБ.

    дМС ДПУФХРБ Л ЮМЕОБН ЛМБУУПЧ Й ЙИ ЬЛЪЕНРМСТПЧ ЙУРПМШЪХЕФУС ТБЪДЕМЙФЕМШ «.», ОБРТЙНЕТ:
    ComplexNumber c = new ComplexNumber; c.x =1.0; c.y = 1.414; double m = c.magnitude();

    рТБЛФЙЮЕУЛЙ ЧУЕ, ЮФП УЛБЪБОП ЧЩЫЕ РТП ПВЯЕЛФЩ, УРТБЧЕДМЙЧП Й ДМС НБУУЙЧПЧ:

    • ДПУФХР Л ОЙН ПУХЭЕУФЧМСЕФУС РП УУЩМЛБН;
    • УПЪДБАФУС ДЙОБНЙЮЕУЛЙ У РПНПЭША new;
    • БЧФПНБФЙЮЕУЛЙ УЮЙФБАФУС НХУПТПН, ЕУМЙ ОБ ОЙИ ОЕФ УУЩМЛЙ.

    ч Java УХЭЕУФЧХЕФ ДЧБ УРПУПВБ УПЪДБОЙС НБУУЙЧПЧ. рЕТЧЩК ЧЩДЕМСЕФ РБНСФШ РПД НБУУЙЧ Й ЙОЙГЙБМЙЪЙТХЕФ ЕЗП ЬМЕНЕОФЩ ЪОБЮЕОЙСНЙ «РП ХНПМЮБОЙА», ОБРТЙНЕТ:
    byte buff[] = new byte[1024]; Button bs[] = new Button[10]; ч РЕТЧПК УФТПЛЕ 1024 ЬМЕНЕОФПЧ НБУУЙЧБ buff ЪБРПМОСАФУС ОХМСНЙ, ЧП ЧФПТПК — 10 ЬМЕНЕОФПЧ НБУУЙЧБ bs ЪБРПМОСАФУС ЪОБЮЕОЙСНЙ null.

    чФПТПК УРПУПВ ОЕ ФПМШЛП ЧЩДЕМСЕФ РБНСФШ, ОП Й УТБЪХ ЦЕ ЙОЙГЙБМЙЪЙТХЕФ ЕЕ ХЛБЪБООЩНЙ ЪОБЮЕОЙСНЙ, ОБРТЙНЕТ:

  • int table[] = <1, 2, 4, 8, 16, 32, 64, 128>; лУФБФЙ, Java ДПРХУЛБЕФ Й ОПЧЩК (ПФОПУЙФЕМШОП C/C++) УЙОФБЛУЙУ ПВЯСЧМЕОЙС НБУУЙЧПЧ, ЛБЛ ЬФП РПЛБЪБОП ОЙЦЕ:
  • int[] table = <1, 2, 4, 8, 16, 32, 64, 128>;

    дПУФХР Л ЬМЕНЕОФБН НБУУЙЧБ ПУХЭЕУФЧМСЕФУС ФБЛ ЦЕ, ЛБЛ Й Ч C — ЙОДЕЛУ Ч ЧЙДЕ ГЕМПЗП ЧЩТБЦЕОЙС Ч ЛЧБДТБФОЩИ УЛПВЛБИ. рТЙ РПРЩФЛЕ ПВТБФЙФШУС ЪБ РТЕДЕМЩ НБУУЙЧБ ЗЕОЕТЙТХЕФУС ЙУЛМАЮЕОЙЕ ArrayIndexOutOfBoundsException.

    рТЙНЕЮБОЙЕ . рПРЩФБКФЕУШ РТЙДХНБФШ ЛПД ДМС ФБЛПК РТПЧЕТЛЙ, ЪБРТПЗТБННЙТХКФЕ ЕЗП, ОБРТЙНЕТ, ОБ СЪЩЛЕ C, ЧЪЗМСОЙФЕ ОБ БУУЕНВМЕТОЩК МЙУФЙОЗ Й УТБЧОЙФЕ У ЛПДПН ДПУФХРБ Л ЬМЕНЕОФХ НБУУЙЧБ ОБ СЪЩЛЕ C (НПЦОП РТЕДРПМБЗБФШ, ЮФП ЬФП ВХДЕФ ЕДЙОУФЧЕООБС НБЫЙООБС ЛПНБОДБ ЪБЗТХЪЛЙ «СЮЕКЛЙ» РБНСФЙ Ч ТЕЗЙУФТ ПВЭЕЗП ОБЪОБЮЕОЙС). рПЖБОФБЪЙТХЕН: ДМС ФБЛПК РТПЧЕТЛЙ ЙУРПМШЪХЕФУС «ЦЕМЕЪП». фПЗДБ, ЧП-РЕТЧЩИ, Java-НБЫЙОБ ДПМЦОБ ЪБРХУЛБФШУС, ЛБЛ НЙОЙНХН, У РТЙЧЙМЕЗЙСНЙ root. чП-ЧФПТЩИ, БРРБТБФОЩЕ УТЕДУФЧБ ЛПОФТПМС ДПУФХРБ ЙНЕАФ ЗТБДБГЙА Ч ЧЙДЕ «УФТБОЙГЩ» РБНСФЙ (ФЙРЙЮОП, 512 ВБКФ).

    дМС ПРТЕДЕМЕОЙС ДМЙОЩ НБУУЙЧБ ЙУРПМШЪХЕФУС РЕТЕНЕООБС ЬЛЪЕНРМСТБ length, ПРТЕДЕМЕООБС ЛБЛ ЛПОУФБОФБ (final).

    ч Java УФТПЛЙ ОЕ СЧМСАФУС НБУУЙЧБНЙ УЙНЧПМПЧ, ЪБЛБОЮЙЧБАЭЙНЙУС УЙНЧПМПН NULL. оБРТПФЙЧ, УФТПЛЙ — ЬФП ЬЛЪЕНРМСТЩ ЛМБУУБ java.lang.String. оП УРЕГЙБМШОП ДМС ЬФПЗП ЛМБУУБ Ч Java ТЕБМЙЪПЧБО ПРЕТБФПТ «+», ПУХЭЕУФЧМСАЭЙК ЛПОЛБФЕОБГЙА УФТПЛ.

    чБЦОПК ПУПВЕООПУФША ПВЯЕЛФПЧ String СЧМСЕФУС ЙИ ОЕЙЪНЕОСЕНПУФШ, Ф.Е. Ч ЛМБУУЕ String НЕФПДПЧ, НПДЙЖЙГЙТХАЭЙИ УПДЕТЦЙНПЕ УФТПЛЙ ОЕФ. еУМЙ ОЕПВИПДЙНБ НПДЙЖЙЛБГЙС, ФП ЙЪ ПВЯЕЛФБ String УМЕДХЕФ УПЪДБФШ ПВЯЕЛФ StringBuffer. оБЙВПМЕЕ ЧБЦОЩЕ НЕФПДЩ ЛМБУУБ String — length(), charAt(), equals(), compareTo(), indexOf(), lastIndexOf(), substring().

    ч Java РПДДЕТЦЙЧБАФУС РПЮФЙ ЧУЕ ПРЕТБФПТЩ C (У ФЕНЙ ЦЕ РТБЧЙМБНЙ РТЙПТЙФЕФБ Й БУУПГЙБФЙЧОПУФЙ). йУЛМАЮЕОЩ ПРЕТБФПТЩ ТБВПФЩ У ХЛБЪБФЕМСНЙ (*, ->, &), ПРЕТБФПТ sizeof, Б ЛПОУФТХЛГЙЙ «[]» (ДПУФХР Л НБУУЙЧХ) Й «.» (ДПУФХР Л ЮМЕОХ) ПРЕТБФПТБНЙ ОЕ УЮЙФБАФУС.

    ч Java ДПВБЧМЕОЩ УМЕДХАЭЙЕ ОПЧЩЕ ПРЕТБФПТЩ.
    instanceof
    чПЪЧТБЭБЕФ ЪОБЮЕОЙЕ true, ЕУМЙ ПВЯЕЛФ, УФПСЭЙК УМЕЧБ, РТЙОБДМЕЦЙФ ЛМБУУХ/РПДЛМБУУХ ЙМЙ ТЕБМЙЪХЕФ ЙОФЕТЖЕКУ, УФПСЭЙК УРТБЧБ.
    >>>
    чЩРПМОСЕФ РПВЙФПЧЩК УДЧЙЗ ЧРТБЧП, ХУФБОБЧМЙЧБС УФБТЫЙЕ ВЙФЩ ТЕЪХМШФБФБ Ч 0.
    +
    чЩРПМОСЕФ ЛПОЛБФЕОБГЙА УФТПЛ.
    & Й |
    дМС ФЙРБ boolean ЧЩРПМОСЕФ МПЗЙЮЕУЛЙЕ ПРЕТБГЙЙ й Й ймй.

    Java РПЧФПТСЕФ ВПМШЫЙОУФЧП ХРТБЧМСАЭЙИ ЛПОУФТХЛГЙК СЪЩЛБ C (ЙУЛМАЮБС goto), ДПВБЧМСС ДЧЕ ОПЧЩЕ: try/catch/finally Й synchronized. лТПНЕ ФПЗП Ч ПРЕТБФПТБИ break Й continue ПВЕУРЕЮЕОБ ЧПЪНПЦОПУФШ РЕТЕИПДБ РП НЕФЛЕ.

    пРЕТБФПТ break ВЕЪ НЕФЛЙ ТБВПФБЕФ ФПЮОП ФБЛ ЦЕ, ЛБЛ Й Ч C: ПО РТЕТЩЧБЕФ ЧЩРПМОЕОЙЕ ФЕМБ ФПЗП ГЙЛМБ for, while, do ЙМЙ ЛПОУФТХЛГЙЙ switch, ЧОХФТЙ ЛПФПТПЗП/ПК ПО ТБЪНЕЭЕО. пРЕТБФПТ break У НЕФЛПК ЪБЧЕТЫБЕФ ЧЩРПМОЕОЙЕ ЧОЕЫОЕЗП ВМПЛБ, РПНЕЮЕООПЗП НЕФЛПК, РТЙ ЬФПН БЧФПНБФЙЮЕУЛЙ ЧЩРПМОСАФУС ЧУЕ ВМПЛЙ finally, ЕУМЙ ПОЙ ПРТЕДЕМЕОЩ (ПВ ПРЕТБФПТЕ try, Ч УПУФБЧ ЛПФПТПЗП ЧИПДЙФ ВМПЛ finally ОЙЦЕ). оБРТЙНЕТ.
    test: if ( check(i) ) < try < for (int j=0; j i) break; // ъБЧЕТЫЕОЙЕ ГЙЛМБ for if (a[i][j] == null) break test; // чЩРПМОЕОЙЕ ПРЕТБФПТБ finally >; // Й ЪБЧЕТЫЕОЙЕ if > finally < cleanup (a, i,j); >; >

    ч Java ЛМАЮЕЧПЕ УМПЧП synchronized ЮБУФП ЙУРПМШЪХЕФУС ЛБЛ УРЕГЙЖЙЛБФПТ ДПУФХРБ Л НЕФПДХ. еУМЙ НЕФПД ПВЯСЧМЕО ЛБЛ synchronized, ФП ПО РПМХЮБЕФ ЙУЛМАЮЙФЕМШОЩК ДПУФХР Л УЧПЕНХ ЛМБУУХ ЙМЙ ЬЛЪЕНРМСТХ ЛМБУУБ.

    йУЛМАЮЕОЙС Й ЙИ ПВТБВПФЛБ

    йУЛМАЮЕОЙС — ЧБЦОБС ПУПВЕООПУФШ Java, ПФМЙЮБАЭБС ЕЕ ПФ C (ОП ОЕ C++).

    йУЛМАЮЕОЙЕ (exception) — УЙЗОБМ, УЧЙДЕФЕМШУФЧХАЭЙК П ЧПЪОЙЛОПЧЕОЙЙ ОЕЫФБФОПК УЙФХБГЙЙ (ОБРТЙНЕТ, ПЫЙВЛЙ). йУЛМАЮЕОЙС НПЗХФ ЗЕОЕТЙТПЧБФШУС ЙМЙ ЧЩДБЧБФШУС (throw) ЛБЛ УЙУФЕНОЩНЙ ЛМБУУБНЙ Java, ФБЛ Й ЛМБУУБНЙ РПМШЪПЧБФЕМЕК. рЕТЕИЧБФШ (catch) ЙУЛМАЮЕОЙЕ — ЪОБЮЙФ ПВТБВПФБФШ ЕЗП, РПРЩФБЧЫЙУШ ЧПУУФБОПЧЙФШ ОПТНБМШОХА ТБВПФХ РТПЗТБННЩ.

    йУЛМАЮЕОЙС ТБУРТПУФТБОСАФУС ЧЧЕТИ (ПВТБФОП) РП ЧУЕК ГЕРПЮЛЕ ЧЩЪПЧПЧ НЕФПДПЧ Й ЧЛМАЮЕОЙК ВМПЛПЧ ЛПДБ. еУМЙ ЙУЛМАЮЕОЙЕ ОЕ РЕТЕИЧБЮЕОП УЗЕОЕТЙТПЧБЧЫЙН ЕЗП ВМПЛПН, ФП ПОП РЕТЕДБЕФУС Ч ПИЧБФЩЧБАЭЙК ВМПЛ. еУМЙ ЙУЛМАЮЕОЙЕ ЧППВЭЕ ОЕ РЕТЕИЧБЮЕОП Ч ФЕЛХЭЕН НЕФПДЕ, ФП ПОП РЕТЕДБЕФУС ДМС ПВТБВПФЛЙ Ч ЧЩЪЩЧБАЭЙК НЕФПД. й ФБЛ ДБМЕЕ ЧРМПФШ ДП ЗПМПЧОПЗП НЕФПДБ main, ЮФП ЪБУФБЧМСЕФ ЙОФЕТРТЕФБФПТ Java ЧЩДБФШ УППВЭЕОЙЕ ПВ ПЫЙВЛЕ.

    йУЛМАЮЕОЙС Ч Java — ЬФП ПВЯЕЛФЩ, СЧМСАЭЙЕУС ЬЛЪЕНРМСТБНЙ РПДЛМБУУПЧ ЛМБУУБ java.lang.Throwable. йЪ Throwable РПТПЦДЕОЩ 2 УФБОДБТФОЩИ РПДЛМБУУБ: java.lang.Error Й java.lang.Exception. йУЛМАЮЕОЙС, СЧМСАЭЙЕУС РПДЛМБУУПН ЛМБУУБ Error, УЙЗОБМЙЪЙТХАФ, ЗМБЧОЩН ПВТБЪПН, ПВ ОЕХУФТБОЙНЩИ РТПВМЕНБИ (ОЕИЧБФЛБ РБНСФЙ, ПЫЙВЛЙ ДЙОБНЙЮЕУЛПК ЪБЗТХЪЛЙ Й Ф.Р.), РПЬФПНХ ПОЙ РЕТЕИЧБФЩЧБФШУС ОЕ ДПМЦОЩ. йУЛМАЮЕОЙС ЦЕ, СЧМСАЭЙЕУС РПДЛМБУУБНЙ Exception, УЧЙДЕФЕМШУФЧХАФ П УЙФХБГЙСИ, ЛПФПТЩЕ НПЦОП ЛПТТЕЛФОП ПВТБВПФБФШ, оБРТЙНЕТ, java.io.EOFException ЗПЧПТЙФ П ДПУФЙЦЕОЙЙ ЛПОГБ ЖБКМБ, Б java.lang.ArrayAccessOutOfBounds — П РПРЩФЛЕ ДПУФХРБ Л ЬМЕНЕОФХ, ОБИПДСЭЕНХУС ЪБ РТЕДЕМБНЙ НБУУЙЧБ.

    ф.Л. ЙУЛМАЮЕОЙС — ЬФП ПВЯЕЛФЩ, ФП ПОЙ НПЗХФ УПДЕТЦБФШ Ч УЕВЕ ДБООЩЕ Й НЕФПДЩ. лМБУУ Throwable ЧЛМАЮБЕФ Ч УЕВС УФТПЛХ УФТПЛХ УППВЭЕОЙС ФЙРБ String, РТПЮЙФБФШ ЕЕ НПЦОП У РПНПЭША НЕФПДБ Throwable.getMessage(). фЕМП УППВЭЕОЙС ЪБДБЕФУС РТЙ УПЪДБОЙЙ ПВЯЕФБ ЙУЛМАЮЕОЙС РХФЕН РЕТЕДБЮЙ БТЗХНЕОФБ ЛПОУФТХЛФПТХ. оЕЛПФПТЩЕ ЙУЛМАЮЕОЙС ДПВБЧМСАФ Й ДТХЗЙЕ ДБООЩЕ Ч УЧПК ЛМБУУ.

    пВТБВПФЛБ ЙУЛМАЮЕОЙК Ч Java ТЕБМЙЪХЕФУС У РПНПЭША ЛПОУФТХЛГЙЙ try/catch/finally, ЙНЕАЭЕК УМЕДХАЭЙК ПВЭЙК ЧЙД:
    try < // вМПЛ ЛПДБ, Ч ЛПФПТПН НПЗХФ РТЙУХФУФЧПЧБФШ // ПРЕТБФПТЩ break, continue Й return, // Й ЛПФПТЩК НПЦЕФ ЗЕОЕТЙТПЧБФШ ЙУЛМАЮЕОЙС >catch (SomeException e1) < // пВТБВПФЛБ ЙУЛМАЮЕОЙС e1 ФЙРБ SomeException // ЙМЙ РПДЛМБУУБ ЬФПЗП ФЙРБ >catch (AnotherException e2) < // пВТБВПФЛБ ЙУЛМАЮЕОЙС e2 ФЙРБ AnotherException // ЙМЙ ЕЗП РПДЛМБУУБ >finally < // ьФПФ ЛПД ЧУЕЗДБ ЧЩРПМОСЕФУС РПУМЕ ЛПДБ Ч try ОЕЪБЧЙУЙНП ПФ ХУМПЧЙС ЧЩИПДБ > чОХФТЙ ВМПЛБ try УПДЕТЦЙФУС ЛПД, Ч ИПДЕ ЧЩРПМОЕОЙС ЛПФПТПЗП НПЗХФ ЧПЪОЙЛБФШ ЙУЛМАЮЕОЙС ЙМЙ ОЕХУФТБОЙНЩЕ ПЫЙВЛЙ. чОХФТЙ ВМПЛБ НПЗХФ УПДЕТЦБФШУС ПРЕТБФПТЩ РЕТЕДБЮЙ ХРТБЧМЕОЙС break, continue Й return.

    рПУМЕ ВМПЛБ try НПЦЕФ УМЕДПЧБФШ МАВПЕ (Ч ФПН ЮЙУМЕ Й ОХМЕЧПЕ) ЛПМЙЮЕУФЧП ВМПЛПЧ catch , Ч ЛПФПТЩИ УПДЕТЦЙФУС ЛПД ПВТБВПФЛЙ ЙУЛМАЮЕОЙК ТБЪМЙЮОЩИ ФЙРПЧ. рТЙ ЧПЪОЙЛОПЧЕОЙЙ ЙУЛМАЮЕОЙС Ч ВМПЛЕ try ЕЗП ЧЩРПМОЕОЙЕ РТЕТЩЧБЕФУС. дБМЕЕ РПУМЕДПЧБФЕМШОП РТПУНБФТЙЧБАФУС ВМПЛЙ catch Й ХРТБЧМЕОЙЕ РЕТЕДБЕФУС ФПНХ ВМПЛХ, ЮЕК ФЙР БТЗХНЕОФБ УПЧРБДБЕФ У ЛМБУУПН ПВЯЕЛФБ ЙУЛМАЮЕОЙС ЙМЙ СЧМСЕФУС ЕЗП УХРЕТЛМБУУПН. бТЗХНЕОФ ВМПЛБ catch ДЕКУФЧЙФЕМЕО ФПМШЛП ЧОХФТЙ УЧПЕЗП ВМПЛБ Й УУЩМБЕФУС ОБ УЗЕОЕТЙТПЧБООЩК Ч ВМПЛЕ try ПВЯЕЛФ ЙУЛМАЮЕОЙС.

    вМПЛ finally УПДЕТЦЙФ ЛПД, ЛПФПТЩК ВЕЪХУМПЧОП ЧЩЪЩЧБЕФУС ОБ ЧЩРПМОЕОЙЕ, ЕУМЙ ЧЩРПМОСМБУШ ИПФС ВЩ НЙОЙНБМШОБС ЮБУФШ ВМПЛБ try. лПОЛТЕФОЕЕ.

    • еУМЙ ЧЩИПД ЙЪ ВМПЛБ try ПУХЭЕУФЧМСЕФУС ПРЕТБФПТПН break, continue (У НЕФЛПК ЙМЙ ВЕЪ) ЙМЙ return, ЛПД ВМПЛБ finally ЧЩРПМОСЕФУС РТЕЦДЕ, ЮЕН ХРТБЧМЕОЙЕ ВХДЕФ РЕТЕДБОП Ч ДТХЗХА ФПЮЛХ РТПЗТБННЩ.
    • еУМЙ Ч ВМПЛЕ try ЗЕОЕТЙТХЕФУС ЙУЛМАЮЕОЙЕ, Й РТЙ ЬФПН УХЭЕУФЧХЕФ УППФЧЕФУФЧХАЭЙК МПЛБМШОЩК ВМПЛ catch, ХРТБЧМЕОЙЕ УОБЮБМБ РЕТЕИПДЙФ Л ЛПДХ ЬФПЗП ВМПЛБ, Б ЪБФЕН — Л ЛПДХ ВМПЛБ finally.
    • лПЗДБ ОЕПВИПДЙНЩК ВМПЛ catch ПФУХФУФЧХЕФ, ХРТБЧМЕОЙЕ РЕТЕДБЕФУС Л ВМПЛХ finally, Б ПФ ОЕЗП — Л ВМЙЦБКЫЕНХ ПИЧБФЩЧБАЭЕНХ ВМПЛХ catch, ЛПФПТЩК ПТЙЕОФЙТПЧБО ОБ ПВТБВПФЛХ ДБООПЗП ЙУЛМАЮЕОЙС.

    пФНЕФЙН, ЮФП, ЕУМЙ ЛПД ВМПЛБ finally УБН РЕТЕДБЕФ ХРТБЧМЕОЙЕ РПУТЕДУФЧПН return, break ЙМЙ continue ЙМЙ РПУТЕДУФЧПН ЗЕОЕТБГЙЙ ОПЧПЗП ЙУЛМАЮЕОЙС, ФП ПФМПЦЕООБС РЕТЕДБЮБ ХРТБЧМЕОЙС ПФНЕОСЕФУС Й ТЕБМЙЪХЕФУС ЬФБ ОПЧБС РЕТЕДБЮБ.

    вМПЛ finally ПВЩЮОП ЙУРПМШЪХЕФУС ДМС ЛПТТЕЛФОПЗП ЪБЧЕТЫЕОЙС ВМПЛБ try (ПУЧПВПЦДЕОЙЕ ТЕУХТУПЧ, ЪБЛТЩФЙЕ ЖБКМПЧ Й Ф.Р.).

    ч Java ЛБЦДЩК НЕФПД, УРПУПВОЩК ЗЕОЕТЙТПЧБФШ ЙУЛМАЮЕОЙС, ОП ОЕ РЕТЕИЧБФЩЧБАЭЙК ЙИ, ДПМЦЕО ЙЪЧЕУФЙФШ ПВ ЬФПН НЙТ, ЙУРПМШЪХС ЛПОУФТХЛГЙА throws Ч ПВЯСЧМЕОЙЙ НЕФПДБ, ОБРТЙНЕТ:
    public void myfunc (int arg) throws MyExcept1, MyExcept2

    ъБНЕФЙН, ЕУМЙ НЕФПД ЗЕОЕТЙТХЕФ ЛБЛПЕ-МЙВП ЙУЛМАЮЕОЙЕ, ОП РЕТЕИЧБФЩЧБЕФ Й ПВТБВБФЩЧБЕФ ЕЗП УБНПУФПСФЕМШОП, ФП ХРПНЙОБОЙЕ ЬФПЗП ЙУЛМАЮЕОЙС Ч ЛПОУФТХЛГЙЙ throws УНЩУМБ ОЕ ЙНЕЕФ.

    фБЛЦЕ ЙЪМЙЫОЕ РЕТЕЮЙУМСФШ Ч throws ЙУЛМАЮЕОЙС, СЧМСАЭЙЕУС РПДЛМБУУБНЙ ЛМБУУПЧ Error Й RuntimeException (ОБРТЙНЕТ, ЙУЛМАЮЕОЙЕ InternalError), РПУЛПМШЛХ ПОЙ РТЙУХФУФЧХАФ ФБН ОЕСЧОП. дЕМП Ч ФПН, ЮФП ФБЛЙЕ ЙУЛМАЮЕОЙС УРПУПВЕО ЗЕОЕТЙТПЧБФШ ЛБЦДЩК НЕФПД.

    лМБУУ ЙУЛМАЮЕОЙС, ПРТЕДЕМЕООПЗП Ч throws, НПЦЕФ ВЩФШ УХРЕТЛМБУУПН ЧУЕИ ФЕИ ЙУЛМАЮЕОЙК, ЛПФПТЩЕ ДЕКУФЧЙФЕМШОП НПЗХФ ВЩФШ РПТПЦДЕОЩ НЕФПДПН.

    уФБОДБТФОЩЕ ЙУЛМАЮЕОЙС, ЛПФПТЩЕ ЮБУФП РТЙИПДЙФУС ПВЯСЧМСФШ — java.lang.io.IOException Й java.lang.InterruptedException.

    дМС ЗЕОЕТБГЙЙ ЙУЛМАЮЕОЙК Ч РТПЗТБННЕ ОБ Java ЙУРПМШЪХЕФУС ПРЕТБФПТ throw, ЧУМЕД ЪБ ЛПФПТЩН УМЕДХЕФ ПВЯЕЛФ ЛМБУУБ Throwable. юБУФП ПВЯЕЛФЩ ЙУЛМАЮЕОЙК УПЪДБАФУС Ч ФПН ЦЕ ПРЕТБФПТЕ, Ч ЛПФПТПН ПОЙ РПТПЦДБАФУС, ОБРТЙНЕТ:
    throw new MyExcept(«My exception occured.»);

    рТПЮЙЕ ПФМЙЮЙС ПФ C

    • Java ДПРХУЛБЕФ МПЛБМШОЩЕ ПВЯСЧМЕОЙС РЕТЕНЕООЩИ Ч НЕУФЕ ЙИ ЙУРПМШЪПЧБОЙС (У ВПМШЫЙНЙ ПЗТБОЙЮЕОЙСНЙ, ЮЕН Ч C++).
    • ч Java ПФУХФУФЧХЕФ struct, Ф.Л. ЛМБУУ У ПФЛТЩФЩНЙ РЕТЕНЕООЩНЙ Й ВЕЪ НЕФПДПЧ — ЬФП УФТХЛФХТБ C.
    • ч Java ОЕФ union, Ф.Л. union НПЦОП УНПДЕМЙТПЧБФШ РПДЛМБУУБНЙ.
    • ч Java ПФЛБЪБМЙУШ ПФ enum, Б ЦБМЛП.
    • ч Java ОЕФ ВЙФПЧЩИ РПМЕК, ОП ЙИ НПЦОП УНПДЕМЙТПЧБФШ НБУЛБНЙ.
    • ч Java, ЛБЛ ПВЯЕЛФОП-ПТЙЕОФЙТПЧБООПН СЪЩЛЕ, ОЕПВИПДЙНПУФЙ Ч typedef РТПУФП ОЕФ.
    • ч Java ОЕДПРХУФЙНЩ НЕФПДЩ У РЕТЕНЕООЩН ЮЙУМПН БТЗХНЕОФПЧ, РПУЛПМШЛХ Java — УФТПЗП ФЙРЙЪЙТПЧБООЩК СЪЩЛ. рЕТЕЗТХЪЛБ НЕФПДПЧ, РХУФШ ОЕ РПМОПУФША, ОП РПЪЧПМСЕФ ПВПКФЙ ЬФП ПЗТБОЙЮЕОЙЕ.
    • ч Java ПФУХФУФЧХЕФ ФЙР НЕФПДБ (Ч C/C++ ДПРХУФЙНЩ ХЛБЪБФЕМЙ ОБ НЕФПДЩ), Б ЬФП ЪОБЮЙФ, ЮФП НЕФПД ОЕМШЪС РЕТЕДБФШ ДТХЗПНХ НЕФПДХ Ч ЛБЮЕУФЧЕ БТЗХНЕОФБ, ОБРТЙНЕТ, ДМС ПТЗБОЙЪБГЙЙ callback -ПВТБВПФЛЙ. рТЙИПДЙФУС УПЪДБЧБФШ ЛМБУУ, УПДЕТЦБЭЙК ОХЦОЩК НЕФПД, Й РЕТЕДБЧБФШ Ч ЛБЮЕУФЧЕ БТЗХНЕОФБ ПВЯЕЛФ ДБООПЗП ЛМБУУБ.
    • ч Java ДПВБЧМЕО ТСД НПДЙЖЙЛБФПТПЧ, ЛПФПТЩЕ НПЦОП РТЙНЕОСФШ РТЙ ПВЯСЧМЕОЙЙ РЕТЕНЕООЩИ Й/ЙМЙ НЕФПДПЧ ДМС ОБМПЦЕОЙС ПЗТБОЙЮЕОЙК ЙМЙ РТЕДПУФБЧМЕОЙС ДПРПМОЙФЕМШОПК ЙОЖПТНБГЙЙ. final ьФПФ НПДЙЖЙЛБФПТ НПЦЕФ РТЙНЕОСФШУС Л ЛМБУУБН, НЕФПДБН Й РЕТЕНЕООЩН. лМБУУ, ПВЯСЧМЕООЩК ЛБЛ final, ОЕ НПЦЕФ ЙНЕФШ РПДЛМБУУПЧ, Б ЖЙОБМШОЩК НЕФПД ОЕ НПЦЕФ ВЩФШ РЕТЕПРТЕДЕМЕО. рЕТЕНЕООПК, ПВЯСЧМЕООПК ЛБЛ final, ОЕМШЪС РТЙУЧПЙФШ ОПЧПЕ ЪОБЮЕОЙЕ. native ьФПФ НПДЙЖЙЛБФПТ НПЦОП ЙУРПМШЪПЧБФШ РТЙ ПВЯСЧМЕОЙЙ НЕФПДПЧ. пО РПЛБЪЩЧБЕФ, ЮФП ДБООЩК НЕФПД ХЦЕ ТЕБМЙЪПЧБО ЗДЕ-МЙВП ЪБЧЙУСЭЙН ПФ ЧЩЮЙУМЙФЕМШОПК РМБФЖПТНЩ УРПУПВПН (ОБРТЙНЕТ, ОБ СЪЩЛЕ C). нЕФПД, ПВЯСЧМЕООЩК ЛБЛ native, ДПМЦЕО УПДЕТЦБФШ ФПЮЛХ У ЪБРСФПК Ч ЛБЮЕУФЧЕ УЧПЕЗП ФЕМБ. synchronized ьФПФ НПДЙЖЙЛБФПТ НПЦОП ЙУРПМШЪПЧБФШ РТЙ ПВЯСЧМЕОЙЙ НЕФПДПЧ ЛМБУУБ Й НЕФПДПЧ ЬЛЪЕНРМСТБ ЛМБУУБ. пО УЙЗОБМЙЪЙТХЕФ П ФПН, ЮФП УППФЧЕФУФЧХАЭЙК НЕФПД ОЕБФПНБТОП ЙЪНЕОСЕФ УПУФПСОЙЕ ЛМБУУБ ЙМЙ ПВЯЕЛФБ. рПЬФПНХ Java ДПМЦОБ ПВЕУРЕЮЙЧБФШ ВМПЛЙТПЧБОЙЕ ЛМБУУБ ЙМЙ ПВЯЕЛФБ ОБ ЧТЕНС ЧЩРПМОЕОЙС synchronized-НЕФПДБ ПФ ДПУФХРБ ЙЪ ДТХЗЙИ РПФПЛПЧ ХРТБЧМЕОЙС. transient ьФПФ НПДЙЖЙЛБФПТ НПЦЕФ РТЙНЕОСФШУС Л РЕТЕНЕООЩН ЬЛЪЕНРМСТБ ЛМБУУБ. хЛБЪЩЧБЕФ, ЮФП РЕТЕНЕООБС ОЕ СЧМСЕФУС ЮБУФША ХУФПКЮЙЧПЗП УПУФПСОЙС ПВЯЕЛФБ, РПЬФПНХ ОЕФ ОЕПВИПДЙНПУФЙ Ч ЕЕ УЕТЙБМЙЪБГЙЙ ЧНЕУФЕ У ПВЯЕЛФПН. volatile ьФПФ НПДЙЖЙЛБФПТ НПЦЕФ РТЙНЕОСФШУС Л РЕТЕНЕООЩН. хЛБЪЩЧБЕФ, ЮФП РЕТЕНЕООБС ЙУРПМШЪХЕФУС БУЙИТПООЩНЙ РПФПЛБНЙ ХРТБЧМЕОЙС, РПЬФПНХ ДМС ОЕЕ ОЕ ДПМЦОБ ЧЩРПМОСФШУС ПРФЙНЙЪБГЙС ЛПДБ.

    уПЪДБОЙЕ ЬЛЪЕНРМСТБ ЛМБУУБ (ПВЯЕЛФБ ЛМБУУБ) ПВЩЮОП ТЕБМЙЪХЕФУС У РПНПЭША ПРЕТБФПТБ new, ЛБЛ ЬФП РПЛБЪБОП ОЙЦЕ.
    Circle c; c = new Circle(); ЙМЙ Circle c = new Circle();

    дПУФХР Л ПФЛТЩФЩН (public) ЮМЕОБН ЛМБУУБ ПУХЭЕУФЧМСЕФУС ЮЕТЕЪ «.»:
    Circle c = new Circle(); c.x = 2.0; c.y =2.0; c.r = 1.0; double a = c.area(); // оП ОЕ area(c)!

    ч РТЙНЕТБИ ЧЩЫЕ ПВЯЕЛФ ЛМБУУБ Circle УПЪДБЧБМУС РХФЕН ЧЩЪПЧБ ЛПОУФТХЛФПТБ «РП ХНПМЮБОЙА» Circle() ВЕЪ БТЗХНЕОФПЧ. фБЛЙН ЛПОУФТХЛФПТПН БЧФПНБФЙЮЕУЛЙ УОБВЦБЕФУС ЛБЦДЩК ЧОПЧШ УПЪДБЧБЕНЩК ЛМБУУ Ч Java (ИПФС ЕЗП НПЦОП Й РЕТЕПРТЕДЕМЙФШ). ъБДБЮБ ЛПОУФТХЛФПТБ «РП ХНПМЮБОЙА» УПУФПЙФ Ч ЧЩДЕМЕОЙЙ РБНСФЙ РПД РЕТЕНЕООЩЕ ПВЯЕЛФБ Й ЙОЙГЙБМЙЪБГЙЙ ЙИ ЪОБЮЕОЙСНЙ «РП ХНПМЮБОЙА».

    ч РТЙНЕТЕ, ПРЙУЩЧБАЭЕН ЛМБУУ Circle, ПРТЕДЕМЕО ЕЭЕ ПДЙО ЛПОУФТХЛФПТ У ФТЕНС БТЗХНЕОФБНЙ. пО ОЕ ФПМШЛП ЧЩДЕМСЕФ РБНСФШ РПД ПВЯЕЛФЩ ЛМБУУБ Circle, ОП Й ЙОЙГЙБМЙЪЙТХЕФ ЪОБЮЕОЙС ЙИ РЕТЕНЕООЩИ УЧПЙНЙ БТЗХНЕОФБНЙ. пВТБФЙФЕ ЧОЙНБОЙЕ ОБ ОЕПВИПДЙНПУФШ ЙУРПМШЪПЧБОЙС Ч ЬФПН ЛПОУФТХЛФПТЕ ХЛБЪБФЕМС this ДМС ЙУЛМАЮЕОЙС ЛПОЖМЙЛФБ ЙНЕО. This Ч Java (ЛБЛ Й Ч C++) СЧМСЕФУС ХЛБЪБФЕМЕН ОБ ЬФП (this pointer), Ф.Е. ОБ ФЕЛХЭЙК ПВЯЕЛФ.

    ч Java ДПРХУФЙНП ЪБДБЧБФШ ДМС ЛМБУУБ МАВПЕ ЛПМЙЮЕУФЧП ЛПОУФТХЛФПТПЧ. оБДП ФПМШЛП РПНОЙФШ, ЮФП ЙНС ЛПОУФТХЛФПТБ УПЧРБДБЕФ У ЙНЕОЕН ЛМБУУБ, Ч ПВЯСЧМЕОЙЙ ЛПОУФТХЛФПТБ ОЕ ХЛБЪЩЧБЕФУС ФЙР ЧПЪЧТБЭБЕНПЗП ЪОБЮЕОЙС ЙМЙ ЛМАЮЕЧПЕ УМПЧП void, Ф.Л. ЛПОУФТХЛФПТ ЧУЕЗДБ Ч ОЕСЧОПН ЧЙДЕ ЧПЪЧТБЭБЕФ this.

    лБЛ РПЛБЪЩЧБЕФ РТЙНЕТ У ОЕУЛПМШЛЙНЙ ЛПОУФТХЛФПТБНЙ Java ДПРХУЛБЕФ ОБМЙЮЙЕ Х ЛМБУУБ НЕФПДПЧ У ПДЙОБЛПЧЩНЙ ЙНЕОБНЙ, ОП ТБЪОЩНЙ ФЙРБНЙ БТЗХНЕОФПЧ, ЮФП ОБЪЩЧБЕФУС РЕТЕЗТХЪЛПК НЕФПДПЧ (method overloading). ч Java МАВЩЕ ДЧБ НЕФПДБ ЧПУРТЙОЙНБАФУС ЛБЛ ТБЪМЙЮОЩЕ, ЕУМЙ Х ОЙИ ОЕ УПЧРБДБЕФ ИПФС ВЩ ПДЙО ЙЪ УМЕДХАЭЙИ РТЙЪОБЛПЧ: ЙНС, ЛПМЙЮЕУФЧП БТЗХНЕОФПЧ, РПРБТОП ФЙРЩ БТЗХНЕОФПЧ. фЙР ЧПЪЧТБЭБЕНПЗП ЪОБЮЕОЙС Ч ЬФПФ УРЙУПЛ ОЕ ЧИПДЙФ (Б ЛБЛ ФБН Ч C++?).

    ьФП (ЛБЛ Й Ч C++) РЕТЕНЕООЩЕ, УХЭЕУФЧХАЭЙЕ Ч ЕДЙОУФЧЕООПК ЛПРЙЙ ДМС ЧУЕЗП ЛМБУУБ ОЕЪБЧЙУЙНП ПФ ЛПМЙЮЕУФЧБ УПЪДБООЩИ ПВЯЕЛФПЧ (ЬЛЪЕНРМСТПЧ) ДБООПЗП ЛМБУУБ. ч ЬФПН ЙИ ПФМЙЮЙЕ ПФ РЕТЕНЕООЩИ ЬЛЪЕНРМСТПЧ, ЛПФПТЩЕ УПЪДБАФУС ДМС ЛБЦДПЗП ПВЯЕЛФБ.

    рЕТЕНЕООЩЕ ЛМБУУБ Ч Java НБТЛЙТХАФУС НПДЙЖЙЛБФПТПН static, ЛБЛ ЬФП РПЛБЪБОП ОЙЦЕ:
    public >

    рЕТЕНЕООБС num_circles НПЦЕФ ВЩФШ ЙУРПМШЪПЧБОБ ДМС РПДУЮЕФБ ЛПМЙЮЕУФЧБ УПЪДБООЩИ ПВЯЕЛФЙРПЧ ФЙРБ Circle, ДМС ЬФПЗП ЛБЦДЩК ЛПОУФТХЛФПТ ПВЯЕЛФБ ЛМБУУБ Circle ДПМЦЕО ХЧЕМЙЮЙЧБФШ ЪОБЮЕОЙЕ ЬФПК РЕТЕНЕООПК ОБ 1 (РПОСФОП, ЮФП ЛПОУФТХЛФПТ «РП ХНПМЮБОЙА» Ч ЬФПН УМХЮБЕ ДПМЦЕО ВЩФШ ПВСЪБФЕМШОП РЕТЕЗТХЦЕО).

    рЕТЕНЕООБС PI, ФПЦЕ РТЙОБДМЕЦБЭБС ЛМБУУХ, Б ОЕ Л ЬЛЪЕНРМСТХ, ОБ УБНПН ДЕМЕ РЕТЕНЕООПК ОЕ СЧМСЕФУС. пОБ — ЛПОУФБОФБ, П ЮЈН ЗПЧПТЙФ НПДЙЖЙЛБФПТ final Ч ЕЈ ПВЯСЧМЕОЙЙ.

    дМС ДПУФХРБ Л РЕТЕНЕООЩН ЛМБУУБ ЙУРПМШЪХЕФУС ОЕ ЙНС ПВЯЕЛФБ, Б, ЕУФЕУФЧЕООП, ЙНС ЛМБУУБ, ОБРТЙНЕТ:
    System.out.println («Num = » + Circle.num_circles); Circle.PI = 3.62; double circumference = 2*Circle.PI*radius; ъБНЕФЙН, ЮФП РПРЩФЛБ ЙЪНЕОЙФШ ЛПОУФБОФХ PI ЧП ЧФПТПК УФТПЛЕ ЧЩЪПЧЕФ ПЫЙВЛХ ОБ ЬФБРЕ ЛПНРЙМСГЙЙ. лТПНЕ ФПЗП, ЛПНРЙМСФПТ Java ДПУФБФПЮОП ЙОФЕММЕЛФХБМЕО ДМС ФПЗП, ЮФПВЩ РТПЙЪЧЕДЕОЙЕ ДЧХИ ЛПОУФБОФ 2*Circle.PI РТЕЧТБФЙФШ Ч ПДОХ.

    рЕТЕНЕООЩЕ ЛМБУУБ ЙОЙГЙБМЙЪЙТХАФУС РТЙ РЕТЧПК ЪБЗТХЪЛЕ ЛМБУУБ, ФПЗДБ ЛБЛ РЕТЕНЕООЩЕ ЬЛЪЕНРМСТБ — РТЙ УПЪДБОЙЙ ПВЯЕЛФБ. рТЙ ОЕПВИПДЙНПУФЙ УМПЦОПК ЙОЙГЙБМЙЪБГЙЙ РЕТЕНЕООЩИ ЛМБУУБ Ч ПРТЕДЕМЕОЙЕ ЛМБУУБ ЧЛМАЮБЕФУС ЛПОУФТХЛГЙС УМЕДХАЭЕЗП ЧЙДБ:

    нЕФПДЩ ЛМБУУБ ОЕ УЧСЪБОЩ У ЛПОЛТЕФОЩНЙ ПВЯЕЛФБНЙ ЛМБУУБ Й РПЬФПНХ Ч ОЙИ ОЕДПРХУФЙНП ЙУРПМШЪПЧБОЙЕ «ХЛБЪБФЕМС ОБ ЬФП» this («ЬФПЗП» ДМС ОЙИ РТПУФП ОЕ УХЭЕУФЧХЕФ). тБУЫЙТЙН ЛМБУУ Circle УМЕДХАЭЙНЙ ДЧХНС НЕФПДБНЙ:
    public Circle bigger (Circle c) < // нЕФПД ЬЛЪЕНРМСТБ if (c.r >r) return c; else return this; >; public static Circle bigger (Circle a, Circle b) < // нЕФПД ЛМБУУБ if (a.r >b.r) return a; else return b; >;

    йУРПМШЪПЧБОЙЕ ЬФЙИ НЕФПДПЧ ЙММАУФТЙТХЕФ УМЕДХАЭЙК РТЙНЕТ:
    Circle a = new Circle(2.0); Circle b = new Circle(3.0); Circle c; c = a.bigger(b); // ЙМЙ c = b.bigger(a); c = Circle.bigger(a, b);

    мЕЗЛП ЧЙДЕФШ, ЮФП НЕФПДЩ ЛМБУУПЧ — ЬФП БОБМПЗ ЖХОЛГЙК СЪЩЛПЧ C/C++ (ОЕФ this — ОЕФ ОЙЛБЛЙИ ПВЯЕЛФПЧ). иПФС Java — ПВЯЕЛФОП-ПТЙЕОФЙТПЧБООЩК СЪЩЛ, ПЛБЪБМПУШ, ЮФП ВЕЪ ЖХОЛГЙК Ч ДХИЕ C Ч ОЕН ОЕ ПВПКФЙУШ, Ф.Л. УХЭЕУФЧХАФ РТПУФЩЕ ФЙРЩ ДБООЩИ, ОЕ СЧМСАЭЙЕУС ПВЯЕЛФБНЙ (ОБРТЙНЕТ, double). б ДМС РТПУФЩИ ФЙРПЧ ДБООЩИ ФПЦЕ ОХЦОЩ ЖХОЛГЙЙ. фБЛ, ЛМБУУ Math — ЬФП ОБВПТ НЕФПД ЛМБУУБ (НБФЕНБФЙЮЕУЛЙИ ЖХОЛГЙК) ДМС ПРЕТЙТПЧБОЙС У ЮЙУМБНЙ У РМБЧБАЭЕК ФПЮЛПК. дТХЗПК ЛМБУУ, ЗДЕ ПРТЕДЕМЕОЩ ФПМШЛП НЕФПДЩ ЛМБУУБ — ЬФП System.

    ч Java ОЕФ УТЕДУФЧ СЧОПЗП ХДБМЕОЙС УПЪДБООЩИ ПВЯЕЛФПЧ (ЛПОУФТХЛГЙЙ ФЙРБ free() ЙМЙ delete ПФУХФУФЧХАФ). лБЛ ХЦЕ ЗПЧПТЙМПУШ, ПВЯЕЛФЩ ХОЙЮФПЦБАФУС УВПТЭЙЛПН НХУПТБ (garbage collector).

    уВПТЭЙЛ, ЖХОЛГЙПОЙТХС Ч ТБНЛБИ ОЙЪЛПРТЙПТЙФЕФОПЗП РПФПЛБ ХРТБЧМЕОЙС, ПФЩУЛЙЧБЕФ Й ХДБМСЕФ ПВЯЕЛФЩ, ОБ ЛПФПТЩЕ ОЕФ УУЩМЛЙ ЙЪ ДТХЗЙИ ПВЯЕЛФПЧ Й РЕТЕНЕООЩИ. вПМЕЕ ФПЗП, ПО УРПУПВЕО ПВОБТХЦЙФШ ЙЪПМЙТПЧБООЩЕ ЗТХРРЩ ПВЯЕЛФПЧ У РЕТЕЛТЕУФОЩНЙ УУЩМЛБНЙ ДТХЗ ОБ ДТХЗБ, ОП ОБ ЛПФПТЩЕ ОЕФ УУЩМЛЕ ЙЪЧОЕ. пДОБЛП, ОБДП РПОЙНБФШ, ЮФП РТПРПЧЕДХЕНБС Java ФЕИОПМПЗЙС «УПЪДБМ ПВЯЕЛФ, РПРПМШЪПЧБМУС Й ВТПУЙМ» ТБВПФБЕФ ХДПЧМЕФЧПТЙФЕМШОП ОЕ ЧУЕЗДБ. оБРТЙНЕТ, ЧРПМОЕ НПЦОП РТЕДУФБЧЙФШ УЕВЕ ФБЛПК (РХУФШ ОЕ ПЮЕОШ ЗТБНПФОЩК) НЕФПД: УПЪДБЕФУС НБУУЙЧ matrix ВПМШЫПЗП ТБЪНЕТБ (ОБРТЙНЕТ, ЛЧБДТБФОПК НБФТЙГЩ), ПО РЕТЕТБВБФЩЧБЕФУС Ч ДТХЗПК НБУУЙЧ (ОБРТЙНЕТ, Ч ПВТБФОХА НБФТЙГХ ЙМЙ ЧЕЛФПТ УПВУФЧЕООЩИ ЪОБЮЕОЙК), ДБМЕЕ УМЕДХЕФ ДМЙФЕМШОБС ПВТБВПФЛБ, ЛБУБАЭБСУС ФПМШЛП ЧФПТПЗП НБУУЙЧБ. сУОП, ЮФП ЧУЕ ЧТЕНС ДМЙФЕМШОПК ПВТБВПФЛЙ ХЦЕ ОЕОХЦОЩК ЙУИПДОЩК НБУУЙЧ matrix ВХДЕФ ОЕРТПДХЛФЙЧОП ЪБОЙНБФШ ВПМШЫПК ПВЯЕН РБНСФЙ. чЩИПД Ч ФБЛПК УЙФХБГЙЙ — ЬФП СЧОП ДБФШ ЪОБФШ УВПТЭЙЛХ НХУПТБ П ФПН, ЮФП ПВЯЕЛФ УФБМ ОЕОХЦОЩН, ЧЩРПМОЙЧ Ч УППФЧЕФУФЧХАЭЕН НЕУФЕ ПРЕТБФПТ
    matrix = null;

    рЕТЕД ХДБМЕОЙЕН ПВЯЕЛФБ УВПТЭЙЛ НХУПТБ ЧЩЪЩЧБЕФ ОБ ЧЩРПМОЕОЙЕ НЕФПД finalize(), ЕУМЙ ПО ПРТЕДЕМЕО Ч ЛМБУУЕ ВЯЕЛФБ. ьФПФ НЕФПД ЪБЧЕТЫЕОЙС (БОБМПЗ ДЕУФТХЛФПТБ Ч C++) РТЕДУФБЧМСЕФ УПВПК НЕФПД ЬЛЪЕНРМСТБ (ОЕ static), ОЕ ЙНЕЕФ БТЗХНЕОФПЧ Й ОЕ ЧПЪЧТБЭБЕФ ЪОБЮЕОЙС (void).

    чПФ ЮФП ЕЭЕ ОЕПВИПДЙНП ЪОБФШ П НЕФПДБИ ЪБЧЕТЫЕОЙС уФТ. 85

    рПДЛМБУУЩ Й ОБУМЕДПЧБОЙЕ

    дМС ПРТЕДЕМЕОЙС РПДЛМБУУБ ОЕЛПФПТПЗП ЛМБУУБ Ч Java ЙУРПМШЪХЕФУС ЛМАЮЕЧПЕ УМПЧП extends (ТБУЫЙТСЕФ), ЛБЛ ЬФП РПЛБЪБОП ОЙЦЕ:
    public class GraphicCircle extends Circle < Color outline, fill; public void draw (DrawWindow dw) < dw.drawCircle (x, y, r, outline, fill); >; >

    лБЦДЩК РПДЛМБУУ ОБУМЕДХЕФ ЧУЕ РЕТЕНЕООЩЕ Й НЕФПДЩ УЧПЕЗП ТПДЙФЕМС — УХРЕТЛМБУУБ . рПЬФПНХ РТЕДУФБЧМЕООЩК ОЙЦЕ ПРЕТБФПТ ЧРПМОЕ ЛПТТЕФЕО
    GraphicCircle gc = new GraphicCircle(-2.0, 2.0, 3.0); double area = gc.area();

    лТПНЕ ФПЗП, ЧБЦОП, ЮФП ЛБЦДЩК ПВЯЕЛФ РПДЛМБУУБ СЧМСЕФУС Й РПМОПРТБЧОЩН ПВЯЕЛФПН УХРЕТЛМБУУБ, ОБРТЙНЕТ:
    Circle c = gc; пДОБЛП, ФЕРЕТШ ЮЕТЕЪ c ДПУФХР Л ЗТБЖЙЮЕУЛЙН ЧПЪНПЦОПУФСН ОБУМЕДХАЭЕЗП ЛМБУУБ GraphicCircle УФБМ ОЕЧПЪНПЦЕО.

    жЙОБМШОЩЕ ЛМБУУЩ — ЬФП ЛМБУУЩ, ПВЯСЧМЕООЩЕ У НПДЙЖЙЛБФПТПН final. дМС ФБЛЙИ ЛМБУУПЧ ЪБРТЕЭЕОП ПРТЕДЕМСФШ РПДЛМБУУЩ. пВЯСЧМЕОЙЕ ЛМБУУПЧ ЛБЛ ОЕТБУЫЙТСЕНЩИ РПЪЧПМСЕФ ЛПНРЙМСФПТХ Java ЧЩРПМОСФШ ОЕЛПФПТХА ПРФЙНЙЪБГЙА ЧЩЪПЧПЧ ЕЗП НЕФПДПЧ.

    х МАВПЗП ЛМБУУБ ЕУФШ УХРЕТЛМБУУ. еУМЙ ПО ОЕ ХЛБЪБО СЧОП Ч ЛПОУФТХЛГЙЙ extends, ФП ТПДЙФЕМЕН ЛМБУУБ УЮЙФБЕФУС ЛМБУУ Object, ЧПЪЗМБЧМСАЭЙК ЧУА ЙЕТБТИЙА ПВЯЕЛФПЧ Java (ФПМШЛП ЛМБУУ Object ОЕ ЙНЕЕФ ТПДЙФЕМС).

    лПОУФТХЛФПТ РПДЛМБУУБ ДМС ЧЩЪПЧБ ЛПОУФТХЛФПТБ УЧПЕЗП УХРЕТЛМБУУБ НПЦЕФ ЙУРПМШЪПЧБФШ ЛПОУФТХЛГЙА super(). оБРТЙНЕТ, ЛПОУФТХЛФПТ ДМС ЛМБУУБ GraphicCircle НПЦЕФ ЙНЕФШ УМЕДХАЭЙК ЧЙД:
    public GraphicCircle (double x, double y, double r, Color outline, Color fill) < super (x, y, r); this.outline = outline; this.fill = fill; >;

    пЗТБОЙЮЕОЙС ОБ ЙУРПМШЪПЧБОЙЕ super() ФБЛПЧЩ:

    • ЛПОУФТХЛГЙА super() НПЦОП ЙУРПМШЪПЧБФШ ФПМШЛП Ч ФЕМЕ ЛПОУФТХЛФПТБ;
    • ЧЩЪПЧ ЛПОУФТХЛФПТБ УХРЕТЛМБУУБ ДПМЦЕО ВЩФШ УБНЩН РЕТЧЩН ПРЕТБФПТПН ФЕМБ ЛПОУФТХЛФПТБ (ПО ДПМЦЕО РТЕДЫЕУФЧПЧБФШ ДБЦЕ ПВЯСЧМЕОЙСН РЕТЕНЕООЩИ).

    еУМЙ Ч ЛПОУФТХЛФПТЕ РПДЛМБУУБ ПФУХФУФЧХЕФ СЧОЩК ЧЩЪПЧ ЛПОУФТХЛФПТБ УХРЕТЛМБУУБ, ФП Java ЧУФБЧМСЕФ Ч УБНПЕ ЕЗП ОБЮБМП ЧЩЪПЧ super() ОЕСЧОП. еУМЙ Ч УХРЕТЛМБУУЕ ПФУХФУФЧХЕФ ЛПОУФТХЛФПТ ВЕЪ БТЗХНЕОФПЧ, ФП ЧПЪОЙЛБЕФ ПЫЙВЛБ ЛПНРЙМСГЙЙ. фБЛЙН ПВТБЪПН РТЙ УПЪДБОЙЙ ПВЯЕЛФБ МАВПЗП ЛМБУУБ Ч Java РПУМЕДПЧБФЕМШОП ЧЩЪЩЧБЕФУС ГЕРПЮЛБ ЛПОУФТХЛФПТПЧ, ОБЮЙОБАЭБСУС У ЛПОУФТХЛФПТБ ЗПМПЧОПЗП ЛМБУУБ Object.

    еУМЙ РТЙ УПЪДБОЙЙ ПВЯЕЛФБ Java ЧЩУФТБЙЧБЕФ ПВСЪБФЕМШОХА ГЕРПЮЛХ ЧЩЪПЧПЧ ЛПОУФТХЛФПТПЧ «УЧЕТИХ ЧОЙЪ», ФП НПЦОП ВЩМП ВЩ ПЦЙДБФШ, ЮФП РТЙ ХДБМЕОЙЙ ПВЯЕЛФПЧ ПОБ ЪБУФБЧЙФ ПТЗБОЙЪПЧБФШ ГЕРПЮЛХ НЕФПДПЧ ЪБЧЕТЫЕОЙС finalize() «УОЙЪХ ЧЧЕТИ». оП ЬФП ОЕ ФБЛ: ЧЩЪЩЧБФШ ЙМЙ ОЕФ НЕФПД ЪБЧЕТЫЕОЙС УХРЕТЛМБУУБ ЙЪ НЕФПДБ ЪБЧЕТЫЕОЙС РПДЛМБУУБ — ЦЕМБОЙЕ РТПЗТБННЙУФБ.

    нЕФПД РПДЛМБУУБ РЕТЕПРТЕДЕМСЕФ (overr >

    лПОУФТХЛГЙС «super.» ЮБУФП ЙУРПМШЪХЕФУС Ч НЕФПДБИ ЪБЧЕТЫЕОЙС (РПНОЙН, ЮФП ЙИ ЙНС ЖЙЛУЙТПЧБОП — finalize). еУМЙ ЙЪ НЕФПДБ ЪБЧЕТЫЕОЙС РПДЛМБУУБ ОЕПВИПДЙНП ЧЩЪЧБФШ НЕФПД ЪБЧЕТЫЕОЙС УХРЕТЛМБУУБ, ФП ЙУРПМШЪХЕФУС ПРЕТБФПТ
    super.finalize(); Ч ЛБЮЕУФЧЕ РПУМЕДОЕЗП ПРЕТБФПТБ НЕФПДБ ЪБЧЕТЫЕОЙС.

    нЕФПД ОЕЛПФПТПЗП ЛМБУУБ ОБЪЩЧБЕФУС ЖЙОБМШОЩН , ЕУМЙ ПО ПВЯСЧМЕО У НПДЙЖЙЛБФПТПН final. фБЛПК НЕФПД ОЕЧПЪНПЦОП РЕТЕПРТЕДЕМЙФШ ОЙ Ч ПДОПН РПДЛМБУУЕ ДБООПЗП ЛМБУУБ. йНЕС ДЕМП У ЖЙОБМШОЩН НЕФПДПН, ЛПНРЙМСФПТ Java РПМХЮБЕФ ЧПЪНПЦОПУФШ ПРФЙНЙЪЙТПЧБФШ ЕЗП ЧЩЪПЧ.

    дЙОБНЙЮЕУЛЙК ЧЩЪПЧ НЕФПДПЧ


    рХУФШ ЕУФШ ЛМБУУ A, ПРТЕДЕМСАЭЙК НЕФПД f(), ДЧБ ЕЗП РПДЛМБУУБ B Й C РЕТЕПРТЕДЕМСАФ ЬФПФ НЕФПД (ЛБЦДЩК РП УЧПЕНХ). уПЪДБЕФУС ЧЕЛФПТ v ЬМЕНЕОФПЧ ФЙРБ A, ЛПФПТЩК ЪБРПМОСЕФУС ЧРЕТЕНЕЦЛХ ПВЯЕЛФБНЙ ЛМБУУПЧ A, B Й C. дБМЕЕ ПУХЭЕУФЧМСЕФУС ЧЩЪПЧ v[i].f(). нЕФПД f() ЛБЛПЗП ЛМБУУБ ВХДЕФ ЧЩЪЧБО ОБ ЧЩРПМОЕОЙЕ? рПОСФОП, ЮФП ЛПНРЙМСФПТ Java ЪБТБОЕЕ ЪОБФШ ЛПОЛТЕФОЩК ЛМБУУ ПВЯЕЛФБ, ЛПФПТЩК РПРБДЕФ Ч i-ЩК ЬМЕНЕОФ ЧЕЛФПТБ ОБ ЬФБРЕ ЧЩРПМОЕОЙС ЪОБФШ ОЕ НПЦЕФ. рПЬФПНХ ПО ЗЕОЕТЙТХЕФ ВБКФ-ЛПД ДЙОБНЙЮЕУЛПЗП РПЙУЛБ ОЕПВИПДЙНПЗП НЕФПДБ Й ЕЗП ЧЩЪПЧБ. фБЛПК РПЙУЛ, ЕУФЕУФЧЕООП, ЪБНЕДМСЕФ ЧЩЪПЧ НЕФПДБ.

    л УЮБУФША, ЧП НОПЗЙИ УМХЮБСИ ЛПНРЙМСФПТ Java ЙНЕЕФ ЧПЪНПЦОПУФШ УПЪДБЧБФШ ВБКФ-ЛПД ОЕРПУТЕДУФЧЕООПЗП ЧЩЪПЧБ НЕФПДБ, ТХЛПЧПДУФЧХСУШ НПДЙЖЙЛБФПТБНЙ static, private Й final Ч ПРЙУБОЙЙ НЕФПДПЧ Й ЛМБУУПЧ. лТПНЕ ФПЗП, НЕФПДЩ, ЧЩЪЩЧБЕНЩЕ ОЕРПУТЕДУФЧЕООП, СЧМСАФУС ЛБОДЙДБФБНЙ ОБ inline-РПДУФБОПЧЛХ (ЕУМЙ, ЛПОЕЮОП, ЙИ ТБЪНЕТ ОЕЧЕМЙЛ).

    ч Java ЙУРПМШЪХАФУС 4 ФЙРБ ПЗТБОЙЮЕОЙК ОБ ДПУФХР Л ЮМЕОБН ЛМБУУБ. фТЙ ЙЪ ОЙИ ЪБДБАФУС НПДЙЖЙЛБФПТБНЙ public (ПФЛТЩФЩК), protected (ЪБЭЙЭЕООЩК) Й private (ЪБЛТЩФЩК). юЕФЧЕТФЩК ФЙР — «РП ХНПМЮБОЙА», ДЕКУФЧХАЭЙК РТЙ ПФУХФУФЧЙЙ Ч ПВЯСЧМЕОЙЙ ЮМЕОБ ЛБЛПЗП-МЙВП ЙЪ ЬФЙИ НПДЙЖЙЛБФПТПЧ.

    рТЕДУФБЧМЕООБС ОЙЦЕ ФБВМЙГБ ПРЙУЩЧБЕФ РТБЧЙМБ ДПУФХРБ Л ЮМЕОБН ЛМБУУБ.

    дПУФХРЕО ДМС фЙР ДПУФХРБ
    public protected РП ХНПМЮБОЙА private
    фПЗП ЦЕ ЛМБУУБ ДБ ДБ ДБ ДБ
    лМБУУБ ЙЪ ФПЗП ЦЕ РБЛЕФБ ДБ ДБ ДБ ОЕФ
    рПДЛМБУУПЧ ЙЪ ФПЗП ЦЕ РБЛЕФБ ДБ ДБ ОЕФ ОЕФ
    рПДЛМБУУПЧ ЙЪ ДТХЗЙИ РБЛЕФПЧ ДБ ОЕФ ОЕФ ОЕФ

    нПЗХФ ВЩФШ ДБОЩ УМЕДХАЭЙЕ ТЕЛПНЕОДБГЙЙ РП ЙУРПМШЪПЧБОЙА НПДЙЖЙЛБФПТПЧ ДПУФХРБ.

    • рТЙНЕОСКФЕ НПДЙЖЙЛБФПТ public ДМС ФЕИ НЕФПДПЧ Й ЛПОУФБОФ, ЛПФПТЩЕ ЧИПДСФ Ч УПУФБЧ ПФЛТЩФПЗП API ЛМБУУБ. оЕЛПФПТЩЕ ПЮЕОШ ЧБЦОЩЕ ЙМЙ ЮБУФП ЙУРПМШЪХЕНЩЕ РЕТЕНЕООЩЕ НПЗХФ ФБЛЦЕ ЙУРПМШЪПЧБФШУС ЛБЛ public, ОП ПВЭЕРТЙОСФЩН СЧМСЕФУС ПВЯСЧМСФШ РЕТЕНЕООЩЕ ЛБЛ ОЕ-public Й ЙОЛБРУХМЙТПЧБФШ ЙИ Ч public-НЕФПДБИ.
    • рТЙНЕОСКФЕ НПДЙЖЙЛБФПТ protected ДМС РЕТЕНЕООЩИ Й НЕФПДПЧ, ЛПФПТЩЕ ОЕ ПВСЪБФЕМШОП ЙУРПМШЪХАФУС Ч ДБООПН ЛМБУУЕ, ОП НПЗХФ РПОБДПВЙФШУС РТЙ УПЪДБОЙЙ РПДЛМБУУБ, ЧИПДСЭЕЗП Ч ДТХЗПК РБЛЕФ.
    • йУРПМШЪХКФЕ ФЙР ЧЙДЙНПУФЙ РП ХНПМЮБОЙА ДМС РЕТЕНЕООЩИ Й НЕФПДПЧ, ЛПФПТЩЕ ОЕ ДПМЦОЩ ВЩФШ ЧЙДОЩ ЧОЕ РБЛЕФБ, ОП Л ЛПФПТЩН ЦЕМБФЕМШОП ЙНЕФШ ДПУФХР ЙЪ ЛМБУУПЧ ФПЗП ЦЕ РБЛЕФБ, ЧЪБЙНПДЕКУФЧХАЭЙИ У ДБООЩН ЛМБУУПН.
    • рТЙНЕОСКФЕ НПДЙЖЙЛБФПТ private ДМС РЕТЕНЕООЩИ Й НЕФПДПЧ, ЛПФПТЩЕ ЙУРПМШЪХАФУС ФПМШЛП ЧОХФТЙ ДБООПЗП ЛМБУУБ Й ДПМЦОЩ ВЩФШ УЛТЩФЩ ДМС ПУФБМШОЩИ.

    Java РПЪЧПМСЕФ ПРТЕДЕМСФШ НЕФПД ВЕЪ ЕЗП ТЕБМЙЪБГЙЙ, ПФНЕЮБС ЕЗП ЛБЛ abstract. чНЕУФП ФЕМБ ФБЛЙИ НЕФПДПЧ ХЛБЪЩЧБЕФУС «;» (ФПЮЛБ У ЪБРСФПК). оЙЦЕ ДБОЩ РТБЧЙМБ ДМС БВУФТБЛФОЩИ НЕФПДПЧ Й УПДЕТЦБЭЙИ ЙИ БВУФТБЛФОЩИ ЛМБУУПЧ .

    • мАВПК ЛМБУУ, ЧЛМАЮБАЭЙК БВУФТБЛФОЩК НЕФПД, БЧФПНБФЙЮЕУЛЙ УФБОПЧЙФУС БВУФТБЛФОЩН ЛМБУУПН. бВУФБЛФОЩК ЛМБУУ ДПМЦЕО УПДЕТЦБФШ ИПФС ВЩ ПДЙО БВУФТБЛФОЩК НЕФПД.
    • лМБУУ НПЦЕФ ВЩФШ ПВЯСЧМЕО abstract ДБЦЕ Ч ФПН УМХЮБЕ, ЛПЗДБ ПО ОЕ УПДЕТЦЙФ ОЙ ПДОПЗП БВУФБЛФОПЗП НЕФПДБ. ьФЙН ЗБТБОФЙТХЕФУС ОЕЧПЪНПЦОПУФШ УПЪДБОЙС ЬЛЪЕНРМСТПЧ ФБЛПЗП ЛМБУУБ.
    • бВУФБЛФОЩК ЛМБУУ ОЕ НПЦЕФ ЙНЕФШ ЬЛЪЕНРМСТПЧ.
    • рПДЛМБУУ БВУФТБЛФОПЗП ЛМБУУБ НПЦЕФ ЙНЕФШ ЬЛЪЕНРМСТЩ, ЕУМЙ Ч ОЕН РЕТЕПРТЕДЕМСАФУС ЧУЕ БВУФТБЛФОЩЕ НЕФПДЩ ЕЗП УХРЕТЛМБУУБ, Й ПВЕУРЕЮЙЧБЕФУС ТЕБМЙЪБГЙС ДМС ЛБЦДПЗП ЙЪ ОЙИ.
    • еУМЙ РПДЛМБУУ БВУФТБЛФОПЗП ЛМБУУБ ОЕ ТЕБМЙЪХЕФ ЧУЕ ХОБУМЕДПЧБООЩЕ БВУФБЛФОЩЕ НЕФПДЩ, ПО УБН УФБОПЧЙФУС БВУФБЛФОЩН.

    рТЕДРПМПЦЙН, ЮФП РМБОЙТХЕФУС УПЪДБФШ ТСД ЛМБУУПЧ ЗЕПНЕФТЙЮЕУЛЙИ ЖЙЗХТ: Circle, Ellipse, Rectangle, Triangle Й Ф.Р. дМС ЛБЦДПЗП ЙЪ ОЙИ ОЕПВИПДЙНП ТЕБМЙЪПЧБФШ ДЧБ ПВЭЙИ НЕФПДБ: area() (РМПЭБДШ) Й circumference() (РЕТЙНЕФТ). дМС ПВЕУРЕЮЕОЙС ЧПЪНПЦОПУФЙ ТБВПФЩ У НБУУЙЧПН ЖЙЗХТ РПМЕЪОП ЙНЕФШ ДМС ЧУЕИ ЬФЙИ ЛМБУУПЧ УХРЕТЛМБУУ Shape У НЕФПДБНЙ area() Й circumference(). пДОБЛП ТЕБМЙЪПЧБФШ ЬФЙ НЕФПДЩ Ч Shape ОЕЧПЪНПЦОП. ч ЬФПН УМХЮБЕ Shape ДПМЦЕО ПВЯСЧЙФШ ЬФЙ НЕФПДЩ БВУФТБЛФОЩНЙ (Й БЧФПНБФЙЮЕУЛЙ УФБФШ БВУФТБЛФОЩН ЛМБУУПН).
    public class Shape

    рПДЮЕТЛОЕН ДЧБ ЧБЦОЩИ НПНЕОФБ.

    • пВЯЕЛФЩ МАВПЗП РПДЛМБУУБ ЛМБУУБ Shape НПЗХФ ВЩФШ РТЙУЧПЕОЩ МАВПНХ ЬМЕНЕОФХ МАВПЗП НБУУЙЧБ ФЙРБ Shape. ч РТЙЧЕДЕОЙЙ ФЙРБ ОЕПВИПДЙНПУФЙ ОЕФ.
    • нЕФПДЩ area() Й circumference() НПЦОП ЧЩЪЩЧБФШ ДМС ПВЯЕЛФПЧ ФЙРБ Shape, УЙОФБЛУЙЮЕУЛПК ПЫЙВЛЙ ЪДЕУШ ОЕФ.

    йОФЕТЖЕКУ РПИПЦ ОБ БВУФТБЛФОЩК ЛМБУУ, ЪБ ЙУЛМАЮЕОЙЕН ФПЗП, ЮФП ЧУЕ НЕФПДЩ ЙОФЕТЖЕКУБ ОЕСЧОП ПРТЕДЕМЕОЩ БВУФТБЛФОЩНЙ, ОБРТЙНЕТ:
    public interface Drawable

    еУМЙ Ч УПУФБЧ ЙОФЕТЖЕКУБ ЧИПДЙФ РЕТЕНЕООБС, ФП ПОБ ПВСЪБФЕМШОП ДПМЦОБ ВЩФШ ПВЯСЧМЕОБ ЛБЛ static final (Ф.Е. ВЩФШ ЛПОУФБОФПК).

    йОФЕТЖЕКУЩ ЧЧЕДЕОЩ Ч Java ДМС ПВЕУРЕЮЕОЙС ОЕЛПФПТПЗП РПДПВЙС НОПЦЕУФЧЕООПЗП ОБУМЕДПЧБОЙС, ЛПФПТПЕ Ч УЧПЕН ЮЙУФПН ЧЙДЕ Ч Java ОЕ РПДДЕТЦЙЧБЕФУС. мАВПК ЛМБУУ Java НПЦЕФ ТЕБМЙЪПЧЩЧБФШ (implement) МАВПЕ ЛПМЙЮЕУФЧП ЙОФЕТЖЕКУПЧ.
    public >

    йОФЕТЖЕКУЩ Ч Java СЧМСАФУС ФБЛЙ ЦЕ ФЙРБНЙ ДБООЩИ, ЛБЛ Й ЛМБУУЩ. еУМЙ ЛМБУУ ТЕБМЙЪХЕФ ЛБЛПК-МЙВП ЙОФЕТЖЕКУ, ФП ЬЛЪЕНРМСТЩ ЬФПЗП ЛМБУУБ НПЗХФ ВЩФШ РТЙУЧПЕОЩ РЕТЕНЕООЩН, ЙНЕАЭЙН ФЙР ТЕБМЙЪХЕНПЗП ЙОФЕТЖЕКУБ.

    йОФЕТЖЕКУЩ, СЧМССУШ ПУПВЩН ЧЙДПН ЛМБУУПЧ, НПЗХФ ТБУЫЙТСФШУС РПДЙОФЕТЖЕКУБНЙ. рТЙ ЬФПН РПДЙОФЕТЖЕКУ НПЦЕФ ОБУМЕДПЧБФШ УТБЪХ ОЕУЛПМШЛП УХРЕТЙОФЕТЖЕКУПЧ.

    АйТи бубен

    Инструменты пользователя

    Инструменты сайта

    Сравнение C++ с языками Java и C#

    Целью создания C++ было расширение возможностей Си, наиболее распространённого языка системного программирования. Ориентированный на ту же самую область применения, C++ унаследовал множество не самых лучших, с теоретической точки зрения, особенностей Си. Перечисленные выше принципы, которых придерживался автор языка, предопределили многие недостатки C++.

    В области прикладного программирования альтернативой C++ стал его язык-потомок, Java. Несмотря на преемственность по отношению к C++, Java строилась на принципиально иной основе, её разработчики не были связаны требованиями совместимости с языком-предком и обеспечения максимально достижимой эффективности, благодаря чему они смогли кардинально переработать язык, отказаться от множества синтаксических средств, чтобы добиться идеологической целостности языка. Позже фирма Майкрософт предложила язык C#, представляющий собой ещё одну переработку C++ в том же направлении, что и Java. В дальнейшем появился язык Nemerle, в котором к средствам C# добавлены средства функционального программирования. Ещё позже появилась попытка объединения эффективности C++ с безопасностью и скоростью разработки Java и C# — был предложен язык D, который пока не получил широкого признания.

    Java и C++ можно рассматривать как два языка-потомка Си, разработанных из различных соображений и пошедших, вследствие этого, по разным путям. В этой связи представляет интерес сравнение данных языков (всё, сказанное ниже про Java, можно с равным успехом отнести к языкам C# и Nemerle, поскольку в рассматриваемых деталях эти языки отличаются лишь внешне).

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

    Java-код компилируются в промежуточный код, который в дальнейшем интерпретируется или компилируется, тогда как C++ изначально ориентирован на компиляцию в машинный код заданной платформы (хотя, теоретически, ничто не мешает создавать для C++ трансляторы в промежуточный код). Это уже определяет разницу в сферах применения языков: Java вряд ли может быть использована при написании таких специфических программ, как драйверы устройств или низкоуровневые системные утилиты. Механизм исполнения Java делает программы, даже откомпилированные (в байт-код) полностью переносимыми. Стандартное окружение и среда исполнения позволяют выполнять программы на Java на любой аппаратной платформе и в любой ОС, без каких-либо изменений, усилия по портированию программ минимальны (при соблюдении рекомендаций по созданию переносимых программ — и вовсе нулевые). Ценой переносимости становится потеря эффективности — работа среды исполнения приводит к дополнительным накладным расходам.

    C++ позволяет использовать принцип «захват ресурсов путём инициализации» (RAII), при котором ресурсы ассоциированы с объектом и автоматически освобождаются при разрушении объекта (например, std::vector и std::ifstream). Также возможен подход, когда программист, выделяя ресурсы (память под объекты, открытые файлы и т. п.), обязан явно позаботиться о своевременном их освобождении. Java работает в среде со сборкой мусора, которая автоматически отслеживает прекращение использования объектов и освобождает занимаемую ими память, если в этом есть необходимость, в некоторый неопределённый момент времени. Ручное управление предпочтительнее в системном программировании, где требуется полный контроль над ресурсами, RAII и сборка мусора удобнее в прикладном программировании, поскольку в значительной степени освобождают программиста от необходимости отслеживать момент прекращения использования ресурсов. Сборщик мусора Java требует системных ресурсов, что снижает эффективность выполнения программ, лишает программы на Java детерминированности выполнения и способен следить только за памятью. Файлы, каналы, сокеты, объекты графического интерфейса программист на Java всегда освобождает явно.

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

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

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

    в C++ RTTI ограничена возможностью сравнивать типы объектов между собой и с буквальными значениями типов. В системе Java доступна более подробная информация о типах. Эту возможность можно было бы реализовать в C++, имея полную информацию о типах во время компиляции CTTI.

    C++ использует препроцессор для включения определений функций и классов, для подключения библиотек, полностью выполненных в исходном коде, а также позволяет осуществлять метапрограммирование с использованием препроцессора, которое, в частности, решает сложные проблемы высокоуровневого дублирования кода[8]. Есть мнение, что этот механизм небезопасен, так как имена макросов препроцессора глобальны, а сами макросы почти никак не связаны с конструкциями языка. Это может приводить к сложным конфликтам имён. С другой точки зрения, C++ предоставляет достаточно средств (константы, шаблоны, встроенные функции) для того, чтобы практически полностью исключить использование препроцессора. Java исключила препроцессор полностью, избавившись разом от всех проблем с его использованием, потеряв при этом возможности метапрограммирования препроцессора и текстовых замен в коде средствами языка.

    Отличия языков приводят к ожесточённым спорам между сторонниками двух языков о том, какой язык лучше. Споры эти во многом беспредметны, поскольку сторонники Java считают различия говорящими в пользу Java, а сторонники C++ полагают обратное. Некоторая аргументация устаревает со временем, например, упрёки в неэффективности Java из-за наличия среды исполнения, бывшие справедливыми в первой половине 1990-х годов, в результате лавинообразного роста производительности компьютеров и появления более эффективной техники исполнения (JIT) в значительной мере потеряли актуальность. C++, в свою очередь, развивался, и ряд его недостатков устранён в последних версиях стандарта (например, появился механизм частичной спецификации шаблонов).

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

    C# или Java? Какой язык программирования тебе больше подходит?

    Если вы пытаетесь найти исчерпывающее сравнение C# или Java – вы попали по адресу! Может быть действительно трудно выбрать только один язык программирования для изучения, когда вы только начинаете в области программирования (или компьютерных наук в целом). В то время как университеты и колледжи имеют свои собственные программы, на которых они изучают языки программирования, тем кто изучает самостоятельно может быть тяжело найти что-то конкретное. Именно здесь поэтому существуют статьи-сравнения как эта – вы не только узнаете (по крайней мере) о двух языках программирования (их плюсах и минусах и т. д.). Но и можете выбрать тот, который подойдет вам лучше всего.

    В самом начале мы поговорим о каждом из двух языков. Мы не будем вдаваться в подробности, но у вас будет возможность узнать основные сведения о каждом из них. Узнав основы C # и Java, мы выведем критерии для сравнения C# или Java. Наконец, в самом конце мы проведем само сравнение.

    Введение

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

    Если вы уже являетесь опытным программистом, возможно, вам все же будет полезно пересмотреть базовые сведения о Java и C# (Си шарп). Чем лучше вы разбираетесь в программировании, тем более автоматизированной становится ваша работа – вы больше не задумываетесь о большей части того, что делаете, это становится мышечной памятью и привычкой. Вот почему повторение – мать учения.

    Тем не менее, давайте начнем нашу статью про C# или Java с рассмотрения Java.

    Создание Java началось в 1991 году. Его создали Джеймс Гослинг, Майк Шеридан и Патрик Нотон. До сегодняшнего дня он наиболее широко известен своим лозунгом WORA – напиши один раз, запускай где угодно (write once, run anywhere). Этот слоган используется для описания универсальности Java – код, написанный на Java, может использоваться на многих различных платформах.

    Вся концепция Java заключалась в том, что она должна быть объектно-ориентированной, простой, знакомой и безопасной. Все четыре из этих принципов являются краеугольными камнями, на которых построен язык. Синтаксис Java схож с синтаксисом языков программирования C и C++. Это связано с тем, что C и C++ были самыми популярными языками программирования в начале 90-х годов.

    Язык Java тоже не идеальный. Люди утверждают, что, хотя языку программирования удалось сохранить все вышеперечисленные особенности, существует одна область, в которой ему все еще не хватает – старение. Существует немало мнений о том, что язык Java попросту не развивается, а другие популярные языки программирования уже далеко впереди. Однако язык Java стремится оспорить эти утверждения, выпустив Java 9 – эта версия языка поставляется с целым рядом новых обновлений и инноваций.

    Обсудив и описав основные моменты Java, давайте продолжим эту статью о C# или Java, рассказав о C#.

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

    Как и Java, язык программирования C# – это объектно-ориентированный язык программирования (также известный как ООП). Это действительно важный момент, если мы говорим о сравнении C# или Java – языки ООП в какой-то мере стали нормой в мире программирования. Объектно-ориентированный язык фокусируется на объектах и ​​классах вместо того, чтобы акцентировать внимание на логике, которая их определяет. Это позволяет программистам повторно использовать свой код для более поздних, различных проектов и делает процесс программирования в целом более плавным.

    Если вы, как разработчик C #, решите использовать Visual C #, у вас также будет встроенный редактор кода. Многие программисты любят язык программирования C#, потому что он очень универсален. Си шарп был создан в Microsoft! Это не только гарантирует отличную производительность, но также означает, что язык хорошо документирован и имеет достаточную поддержку для любых проблем, которые могут возникнуть.

    Один из самых больших недостатков C# заключается в том, что если вы хотите запрограммировать приложение .NET, вам придется делать это через ОС Windows. Это может стать серьезным препятствием для некоторых программистов, которые непреклонны в использовании Mac или любой другой ОС.

    Итак, теперь – теперь вы знаете некоторую фундаментальную информацию о языках сегодняшнего сравнения C# или Java. Чтобы продолжить, давайте попробуем выяснить основное различие между Си шарп и Java – после этого мы перейдем непосредственно к части сравнения.

    C# или Java – различия языков

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

    Честно говоря, главное различие между двумя языками программирования в C# или Java заключается в их предполагаемом использовании. Java в основном предназначен для разработки мобильных приложений (точнее – Android). Напротив, C# фокусируется на веб-разработке и разработке игр. Стоит упомянуть, что эти два языка на самом деле больше похожи, чем различны – они оба могут быть использованы для веб-разработки, но также имеют свое собственное назначение!

    Еще одна вещь, о которой стоит упомянуть, это то, что хотя язык Java очень гибкий и может легко использоваться для кроссплатформенной разработки, язык программирования C# страдает от отсутствия универсальности. Это важный аспект для программистов, которые ценят гибкость в своей повседневной работе.

    Критерий сравнения

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

    Три функции – это простота использования, поддержка сообщества и зарплата в этой области. Давайте быстро пройдемся по каждому из них.

    Простота использования

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

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

    Поддержка сообществом

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

    Какой бы язык C# или Java вы ни выбрали, вам, вероятно, захочется начать изучать его онлайн, через курсы, видеоролики на YouTube или любым другим способом. Должно быть много соответствующей информации о языке, который вы могли бы выбрать. Популярные языки программирования предлагают различные источники на выбор, так что вам не нужно беспокоиться. Если бы мы рассматривали другой, неизвестный язык программирования, есть вероятность, что вы действительно не сможете изучить его через онлайн-источники – вы просто ничего не найдете

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

    Зарплата

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

    Однако не все языки программирования имеют одинаковую зарплату. Это также верно в нашем сравнении C# или Java – оба эти языка предлагают разные зарплаты. Естественно, сумма денег, которую вы можете заработать, зависит от нескольких факторов: сложности языка программирования, уровня владения им, компании и даже местоположения вашей работы (географической). может отличаться огромными наценками в разных странах). Однако одно можно сказать наверняка – программирование в целом – это сверхприбыльная и стабильная карьера, и это одна из его главных привлекательных сторон.

    Сравнение

    Теперь, момент, которого вы ждали – сравнение C# и Java. У нас есть основы, мы знаем различия между двумя языками, и мы выделили критерии. Осталось только ответить на вопрос – C# или Java?

    Какой из языков проще использовать?

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

    Хотя раньше Java был проще, недавние обновления C# как бы выравнивали игровое поле. Конечно, оба они не близки к уровням простоты, скажем, Python, но они также намного проще, чем C++.

    У какого языка шире поддержка сообщества?

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

    Когда дело доходит до изучения C# или Java, вам не нужно беспокоиться – какой бы вариант вы ни выбрали, информации в Интернете более чем достаточно. Будь то курс или статья, которую вы ищете, вы не столкнетесь с какими-либо препятствиями, пытаясь изучить C# или Java.

    В какой сфере выше зарплаты?

    По данным Glassdoor.com, средняя годовая зарплата разработчика Java составляет около 88 100 долларов США. Это составляет 7340 долларов США в месяц. По данным того же веб-сайта, зарплата разработчика C# составляет чуть более 95 000 долларов США в год или около 7920 долларов США в месяц.

    Как вы видите, разработчик на C# зарабатывает немного больше денег, чем разработчик на Java. Разница не так уж и значительна, но она все же имеется. При этом обе зарплаты значительно выше средней!

    Заключение

    Итак, каков будет вывод этого сравнения C# или Java? Оба языка похожи, это точно. Тем не менее, если вы хотите больше ориентироваться на разработку игр, то C# – это определенно правильный путь, в то время как люди, ориентированные на веб-разработку, могут найти Java более подходящим выбором.

    Я надеюсь, что это сравнение было полезно для вас, и вы узнали что-то новое о C# и Java! Желаем удачи и увидимся позже!

    Объясните разницу между шаблонами в C++ и дженериками в Java

    Многие программисты полагают, что шаблоны C++ и дженерики (например в Java) — это одно и то же, ведь их синтаксис похож: в обоих случаях можно написать что-то вроде List . Чтобы найти различия, давайте разберемся, что такое шаблоны и дженерики, и как они реализуется в каждом из языков.

    Дженерики Java связаны с идеей «стирания типов» (type erasure). Эта техника устраняет параметры типов, когда исходный код преобразуется в байткод JVM.

    Предположим, что у вас есть Java-код:

    Во время компиляции он будет преобразован:

    Использование обобщений Java не повлияло на наши возможности, но сделало код более красивым. Поэтому дженерики в Java часто называют «синтаксическим сахаром».

    Дженерики сильно отличаются от шаблонов C++. Шаблоны в C++ представляют собой набор макросов, создающих новую копию шаблонного кода для каждого типа. Особенно это заметно на следующем примере: экземпляр MyClass не сможет совместно с MyClass использовать статическую переменную. А два экземпляра MyClass будут совместно использовать статическую переменную.

    «Росбанк», Москва, до 60 000 ₽ (до налогов)

    Чтобы проиллюстрировать этот пример, рассмотрим следующий код:

    В Java различные экземпляры MyClass могут совместно использовать статические переменные, независимо от параметров типа.

    Из-за различий в архитектуре дженерики Java и шаблоны C++ имеют множество отличий:

    • Шаблоны C++ могут использовать примитивные типы, как, например, int , а дженерики Java — нет, они обязаны использовать Integer .
    • Java позволяет указывать ограничения на тип, передаваемый в качестве параметра. Например, вы можете использовать дженерики для реализации CardDeck и указать, что параметр типа должен наследоваться от CardGame .
    • В C++ можно создать экземпляр типа, передаваемого параметром, а Java — нет.
    • Java не позволяет использовать типы, передаваемые параметром (например, Foo в MyClass ) для статических методов и переменных, так как они могут совместно использоваться в MyClass и MyClass . В C++ — это разные классы, поэтому тип из параметра можно использовать для статических методов и переменных.
    • В Java все экземпляры MyClass , независимо от их параметров, относятся к одному и тому же типу. Параметры типов уничтожаются после компиляции. В C++ экземпляры с разными параметрами типов — различные типы.

    Помните, что хотя дженерики Java и шаблоны C++ внешне похожи, это разные вещи.

    Java против C#: какой язык производительнее в реальных проектах?

    Сегодня мы познакомимся с одним опытом, при помощи которого усердный автор, Джефф Когсвелл, попытался рассмотреть производительность кода Java и C# «в реальных условиях». Этот опыт можно считать приглашением к анализу производительности двух языков, ведь полученные автором результаты не претендуют на абсолютную объективность. Но, учитывая соперничество и популярность затронутых в статье языков, надеемся, что материал станет для читателя вкусной пищей для размышлений.

    Автор подготовил специальные тесты и решил проверить, какой из этих языков окажется лучше «в реальных условиях»

    Давайте сравним Java и C# — два языка программирования, каждый из которых имеет широкий круг поклонников, но вместе с тем и яростных противников. Несмотря на все те прения, которые разворачиваются в онлайне, сложно найти четкие критерии, позволяющие оценить реальную производительность каждого из этих языков.

    Какой смысл я вкладываю в понятие «реальный»? Дело в том, что меня не интересует еще один тест, скрупулезно вычисляющий значение числа Пи до миллиона знаков. Я хочу поговорить о решении прикладных задач на языке: какой язык мне выбрать, если требуется ежедневно выдавать клиентам миллионы веб-страниц? Какой из языков сильнее при выборке информации из базы данных и динамической сборке веб-страниц? Именно такая статистика обычно интересует технического специалиста, выбирающего подходящую платформу.

    Прежде чем перейти к тестам, давайте определимся с терминологией. Когда вы пишете код Java, вы обычно планируете использовать его на виртуальной машине Java (JVM). Иными словами, ваш код компилируется в байт-код, а этот байт-код работает под управлением JVM. C#, в свою очередь, обычно работает в общеязыковой исполняющей среде (CLR) от Microsoft. C#, как и Java, компилируется в байт-код.

    Java и C# — это просто языки. Теоретически вы могли бы писать код Java для исполняющей среды Microsoft CLR, а также код C# для JVM. Действительно, на работу с виртуальной машиной Java ориентирован и ряд других языков, в частности Erlang, Python и др. Самые распространенные языки, рассчитанные на работу с CLR (кроме C#), — собственный язык Microsoft Visual Basic.NET, а также майкрософтовская разновидность C++, называемая C++.NET. Общеязыковая исполняющая среда также поддерживает некоторые менее распространенные языки — уже упомянутый выше Python и F#.

    Две эти исполняющие среды содержат фреймворки, представляющие собой наборы классов. Такие наборы для JVM были написаны в Oracle/Sun, а для CLR — в Microsoft. У Oracle есть платформа Java с разнообразными API. Фреймворк Microsoft .NET — это огромный набор классов, обеспечивающих разработку для CLR. На самом деле, многие специалисты называют всю систему просто .NET, а не CLR.

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

    Например, вы вполне можете написать собственный HTTP-слушатель на C# или Java, а потом просто отправить клиенту динамически сгенерированную HTML-страницу. Но на практике почти никто не пишет низкоуровневых HTTP-слушателей; обычно мы стремимся использовать имеющиеся HTTP-серверы. Большинство веб-приложений на C# работают на базе майкрософтовского сервера IIS.

    C другой стороны, серверный код на Java может работать с несколькими разными серверами, в частности Apache HTTP и Tomcat. Кстати, сервер Tomcat был специально разработан для взаимодействия с серверным кодом Java. Мы, конечно, хотели бы сравнивать сопоставимые величины, но в то же время должны сохранить реалистичность эксперимента. Скорее всего, отклик будет зависеть от сервера, а одни серверы работают быстрее других. Хотя HTTP-серверы технически и не входят в состав исполняющей среды, они применяются практически всегда, поэтому их производительность нельзя не учитывать. В первом тесте мы обойдемся без этих стандартных инструментов, а напишем собственные небольшие HTTP-серверы. Во втором случае мы опробуем подобные тесты с аналогичными HTTP-серверами, чтобы получить более точную и полную картину.

    Еще одна проблема — это статические файлы, я собираюсь обойтись в данном опыте без них. Некоторые читатели могут со мной не согласиться, но при современных архитектурах, если вам требуется высокая скорость работы со статическими файлами, написанными на JavaScript или CSS, их просто можно загрузить на облачный сервер, данные которого тиражируются во всей стране. Далее по DNS-конфигурации определяем, какой сервер расположен ближе всего к клиенту, и отсылаем данные весьма быстро. Именно поэтому я собираюсь пропустить эту часть. Вдобавок, если вас интересует максимальная производительность, вы не будете нагружать ваше веб-приложение выдачей статических файлов, а постараетесь выполнять в нем только самую необходимую работу: считывание баз данных, сборка динамического контента и т. п.

    Замечание об аппаратном обеспечении

    Я хочу гарантировать, что применяемое в тестах оборудование привносит в опыт минимальное количество посторонних переменных факторов. На той машине, где я занимаюсь разработкой, стоит масса дополнительных программ, в частности многочисленные сервисы, которые запускаются автоматически и отхватывают процессорное время. В идеале следовало бы выделить под процесс Java или C# целое процессорное ядро, но, к сожалению, выделение ядер происходит иначе. Вы можете ограничить зону действия процесса одним ядром, но не можете «не допустить» в это ядро другие процессы. Поэтому я выделяю для опыта крупные серверы на Amazon EC2, системы которых можно считать базовыми. Поскольку здесь мы не собираемся сравнивать Linux и Windows, а C# ориентирован преимущественно на Windows (если не учитывать проект Mono, который мы и не будем учитывать), все тесты будут выполнены в Windows.

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

    Сбор результатов

    Результаты хронометрировались на клиентской стороне. Делая это, лучше всего отследить время и сохранить его, потом по мере необходимости снова отмечать время, и так до конца теста. Лишь по окончании работы выполняются все подсчеты. Кроме того, я не выводил на консоль никаких данных до полного завершения теста. Распространенная ошибка, которую совершают в подобных тестах: в определенных точках отбираются значения времени, в каждой точке подсчитывается разница во времени, после чего результаты выводятся на консоль. Консоли работают медленно, особенно если их требуется прокручивать. Итак, работаем до конца, а потом вычисляем разностные значения и выводим данные на экран.

    Клиентский код

    Фактически неважно, какой код мы используем в качестве клиентского — важно последовательно задействовать его во всех тестах. Клиентский код будет имитировать работу браузера и измерять, сколько времени требуется на доставку страницы с сервера. Для этого можно использовать C# или Java. Я остановился на C#, поскольку в нем есть очень простой класс WebClient и несложный класс-таймер.

    Первый тест: слушание HTTP

    Начнем. Мы протестируем код, который просто открывает HTTP-слушатель и рассылает динамически сгенерированные веб-страницы.

    Сначала попробуем Java. Мы можем реализовать описанную задачу несколькими способами, но я хотел бы обратить внимание на два подхода. Во-первых, попробуем открыть слушатель TCP/IP на порте 80 и дождаться входящих соединений. Это очень низкоуровневый метод, при котором мы будем пользоваться классом Socket. Другой интересующий нас вариант — использование класса HttpServer. Вот почему я собираюсь воспользоваться этим классом: если мы действительно хотим сравнить скорость Java и C#, без участия Веба, то можно применить некоторые базовые индикаторы, не связанные с работой в Интернете. Так, можно написать два консольных приложения, которые будут оперировать подборкой математических уравнений и, возможно, также выполнять кое-какой строковый поиск и конкатенацию — но это уже другая история. Здесь нас интересует Веб, поэтому займемся HttpServer и его эквивалентом на C#.

    Сразу же я обнаружил одну аномалию: выполнение любого запроса в Java-версии длится почти в 2000 раз больше. На обработку 5 запросов при получении строки из CLR-программы, использующей класс HttpListener, ушло около 17 615 тактов процессора, а на 5 аналогичных запросов с применением сервера Java и класса HttpListener было израсходовано 7 882 975 тактов. Если выразить это соотношение в миллисекундах, то имеем 2 миллисекунды на 15 запросов на сервере C# и 4045 миллисекунд на сервере Java.

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

    Чтобы докопаться до сути проблемы, я решил перейти на другой Java-клиент. Отказался от сравнительно тяжеловесного класса HttpServer, а взамен создал простой сокет, слушающий TCP/IP — для этого воспользовался классом ServerSocket. Вручную создал строку заголовка и основной текст, совпадающий с отправленным в версию на C#.

    Ситуация значительно улучшилась. Могу запускать множество тестов; выполняю 2000 запросов один за другим, но не собираю данных о времени, пока не завершатся все 2000 вызовов к серверу Java. Потом осуществляю аналогичный процесс с сервером C#. В данном случае время измеряется в миллисекундах. На 2000 запросов к серверу Java уходит 2687 миллисекунд. На 2000 запросов к серверу на C# тратится 214 миллисекунд. C# по-прежнему гораздо быстрее.

    Поскольку сохраняется такая значительная разница, мне ничего не оставалось, кроме как испробовать версию Java на сервере Linux. Я воспользовался сервером «c1.medium» на Amazon EC2. Установил оба упомянутых класса Java и получил фактически такие же скорости. Класс HttpServer тратит около 14 секунд на обработку 15 запросов. Плоховато.

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

    Второй тест: полнофункциональный сайт

    Как я уже указывал, мы редко пользуемся самодельными HTTP-серверами. Программисты, работающие с C#, обычно прибегают к IIS. У приверженцев Java есть несколько вариантов, в частности, Tomcat. В моих тестах я использовал именно эти два сервера. В варианте с C# я задействовал платформу ASP.NET MVC 4, работающую на IIS 8. Применил два метода: в первом случае возвращал HTML-строку от самого контроллера; во втором — возвращал представление, содержащее справку даты/времени.

    В тестах Java можно применять два похожих метода. Можно работать с сервлетом, возвращающим информацию на HTML, либо возвращать результаты на странице JSP. Эти методы аналогичны приемам C#, в первом из которых задействуется контроллер, а во втором — представление. Можно было бы применить более новые Java Faces или любые другие фреймворки; оставляю эти задачи всем заинтересованным для самостоятельного изучения.

    Контроллер C# просто возвращает HTML-строку. При прогоне моего клиентского теста с 2000 итераций на него уходит 991 миллисекунда. Опять же, гораздо быстрее, чем версия с сокетом Java.

    Та версия приложения C#, которая работает с представлением, создает полнофункциональную HTML-страницу, соответствующую всем стандартам. Здесь есть элементы HTML, head, meta, title, body и внутренний элемент div, содержащий текст «The date and time is» с указанием даты и времени. Дату и время мы получаем в экземпляре DateTime.Now, динамически записывая эту информацию при каждом запросе.

    Прогон клиентского теста (2000 итераций) в такой версии с представлением занимает 1804 миллисекунды; примерно вдвое дольше, чем напрямую. Напрямую мы возвращаем более краткий HTML, но если увеличить HTML до размеров, сопоставимых с вариантом-представлением, разница практически отсутствует; длительность колеблется в пределах 950—1000 миллисекунд. Даже при добавлении динамической записи даты и времени процесс существенно не замедляется. В любых условиях версия с представлением выполняется примерно вдвое дольше, чем версия с контроллером.

    Перейдем к Java. Сервлет не сложнее, чем контроллер C#. Он просто возвращает строку, содержащую HTML-страницу. На возврат 2000 экземпляров уходит 479 миллисекунд. Это примерно вдвое быстрее, чем с контроллером C# — действительно впечатляет.

    Возврат JSP-страницы также происходит очень быстро. Как и в случае с C#, второй вариант протекает дольше первого. В данном случае на возврат 2000 экземпляров расходуется 753 миллисекунды. Если добавить к JSP-файлу вызов, возвращающий дату, заметной разницы не возникает. На самом деле, на сервере Tomcat явно выполняется какая-то оптимизация, так как в последующих попытках на возврат 2000 экземпляров тратится уже 205 миллисекунд.

    Заключение

    Эти результаты кажутся мне довольно интересными. Я много лет профессионально занимался программированием на C#, мне неоднократно говорили, ссылаясь на личный опыт, что .NET — одна из самых быстрых существующих сред исполнения. Но эти тесты свидетельствуют об обратном. Разумеется, они минимальны; я не делал никаких крупных вычислений, активных запросов к базе данных. Возможно, я еще проведу тесты с базой данных и уточню результаты. Но в моем опыте Java побеждает с явным преимуществом.

    Отличия java от c

    Профиль
    Группа: Участник
    Сообщений: 9
    Регистрация: 8.5.2006

    Репутация: нет
    Всего: нет

    5 основных отличий между Java и C++

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

    Профиль
    Группа: Модератор
    Сообщений: 4367
    Регистрация: 7.10.2005

    Репутация: 47
    Всего: 159

    powerOn
    Дата 8.5.2006, 14:54 (ссылка) | (нет голосов) Загрузка .
    Цитата
    Например, я нашла, что в Java в отличии от С++ есть встроенная (автоматическая) функция «сбора мусора», или, например , что Java не позволяет «многонаследования». Это правильно?

    В Java нет указателей в отлиичии от C++
    B Java нет глобальных переменных.
    .

    Цитата
    нашла по этой теме довольно много материала, но там слишком подробно, слишком длинно и для проффи.

    Все отличия хороши, выбирай на вкус!

    Добавлено @ 14:57
    Java — это чистый ОО язык, С++ — гибридный.

    нет времени думать — нужно писать КОД!

    Профиль
    Группа: Участник
    Сообщений: 131
    Регистрация: 26.10.2005

    Репутация: нет
    Всего: 2

    Sherst
    Дата 8.5.2006, 14:59 (ссылка) | (нет голосов) Загрузка .

    Leprechaun Software Developer

    Профиль
    Группа: Модератор
    Сообщений: 15658
    Регистрация: 24.3.2004

    Репутация: 206
    Всего: 533

    Вообщем все верно.

    Основное отличие Java от С++ состоит в том, что Java это в первую очередь платформа:

    • среда выполнения (JRE)
    • библиотека стандартных компонентов (framework)
    • язык программирования Java

    Есть и языковые отличия, в основном касаются работы с указателями. В частности вообще нет поинтерной арифметики, указателей на функции и т.п.
    А какова собственно цель вопроса?

    LSD
    Дата 8.5.2006, 15:09 (ссылка) | (нет голосов) Загрузка .

    Профиль
    Группа: Участник
    Сообщений: 354
    Регистрация: 22.3.2006

    Репутация: 1
    Всего: 11

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

    ALKS
    Дата 8.5.2006, 15:18 (ссылка) | (нет голосов) Загрузка .

    Профиль
    Группа: Участник
    Сообщений: 9
    Регистрация: 8.5.2006

    Репутация: нет
    Всего: нет

    Извиняюсь за «многонаследование», конечно «множественное наследование». Это я просто читаю на англ., финском и русском, пытаясь найти инфу, вот в голове и каша
    Цель вопроса — хочу попасть на курсы по программир-ю, попала в 30 чел. отобранных на собеседование, теперь дали задание на дом: 20 вопросов, отберут 16 чел. Хочу очень, нет — просто надо!
    Спасибо всем отозвавшимся, теперь буду формулировать это по фински.

    raiskaa
    Дата 8.5.2006, 16:29 (ссылка) | (нет голосов) Загрузка .

    Профиль
    Группа: Завсегдатай
    Сообщений: 1077
    Регистрация: 22.3.2006
    Где: Москва

    Репутация: 20
    Всего: 54

    Открываете Google и пишете запрос: «java and c++ differences«. На первой же странице куча ссылок. Это во-первых. А во-вторых, как верно заметил LSD, Java — это платформа, а C++ — это язык (или язык плюс некоторое количество стандартных библиотек, если рассматривать стандартный ANSI C++). Вообще некорректный вопрос, короче.

    Это сообщение отредактировал(а) w1nd — 8.5.2006, 21:53

    w1nd
    Дата 8.5.2006, 21:48 (ссылка) | (нет голосов) Загрузка .

    Профиль
    Группа: Участник
    Сообщений: 338
    Регистрация: 31.7.2005

    Репутация: нет
    Всего: нет

    a)
    C++ code — ANSI code.
    Java code — Unicode code.

    b)
    C++, int x; if( x ) block1; else block2;
    Java, boolean con; if( con ) block1; else block2;

    jxr
    Дата 8.5.2006, 23:26 (ссылка) | (нет голосов) Загрузка .

    Профиль
    Группа: Завсегдатай
    Сообщений: 1077
    Регистрация: 22.3.2006
    Где: Москва

    Репутация: 20
    Всего: 54

    w1nd
    Дата 9.5.2006, 00:01 (ссылка) | (нет голосов) Загрузка .
    Цитата(jxr @ 8.5.2006, 23:26)
    a)
    C++ code — ANSI code.
    Java code — Unicode code.

    b)
    C++, int x; if( x ) block1; else block2;
    Java, boolean con; if( con ) block1; else block2;

    Профиль
    Группа: Участник Клуба
    Сообщений: 2206
    Регистрация: 16.11.2004
    Где: Zürich

    Репутация: 1
    Всего: 173

    Void
    Дата 9.5.2006, 01:01 (ссылка) | (нет голосов) Загрузка .
    Цитата(w1nd @ 9.5.2006, 02:01 )
    второй — явно далекое от основных отличие

    Профиль
    Группа: Админ
    Сообщений: 13282
    Регистрация: 10.2.2004
    Где: Германия г .Ганновер

    Репутация: 6
    Всего: 360

    • C++ — машинный код / Java — интерпретируемый код (необходим интерпретатор — JVM)
      (Тут как следствие несколько пунктов Платформонезависимость в обмен на зависимость от JVM, Типы (размер) в С++ не определены точно и зависят от компилятора, а на Java типы на всех платтформах одинаковы. )
    • С++ «- Возможно всё, чтего только пожелает программист!» перегрузка операторов, наследование итд. / Java — Возможно только то, что разработчики Явы посчитали логически безопасным. (Этот пункт тоже можно развить на несколько: Перегрузка операторов, множественное наследование итд.)
    • С++ — не полностью Обьектно-ориентированный (возможна смесь с Си, #define и прочие извращения) / Java — полностью обьектно-ориентированный.
    • С++ — Программист полностью сам котроллирует состояние программы, валидность указателей итд./ Java — этим забавляется сборщик мусора и среда Runtime
    • C++ — множество библиотек различной степени свежести и помятости / Java — стандартные библиотеки, распространяемые с JVM, в которых шанс выстрелить себе в ногу сведена практически до нуля

    Остальные отличия, как например синтаксис, ява-специфичные степени инкапсуляции («protected»), особенности поиска библиотек компилятором итд. присутствуют также, но ИМХО отходят далеко на второй план

    sergejzr
    Дата 9.5.2006, 01:24 (ссылка) | (нет голосов) Загрузка .

    Профиль
    Группа: Завсегдатай
    Сообщений: 1077
    Регистрация: 22.3.2006
    Где: Москва

    Репутация: 20
    Всего: 54

    w1nd
    Дата 9.5.2006, 01:27 (ссылка) | (голосов:1) Загрузка .
    Цитата(Void @ 9.5.2006, 01:01)
    В принципе, это следствие из весьма важного отличия Java — типобезопасности, как статической, так и в рантайме. Java позволяет гораздо меньше «тихих» приведений типов, а некорректная интерпретация типа объекта ведет, в отличие от C++, не к неопределенному поведению (читай, непредсказуемым граблям), а к выбросу исключения.

    Не совсем так. Просто в C++ нет булевского типа.

    Это сообщение отредактировал(а) w1nd — 9.5.2006, 01:33

    Профиль
    Группа: Участник Клуба
    Сообщений: 2206
    Регистрация: 16.11.2004
    Где: Zürich

    Репутация: 1
    Всего: 173

    Void
    Дата 9.5.2006, 01:35 (ссылка) | (нет голосов) Загрузка .
    Цитата(w1nd @ 9.5.2006, 03:27 )
    Просто в C++ нет булевского типа.
    Цитата(w1nd @ 9.5.2006, 03:27 )
    Невозможность же проверки в runtime — это особенности работы с указателями и конкретных компиляторов, а не языка.

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

    Цитата(sergej.z @ 9.5.2006, 03:24 )
    ява-специфичные степени инкапсуляции («protected»

    Профиль
    Группа: Завсегдатай
    Сообщений: 1077
    Регистрация: 22.3.2006
    Где: Москва

    Репутация: 20
    Всего: 54

    w1nd
    Дата 9.5.2006, 05:26 (ссылка) | (нет голосов) Загрузка .
    Цитата
    Вы не правы. Есть стандарт C++, в котором четко прописаны конструкции и положения, делающие обязательную проверку типов в рантайме невозможной.
    Цитата
    Это вы мне говорите? А с Си не путаете? В C++ есть булевский тип (bool)

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

    Это сообщение отредактировал(а) w1nd — 9.5.2006, 05:37

    Профиль
    Группа: Участник
    Сообщений: 354
    Регистрация: 22.3.2006

    Репутация: 1
    Всего: 11

    ALKS
    Дата 9.5.2006, 08:31 (ссылка) | (нет голосов) Загрузка .
    Цитата(sergej.z @ 9.5.2006, 01:24)
    [LIST]
    С++ — не полностью Обьектно-ориентированный (возможна смесь с Си, #define и прочие извращения) / Java — полностью обьектно-ориентированный.

    Ни C++ ни Java не являются полностью объектными языками. Полностью объектный язык, это язык, у которого все является объектами, т.е. нет примитивных типов вообще. Кроме того, еще можно смело спорить какой из двух языков предоставляет большие возможности объектно ориентированного программирования. Попробуйте на Java самостоятельно написать класс java.lang.String это не возможно у String перегружена оперция «+». хе хе. а на С++ вы напишете такое запросто. С++ ые templates это конечно предмет вечной зависти. так что не всё так просто.

    Остальные перечисленные пункты тоже верны не доконца и спорны .

    Это сообщение отредактировал(а) ALKS — 9.5.2006, 08:44

    Google
    Дата 12.11.2020, 21:32 (ссылка)
    Правила форума «Java»
    • Прежде, чем задать вопрос, прочтите это!
    • Книги по Java собираются здесь.
    • Документация и ресурсы по Java находятся здесь.
    • Используйте теги [code=java][/code] для подсветки кода. Используйтe чекбокс «транслит«, если у Вас нет русских шрифтов.
    • Помечайте свой вопрос как решённый, если на него получен ответ. Ссылка «Пометить как решённый» находится над первым постом.
    • Действия модераторов можно обсудить здесь.
    • FAQ раздела лежит здесь.

    Если Вам помогли, и атмосфера форума Вам понравилась, то заходите к нам чаще! С уважением, LSD, AntonSaburov, powerOn, tux, javastic.

    В чем разница между Java и С++?

    В чем разница между Java и С++? Оба объектно-ориентированных?

    Это слишком общий вопрос, на который нужно ответить здесь.

    Java — это явно объектно-ориентированный язык, причем более сложные в использовании биты отключаются.

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

    Если бы у вас был более конкретный вопрос, мы могли бы помочь. Почему ты спрашиваешь? Если вам нужны рекомендации для конкретной платформы или проекта или что-то еще, мы можем быть более отзывчивыми.

    Программист на С++ скажет вам, что Java — это мусор. Java-программист скажет вам, что С++ — это мусор. Поэтому я заключаю, что они действительно одно и то же.

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

    Вообще говоря, С++ — это открытый стандарт, предназначенный для внедрения высокопроизводительных систем, где скорость, производительность и критический характер, есть много впечатляющих проектов, разработанных с использованием этого языка, таких как Phoenix Lander, Adobe Acrobat Reader и другие. С++ дает разработчику возможность программировать, используя абстракцию очень высокого уровня, например, с использованием дженериков и, при необходимости, спускаться глубоко в голый металл машины — например, для обработки прерывания.

    Java был разработан с учетом других целей, когда Sun планировал Oak (позже называемый Java), он сосредоточился на веб-приложениях, поэтому он поддерживал язык с кучей тяжелых библиотек простых в использовании интерфейсов, учитывая это. и переносимость (компилировать один раз, запускать в любом месте) с помощью JVM, что предотвращает программирование от кодирования на конкретном компьютере, а вместо этого кодирует песочницу, которая, в свою очередь, запускает код на хостинговой машине, и это, очевидно, отрицательно отражается на производительности/скорости.

    Сравнение этих двух языков является популярной причиной споров между программистами, и это связано с их различными рабочими требованиями и характером, ИМО каждый язык допустил ошибки, чтобы созреть, например, экспортированные на С++ шаблоны, а Java не хватает процедурного программирования (Big Mistake). плюс, каждый из них имеет свои плюсы и минусы в отношении разных аспектов, следовательно, тот, который уравновешивает производительность/производительность, является правильным языком.

    Возможно, было бы интересно посмотреть, какие языки используются (и используются) для создания основных систем (например, Google) из здесь.

    Отличия java от c

    CodeNet — Web Design — Java — Отличия Java от C++

    Отличия Java от C++

    В большинстве книг по C++ вы найдете такое же описание достоинств объектно-ориентированного программирования и доказательства того, что это — очередная ступень в развитии индустрии программирования. В чем же беда C++ и почему была создана Java?

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

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

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

    Другая не слишком хорошая конструкция традиционных языков программирования — оператор goto, предназначенный для передачи управления. Всем нам на первых занятиях по программированию говорили, что можно обойтись без этого оператора, ухудшающего структуру программы и делающего ее неудобочитаемой. До того, как в C++ появился механизм работы с исключениями, goto активно использовался для выхода из циклов в исключительных ситуациях.

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

    Указатели или адреса в памяти — наиболее мощная и наиболее опасная черта C++. Причиной большинства ошибок в сегодняшнем коде является именно неправильная работа с указателями. Например, одна из типичных ошибок — просчитаться на единицу в размере массива и испортить содержимое ячейки памяти, расположенной вслед за ним.

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

    В строю опасных качеств C++ рука об руку с указателями идет распределение памяти. Распределение памяти в С, а значит и в C++, опирается на инь и янь ненадежного кода — на вызовы библиотечных функций malloc() и free().Если вы вызовете free() с указателем на блок памяти, который вы уже освободили ранее, или с указателем, память для которого никогда не выделялась — готовьтесь к худшему. Обратная проблема, когда вы просто забываете вызвать free(), чтобы освободить ненужный больше блок памяти, гораздо более коварна. «Утечка памяти» (memory leak) приводит к постепенному замедлению работы программы по мере того, как системе виртуальной памяти приходится сбрасывать на диск неиспользуемые страницы с мусором. И, наконец, когда все системные ресурсы исчерпаны, программа неожиданно аварийно завершается, а вы начинаете ломать голову над этой проблемой. В C++ добавлены два оператора — new и delete, которые используются во многом аналогично функциям malloc() и free(). Программист по-прежнему отвечает за то, чтобы каждый неиспользуемый объект, созданный с помощью оператора new, был уничтожен оператором delete.

    в Java нет функций ьфддщс() , free(). Поскольку в ней каждая сложная структура данных — это объект, память под такие структуры резервируется в куче (heap) с помощью оператора new. Реальные адреса памяти, выделенные этому объекту, могут изменяться во время работы программы, но вам не нужно об этом беспокоиться. Вам даже не придется вызывать free () или delete, поскольку Java — система с так называемым сборщиком мусора. Сборщик мусора запускается каждый раз, когда система простаивает, либо когда Java не может удовлетворить запрос на выделение памяти.

    Хрупкие типы данных

    C++ получил в наследство от С все обычные типы данных последнего. Эти типы служат для представления целых и вещественных чисел различных размеров и точности. К несчастью, реальный диапазон и точность этих типов колеблется в зависимости от конкретной реализации транслятора. Поведение кода, который прекрасно транслируется и выполняется на одной машине, может радикально отличаться при смене платформы. Различные трансляторы C++ могут резервировать под целый тип 16, 32 или 64 бита в зависимости от разрядности машинного слова.

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

    Ненадежное приведение типов

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

    Дескрипторы объектов в Java включают в себя полную информацию о классе, представителем которого является объект, так что Java может выполнять проверку совместимости типов на фазе исполнения кода, возбуждая исключение в случае ошибки.

    Ненадежные списки аргументов

    C++ гордится своей возможностью передавать указатели на произвольные типы в списках аргументов переменной длины, известных под названием varargs. Интерфейс varargs — простое расширение, основанное на возможности приведения любого адреса к произвольному типу, при этом заботы о проверке допустимости типов ложатся на плечи программиста.

    Было бы прекрасно, если бы в Java существовала безопасная возможность объявлять и передавать списки аргументов переменной длины, но в Java 1. 0 такие средства отсутствуют.

    Раздельные файлы заголовков

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

    В Java такое невозможно, поскольку в ней отсутствуют файлы заголовков. Тип и видимость членов класса при трансляции встраиваются внутрь файла *. >Ненадежные структуры

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

    В Java нет конструкций struct и union, все это объединено в концепции классов.

    Работа препроцессора C++ которого заключается в поиске специальных команд, начинающихся с символа #. Эти команды позволяют выполнять простую условную трансляцию и расширение макроопределений.

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

    Илон Маск рекомендует:  Лекции по конструированию компиляторов литература
  • Понравилась статья? Поделиться с друзьями:
    Кодинг, CSS и SQL