WikiDer > Сравнение C Sharp и Java

Эта статья поднимает множество проблем. Пожалуйста помоги Улучши это или обсудите эти вопросы на страница обсуждения. (Узнайте, как и когда удалить эти сообщения-шаблоны) эта статья написано как руководство или путеводитель. Пожалуйста помоги переписать эту статью из описательного, нейтральная точка зрения, и удалите совет или инструкцию. (Январь 2016) (Узнайте, как и когда удалить этот шаблон сообщения) эта статья может быть слишком техническим для большинства читателей, чтобы понять. Пожалуйста помогите улучшить это к сделать понятным для неспециалистов, не снимая технических деталей. (Январь 2016) (Узнайте, как и когда удалить этот шаблон сообщения) эта статья возможно содержит оригинальные исследования. Пожалуйста Улучши это от проверка заявленные претензии и добавление встроенные цитаты. Заявления, содержащие только оригинальные исследования, следует удалить. (Декабрь 2015 г.) (Узнайте, как и когда удалить этот шаблон сообщения) эта статья содержит ласковые слова: расплывчатая формулировка, которая часто сопровождает предвзятый или непроверяемый Информация. Такие заявления должны быть уточнены или удалены. (Март 2011 г.) (Узнайте, как и когда удалить этот шаблон сообщения)

В этой статье сравниваются два языки программирования: C # с участием Ява. Хотя в этой статье основное внимание уделяется языкам и их функциям, при таком сравнении обязательно будут рассмотрены некоторые особенности платформы и библиотеки. Для более подробного сравнения платформ см. Сравнение платформ Java и .NET.

C # и Ява похожие языки, которые напечатанный статически, сильно, и явно. Оба объектно-ориентированный, и разработан с полу-интерпретация или время выполнения своевременная компиляция, и оба фигурные скобки, любить C и C ++.

Типы

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

Единая система типов

Оба языка имеют статическую типизацию с объектной ориентацией на основе классов. В Java примитивные типы особенные в том, что они не объектно-ориентированный и они не могли быть определены с помощью самого языка. У них также нет общего предка со ссылочными типами. Ява ссылочные типы все происходят от общего корневого типа. C # имеет унифицированный система типов в котором все типы (кроме небезопасных указателей^[16]) в конечном итоге происходят от общего корневого типа. Следовательно, все типы реализуют методы этого корневого типа и методы расширения, определенные для объект тип применяется ко всем типам, даже к примитивным int литералы и делегаты. Это позволяет C #, в отличие от Java, поддерживать объекты с инкапсуляцией, которые не являются ссылочными типами.

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

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

Простые типы C # реализуют несколько интерфейсы и, следовательно, предлагают множество методов непосредственно для экземпляров типов, даже для литералов. Имена типов C # также просто псевдонимы для общеязыковая среда выполнения (CLR) типы. C # System.Int64 тип точно такой же, как и длинная тип; единственное отличие состоит в том, что первое - это каноническое имя .NET, а второе - псевдоним C #.

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

Типы данных

Числовые типы

Целые числа со знаком

Поддержка как Java, так и C # подписанный целые числа с разрядностью 8, 16, 32 и 64 бит. Они используют одно и то же имя / псевдонимы для типов, за исключением 8-битного целого числа, которое называется байт в Java и сбайт (байт со знаком) в C #.

Целые числа без знака

C # поддерживает беззнаковый в добавок к подписанный целые типы. Беззнаковые типы: байт, ushort, uint и Улонг для ширины 8, 16, 32 и 64 бита соответственно. Также поддерживаются беззнаковые арифметические операции с типами. Например, добавление двух целых чисел без знака (uints) по-прежнему дает uint как результат; не длинное целое число со знаком.

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

Целые числа без знака были намеренно исключены из Java, потому что Джеймс Гослинг считал, что программисты не поймут, как работает беззнаковая арифметика.

При разработке языков программирования одна из стандартных проблем заключается в том, что язык становится настолько сложным, что никто не может его понять. Один из небольших экспериментов, которые я провел, - это расспрашивать людей о правилах беззнаковой арифметики в C. Оказывается, никто не понимает, как работает беззнаковая арифметика в C. Есть несколько очевидных вещей, которые люди понимают, но многие этого не понимают.^[9][18]

Десятичные числа высокой точности

В C # есть тип и буквальная нотация для высокоточной (28 десятичных цифр) десятичной арифметики, которая подходит для финансовых и денежных расчетов.^[19][20][21] В отличие от плавать и двойной типы данных, десятичные дробные числа, такие как 0,1, могут быть представлены точно в десятичном представлении. В представлениях float и double такие числа часто имеют неограниченные двоичные расширения, что делает эти представления более подверженными ошибкам округления.^[20]

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

Расширенные числовые типы

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

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

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

C # позволяет интегрировать определяемые библиотекой типы с существующими типами и операторами с помощью настраиваемых неявных / явных преобразований и перегрузки операторов. См. Пример в разделе Интеграция типов, определяемых библиотекой

Символы

Оба языка имеют родной char (символьный) тип данных как простой тип. Хотя char type можно использовать с поразрядными операторами, это выполняется путем продвижения char значение до целого числа перед операцией. Таким образом, результатом побитовой операции в обоих языках является числовой тип, а не символ.

Встроенные составные типы данных

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

Библиотеки обоих языков определяют классы для работы с датами и календарями в разных культурах. Ява java.util.Date является изменяемым ссылочным типом, тогда как C # System.DateTime является типом значения структуры. C # дополнительно определяет Промежуток времени тип для работы с периодами времени. Оба языка поддерживают арифметику даты и времени в соответствии с различными культурами.

Пользовательский тип значения (структура)

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

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

Помимо встроенных примитивных типов, Java не включает концепцию типов значений.

Перечисления

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

В C # перечисления реализованы аналогично C, то есть как оболочки вокруг битовых флагов, реализованные в примитивных целочисленных типах (int, byte, short и т. Д.). Это дает преимущества в производительности и улучшает взаимодействие с скомпилированным кодом C / C ++, но предоставляет меньше функций и может привести к ошибкам, если типы значений низкого уровня напрямую приводятся к типу перечисления, как это разрешено в языке C #. Следовательно, это рассматривается как синтаксический сахар.^[22] Напротив, Java реализует перечисления как полнофункциональный набор экземпляров, требующий больше памяти и не способствующий взаимодействию с кодом C / C ++, но предоставляющий дополнительные функции в отражении и внутреннем поведении. Реализация на каждом языке описана в таблице ниже.

И в C #, и в Java программисты могут использовать перечисления в оператор переключения без преобразования в строковый или примитивный целочисленный тип. Однако C # не допускает неявного провала, если оператор case не содержит никакого кода, так как это частая причина трудных для поиска ошибок.^[25] Отказ должен быть явно объявлен с помощью оператора goto.^[26]

Делегаты, ссылки на методы

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

Не следует путать делегатов с закрытием и встроенными функциями. Эти концепции связаны, потому что ссылка на закрывающую / встроенную функцию должна быть зафиксирована в ссылке на делегат, чтобы быть полезной. Но делегат не всегда ссылается на встроенную функцию; он также может ссылаться на существующие статические методы или методы экземпляра. Делегаты составляют основу C # События, но не следует путать с ними.

Делегатов намеренно исключили из Java, потому что они считались ненужными и вредными для языка, а также из-за потенциальных проблем с производительностью.^[27] Вместо этого используются альтернативные механизмы. В шаблон обертки, который напоминает делегатов C # тем, что позволяет клиенту получить доступ к одному или нескольким методам, определяемым клиентом, через известный интерфейс, является одним из таких механизмов.^{[нужна цитата]} Другой - использование адаптер объекты, использующие внутренние классы, что, по мнению разработчиков Java, является лучшим решением, чем ссылки на связанные методы.^[27]

См. Также пример Делегаты C # и эквивалентные конструкции Java.

Поднятые (обнуляемые) типы

C # позволяет "поднять" значения / примитивные / простые типы, чтобы разрешить специальные значение NULL value в дополнение к собственным значениям типа. Тип снимается добавлением ? суффикс к названию типа; это эквивалентно использованию Обнуляемый общий типа, где Т тип, который нужно поднять. Неявно определены преобразования для преобразования между значениями базового и повышенного типов. Поднятый тип можно сравнить с значение NULL или его можно протестировать на HasValue. Кроме того, поднятые операторы неявно и автоматически определяются на основе их не поднятого основания, где - за исключением некоторых логических операторов - нулевой аргумент будет распространяться на результат.

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

Согласно спецификации Java, любая попытка разыменовать значение NULL ссылка должна привести к возникновению исключения во время выполнения, в частности Исключение нулевого указателя. (В противном случае не было бы смысла разыменовать его, потому что, по определению, он не указывает ни на один объект в памяти.) Это также применимо при попытке распаковать переменная типа оболочки, которая оценивается как значение NULL: программа выдаст исключение, потому что нет объекта, который нужно распаковать, и, следовательно, нет упакованного значения, которое могло бы участвовать в последующих вычислениях.

В следующем примере показано другое поведение. В C # оператор поднятого * распространяет значение NULL значение операнда; в Java при распаковке пустой ссылки возникает исключение.

Не все операторы с расширением C # были определены для распространения значение NULL безусловно, если один из операндов значение NULL. В частности, логические операторы были подняты для поддержки троичная логика таким образом сохраняя сопротивление с SQL.

Логические операторы Java не поддерживают троичную логику и не реализованы в библиотеке базовых классов.

Поздний (динамический) тип

C # имеет поздняя граница динамический тип, который поддерживает динамический вызов без отражения, взаимодействие с динамическими языками и специальную привязку (например) к объектным моделям документов. В динамичный type разрешает доступ к членам динамически во время выполнения, в отличие от статического / виртуального во время компиляции. Механизм поиска членов расширяем за счет традиционного отражения в качестве механизма отката.

Есть несколько вариантов использования динамичный введите C #:

• Менее подробное использование отражения: путем приведения экземпляра к динамичный type, члены, такие как свойства, методы, события и т. д., могут быть непосредственно вызваны в экземпляре без прямого использования API отражения.
• Взаимодействие с динамическими языками: динамический тип имеет ступица и спица поддержка реализации динамически типизированных объектов и общей инфраструктуры времени выполнения для эффективного поиска членов.
• Создание динамических абстракций на лету: например, динамический объект может обеспечить более простой доступ к объектным моделям документа, таким как XML или XHTML документы.

Java не поддерживает тип с поздним связыванием. Варианты использования динамического типа C # имеют разные соответствующие конструкции в Java:

• Для динамической поздней привязки по имени вызов ранее существовавших типов, следует использовать отражение.
• Для взаимодействия с динамическими языками необходимо использовать некоторую форму API взаимодействия, специфичную для этого языка. В Виртуальная машина Java На платформе реализовано несколько динамических языков, но не существует общего стандарта для передачи объектов между языками. Обычно это включает в себя некоторую форму отражения или подобного отражению API. В качестве примера использования объектов JavaFX из Java.^[28]
• Для создания и взаимодействия с объектами полностью во время выполнения, например, взаимодействия с абстракцией объектной модели документа, должен использоваться специальный API абстракции.

См. Также пример # Взаимодействие с динамическими языками.

Указатели

Java исключает указатели и арифметику указателей в среде выполнения Java. Разработчики языка Java рассудили, что указатели - это одна из основных функций, позволяющих программистам вставлять ошибки в свой код, и решили не поддерживать их.^[9] Java не позволяет напрямую передавать и получать объекты / структуры в / из базовой операционной системы и, следовательно, не нуждается в моделировании объектов / структур для такого конкретного макета памяти, макетов, которые часто будут включать указатели. Связь Java с базовой операционной системой вместо этого основана на Собственный интерфейс Java (JNI), где связь с базовой операционной системой / адаптация к ней осуществляется через внешний клей слой.

Хотя C # позволяет использовать указатели и соответствующей арифметики указателей, у разработчиков языка C # были те же опасения, что указатели потенциально могут использоваться для обхода строгих правил доступа к объектам. Таким образом, C # по умолчанию также исключает указатели.^[29] Однако, поскольку указатели необходимы при вызове многих собственных функций, указатели разрешены в явном небезопасно Режим. Блоки кода или методы, использующие указатели, должны быть отмечены небезопасно ключевое слово, чтобы иметь возможность использовать указатели, а компилятору требуется / небезопасно переключатель, чтобы разрешить компиляцию такого кода. Сборки, скомпилированные с использованием / небезопасно switch помечены как таковые и могут выполняться только в случае явного доверия. Это позволяет использовать указатели и арифметику указателей для прямой передачи и получения объектов в / из операционной системы или других собственных API-интерфейсов с использованием внутренней структуры памяти для этих объектов, а также изолировать такой потенциально небезопасный код в специально доверенных сборках.

Типы ссылок

На обоих языках использованная литература являются центральной концепцией. Все экземпляры классов по ссылке.

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

Помимо слабых ссылок, в Java есть мягкие ссылки. Они очень похожи на слабые ссылки, но JVM не освобождает объекты с мягкими ссылками до тех пор, пока не потребуется память.

Массивы и коллекции

Массивы и коллекции - концепции, представленные в обоих языках.

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

В некоторых случаях многомерные массивы могут повысить производительность из-за увеличения местонахождение (поскольку существует одно разыменование указателя вместо одного для каждого измерения массива, как в случае массивов с зазубринами). Однако, поскольку доступ ко всем элементам массива в многомерном массиве требует умножения / сдвига между двумя или более измерениями, это является преимуществом только в сценариях с очень произвольным доступом.

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

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

Java также поддерживает синтаксис C / C ++:^[38]

 // Допустимо, поскольку числа - это объект типа short [] короткая[] числа = новый короткая[100]; // Верно, но это непонятный код двойной ценности[] = новый двойной[100];

 // Допустимо, поскольку числа - это объект типа short [] короткая[] числа = новый короткая[100]; // Не компилируется! двойной ценности[] = новый двойной[100];

Выражения и операторы

Бокс и распаковка

Оба языка позволяют автоматический бокс и распаковка, т.е. они допускают неявное приведение между любыми примитивными типами и соответствующими ссылочными типами.
В C # примитивные типы являются подтипами типа Object. В Java это не так; любой заданный примитивный тип и соответствующий тип оболочки не имеют конкретных отношений друг с другом, за исключением автобокса и распаковки, которые действуют как синтаксический сахар для обмена между ними. Это было сделано намеренно, чтобы поддерживать обратную совместимость с предыдущими версиями Java, в которых не разрешалось автоматическое приведение типов, и программист работал с двумя отдельными наборами типов: примитивными типами и иерархией типов-оболочек (ссылочных).^[42]

Это различие имеет следующие последствия. Прежде всего, в C # примитивные типы могут определять методы, такие как переопределение Object Нанизывать() метод. В Java эту задачу выполняет примитивные классы-оболочки.
Во-вторых, в Java требуется дополнительное приведение всякий раз, когда кто-то пытается напрямую разыменование примитивное значение, так как оно не будет упаковано автоматически. Выражение ((Целое число) 42) .toString () преобразует целочисленный литерал в строку в Java, а 42.ToString () выполняет ту же операцию в C #. Это потому, что последний является вызовом экземпляра примитивного значения 42, а первый - вызов экземпляра объекта типа java.lang.Integer.

Наконец, еще одно отличие заключается в том, что Java активно использует упакованные типы в дженерики (увидеть ниже).

Заявления

Синтаксис

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

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

Ключевые слова и обратная совместимость

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

Разработчики языка Java по возможности избегали новых ключевых слов, предпочитая вместо этого вводить новые синтаксические конструкции, которые ранее были недопустимы, или повторно использовать существующие ключевые слова в новых контекстах. Таким образом, они не поставили под угрозу обратную совместимость. Пример первого можно найти в том, как для цикл был расширен, чтобы принимать итерируемые типы. Пример последнего можно найти в том, как расширяет и (особенно) супер Ключевые слова были повторно использованы для определения границ типов, когда в Java 1.5 были введены универсальные шаблоны. В свое время (Java 1.4) новое ключевое слово утверждать было введено, которое ранее не было зарезервировано как ключевое слово. Это могло сделать ранее действующий код недействительным, если, например, использованный код утверждать как идентификатор. Разработчики решили решить эту проблему с помощью четырехэтапного решения: 1) Введение переключателя компилятора, который указывает, следует ли использовать Java 1.4 или новее, 2) Только маркировка утверждать в качестве ключевого слова при компиляции в Java 1.4 и более поздних версиях, 3) По умолчанию используется значение 1.3, чтобы не отображать предыдущий (не поддерживающий 1.4 код) недействительным и 4) Выдавать предупреждения, если ключевое слово используется в режиме Java 1.3, чтобы разработчики могли изменить код.

Разработчики языка C # ввели несколько новых ключевых слов, начиная с первой версии. Однако вместо того, чтобы определять эти ключевые слова как Глобальный ключевые слова, они определяют их как контекстно-зависимый ключевые слова. Это означает, что даже когда они представили (среди прочего) частичный и Уступать ключевых слов в C # 2.0, использование этих слов в качестве идентификаторов по-прежнему допустимо, поскольку с учетом контекста нет никаких конфликтов между использованием ключевого слова as и использованием в качестве идентификатора. Таким образом, существующий синтаксис C # полностью обратно совместим с исходным кодом, написанным для любой предыдущей версии, без указания используемой языковой версии.

переключатель(цвет){    кейс цвет.Синий:        Консоль.WriteLine(«Цвет синий»);        перерыв;    кейс цвет.Темно-синий:        Консоль.WriteLine(«Цвет темный»);        перейти к кейс цвет.Синий;    // ...}

общественный int readItem() бросает Ява.io.IOException {    // ...}

// Создаем небольшой файл "test.txt", записываем строку,// ... и закрыть его (даже если возникнет исключение)с помощью (StreamWriter файл = новый StreamWriter("test.txt")){    файл.Написать("тестовое задание");}

пытаться (BufferedReader br = новый BufferedReader(новый FileReader(дорожка))) {    вернуть br.readLine();}

Объектно-ориентированного программирования

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

Частичный класс

C # позволяет разделить определение класса на несколько исходных файлов с помощью функции, называемой частичные классы. Каждая часть должна быть помечена ключевым словом частичный. Все части должны быть представлены компилятору как часть одной компиляции. Детали могут ссылаться на элементы из других деталей. Части могут реализовывать интерфейсы, а одна часть может определять базовый класс. Эта функция полезна в сценариях генерации кода (например, пользовательский интерфейс (UI) design), где генератор кода может предоставить одну часть, а разработчик - другую для совместной компиляции. Таким образом, разработчик может редактировать свою часть без риска того, что генератор кода позже перезапишет этот код. В отличие от механизма расширения класса, частичный класс позволяет круговой зависимости между его частями, поскольку они гарантированно будут разрешены во время компиляции. В Java нет соответствующей концепции.

Внутренние и местные классы

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

В Java, если не объявлен внутренний класс статический, ссылка на экземпляр внутреннего класса несет с собой ссылку на внешний класс. В результате код внутреннего класса имеет доступ как к статическим, так и нестатическим членам внешнего класса. Чтобы создать экземпляр нестатического внутреннего класса, необходимо назвать экземпляр охватывающего внешнего класса.^[49] Это делается с помощью нового новый-оператор, представленный в JDK 1.3: externalClassInstance.new Outer.InnerClass (). Это можно сделать в любом классе, который имеет ссылку на экземпляр внешнего класса.

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

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

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

Мероприятие

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

Увидеть Вот для получения информации о том, как события реализованы в Java.

Перегрузка операторов и преобразования

Перегрузка оператора и определяемые пользователем бросает - это отдельные функции, цель которых - позволить новым типам стать первоклассными гражданами в системе типов. Используя эти функции в C #, такие типы, как Сложный и десятичная дробь были интегрированы так, что обычные операторы, такие как сложение и умножение, работают с новыми типами. В отличие от C ++, C # действительно ограничивает использование перегрузки операторов, запрещая это для операторов новый, ( ), ||, &&, =, и любые варианты составных операторов, например +=. Но составные операторы будут вызывать перегруженные простые операторы, например -= вызов - и =.^[50]

Java не включает перегрузку операторов или настраиваемые преобразования, чтобы предотвратить злоупотребление функцией и сохранить простой язык.^[51]

Индексатор

C # также включает индексаторы что можно рассматривать как частный случай перегрузки оператора (например, C ++ оператор []) или параметризованный получить/набор свойства. Индексатор - это свойство с именем этот[] который использует один или несколько параметров (индексов); индексы могут быть объектами любого типа:

мой список[4] = 5;строка имя = xmlNode.Атрибуты["имя"];заказы = customerMap[клиент];

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

Поля и инициализация

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

И в C #, и в Java поля объекта могут быть инициализированы либо инициализаторы переменных (выражения, которые могут быть присвоены переменным там, где они определены) или конструкторы (специальные подпрограммы, которые выполняются при создании объекта). Кроме того, Java содержит инициализаторы экземпляров, которые представляют собой анонимные блоки кода без аргументов, которые запускаются после явного (или неявного) вызова конструктора суперкласса, но до его выполнения.

C # инициализирует поля объекта в следующем порядке при создании объекта:

1. Производные статические поля
2. Производный статический конструктор
3. Поля производных экземпляров
4. Базовые статические поля
5. Базовый статический конструктор
6. Поля базового экземпляра
7. Конструктор базового экземпляра
8. Конструктор производного экземпляра

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

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

В Java порядок инициализации следующий:

1. Вызов другого конструктора (либо класса объекта, либо суперкласса объекта)
2. Инициализаторы переменных экземпляра и инициализаторы экземпляра (в порядке их появления в исходном коде)
3. Тело конструктора

Как и в C #, новый объект создается путем вызова определенного конструктора. Внутри конструктора первая инструкция может быть вызовом другого конструктора. Если это опущено, вызов конструктора суперкласса без аргументов добавляется неявно компилятором. В противном случае либо другой перегруженный конструктор класса объекта может быть вызван явно, либо может быть вызван конструктор суперкласса. В первом случае вызываемый конструктор снова вызовет другой конструктор (либо из класса объекта, либо из его подкласса), и цепочка рано или поздно завершится вызовом одного из конструкторов суперкласса.

После вызова другого конструктора (который вызывает прямой вызов конструктора суперкласса и так далее, вплоть до класса Object) инициализируются переменные экземпляра, определенные в классе объекта. Даже если для некоторых переменных явно не определены инициализаторы переменных, эти переменные инициализируются значениями по умолчанию. Обратите внимание, что переменные экземпляра, определенные в суперклассах, уже инициализированы к этому моменту, потому что они были инициализированы конструктором суперкласса при его вызове (либо кодом конструктора, либо инициализаторами переменных, выполненными до кода конструктора, либо неявно значениями по умолчанию). В Java инициализаторы переменных выполняются в соответствии с их текстовым порядком в исходном файле.

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

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

Утилизация ресурсов

Оба языка в основном используют вывоз мусора как средство освобождения ресурсов памяти, а не явного освобождения памяти. В обоих случаях, если объект содержит ресурсы разных типов, помимо памяти, такие как дескрипторы файлов, графические ресурсы и т. Д., То он должен быть явно уведомлен, когда приложение больше не использует его. И C #, и Java предлагают интерфейсы для таких детерминированных утилизация и как C #, так и Java (начиная с Java 7) содержат операторы автоматического управления ресурсами, которые автоматически вызывают методы удаления / закрытия на этих интерфейсах.

Методы

Методы расширения и методы по умолчанию

Используя специальный этот указатель на первый параметр метода, C # позволяет методу действовать так, как если бы он был методом-членом типа первого параметра. Эта расширение иностранного класса является чисто синтаксическим. Должен быть объявлен метод расширения статический и определен внутри чисто статического класса. Этот метод должен подчиняться любому ограничению доступа к члену, как и любой другой метод, внешний по отношению к классу; таким образом, статические методы не могут нарушить инкапсуляцию объекта.^[57][58] «Расширение» активно только в областях, в которые было импортировано пространство имен статического класса хоста.

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

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

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

Частичные методы

Относится к частичные классы C # позволяет указывать частичные методы внутри частичных классов. Частичный метод - это намеренное объявление метода с несколькими ограничениями на подпись. Ограничения гарантируют, что если определение не предоставляется какой-либо частью класса, то метод и каждый его вызов можно безопасно удалить.^[59] Эта функция позволяет коду предоставлять большое количество точек перехвата (например, шаблонный метод GoF шаблон проектирования) без дополнительных затрат времени выполнения, если эти точки расширения не используются другой частью класса во время компиляции. В Java нет соответствующей концепции.

Виртуальные методы

Методы в C # не являютсявиртуальный по умолчанию и при желании должен быть объявлен как виртуальный. В Java все нестатические неприватные методы являются виртуальными. Виртуальность гарантирует, что самые последние отменять потому что метод всегда будет вызываться, но требует определенных затрат времени выполнения при вызове, поскольку эти вызовы не могут быть обычно встроенный, и требуют косвенного вызова через таблица виртуальных методов. Однако некоторые реализации JVM, включая эталонную реализацию Oracle, реализуют встраивание наиболее часто называемых виртуальных методов.

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

Это означает, что по умолчанию в Java и только при явном включении в C # новые методы могут быть определены в производном классе с тем же именем и подписью, что и в его базовом классе. Когда метод вызывается для ссылки на суперкласс такого объекта, «самая глубокая» переопределяет реализацию базовый класс'будет вызываться в соответствии с конкретным подклассом объекта, на который имеется ссылка.

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

Чтобы смягчить это, C # требует, чтобы, если метод предназначен для переопределения унаследованного метода, отменять ключевое слово должно быть указано. В противном случае метод «скроет» унаследованный метод. Если ключевое слово отсутствует, компилятор выдает соответствующее предупреждение, которое можно отключить, указав новый ключевое слово. Это позволяет избежать проблемы, которая может возникнуть из-за расширения базового класса с помощью не частного метода (то есть унаследованной части пространства имен), сигнатура которого уже используется производным классом. В Java есть аналогичная проверка компилятора в виде @Override аннотации метода, но она не является обязательной, и в ее отсутствие большинство компиляторов не предоставляют комментарии (но метод будет переопределен).

Постоянные / неизменяемые параметры

В Java можно предотвратить переназначение локальной переменной или параметра метода с помощью окончательный ключевое слово. Применение это ключевое слово в переменную примитивного типа заставляет переменную стать неизменной. Однако применяя окончательный к переменной ссылочного типа только предотвращает присвоение ей другого объекта. Это не предотвратит изменение данных, содержащихся в объекте. Начиная с C # 7, можно предотвратить переназначение параметра метода с помощью в ключевое слово, однако это ключевое слово нельзя использовать с локальными переменными. Как и в случае с Java, применение в к параметру только предотвращает переназначение параметра другому значению. По-прежнему можно изменять данные, содержащиеся в объекте.^[60]

общественный int добавить один(окончательный int Икс) {    Икс++; // ОШИБКА: конечную переменную нельзя переназначить    вернуть Икс;}общественный Список добавить один(окончательный Список<Целое число> список) {    список.Добавить(1); // ОК: все еще можно изменить                 // конечная (ссылочного типа) переменная    вернуть список;}

общественный int Добавить один(в int Икс) {    Икс++; // ОШИБКА: параметр только для чтения не может быть переназначен    вернуть Икс;}общественный Список<int> Добавить один(в Список<int> список) {    список.Добавить(1); // ОК: все еще можно изменить                 // параметр только для чтения (ссылочный тип)    вернуть список;}

Оба языка не поддерживают основные функции const-правильность что существует в C/C ++, что делает метод постоянным.

В Java слово «константа» произвольно определяется как статический окончательный поле. Только эти переменные являются переменными, состоящими только из заглавных букв, имена которых разделяются знаком нижнее подчеркивание^{[нужна цитата]}. Параметр, который только окончательный не считается константой, хотя это может быть так в случае примитивный тип данных или неизменный класс, как Строка.

Генераторные методы

Любой метод C #, объявленный как возвращающий IEnumerable, IEnumerator или общие версии этих интерфейсов могут быть реализованы с помощью Уступать синтаксис. Это форма ограниченных продолжений, генерируемых компилятором, и она может значительно сократить код, необходимый для обхода или генерации последовательностей, хотя вместо этого этот код просто генерируется компилятором. Эта функция также может использоваться для реализации бесконечных последовательностей, например, последовательности Числа Фибоначчи.

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

См. Также пример Последовательность Фибоначчи ниже.

Явная реализация интерфейса

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

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

Эталонные (входные / выходные) параметры

Аргументы примитивных типов (например, int, double) методу передаются по значению в Java, тогда как объекты передаются по ссылке. Это означает, что метод работает с копиями переданных ему примитивов, а не с фактическими переменными. Напротив, реальные объекты в некоторых случаях могут быть изменены. В следующем примере объект String не изменяется. Объект класса «а» изменен.

В C # можно принудительно указать ссылку с ссылка ключевое слово, похожее на C ++ и в некотором смысле на C. Эта функция C # особенно полезна, когда нужно создать метод, возвращающий более одного объекта. В Java попытка вернуть несколько значений из метода не поддерживается, если только не используется оболочка, в данном случае с именем «Ref».^[61]

класс PassByRefTest {    статический класс Ссылка<Т> {        Т вал;        Ссылка(Т вал) { этот.вал = вал; }    }        статический пустота Измени меня(Ссылка<Строка> s) {        s.вал = "Изменено";    }    статический пустота своп(Ссылка<Целое число> Икс, Ссылка<Целое число> y) {        int темп = Икс.вал;        Икс.вал = y.вал;        y.вал = темп;    }    общественный статический пустота основной(Строка[] аргументы) {        вар а = новый Ссылка(5);        вар б = новый Ссылка(10);        вар s = новый Ссылка("все еще без изменений");                своп(а, б);        Измени меня(s);        Система.вне.println( "а =" + а.вал + ", " +                            "b =" + б.вал + ", " +                            "s =" + s.вал );    }}

класс PassByRefTest {    общественный статический пустота Измени меня(вне строка s)     {        s = "Изменено";    }    общественный статический пустота Своп(ссылка int Икс, ссылка int y)     {        int темп = Икс;        Икс = y;        y = темп;    }    общественный статический пустота Основной(строка[] аргументы)     {        int а = 5;        int б = 10;        строка s = "все еще без изменений";        Своп(ссылка а, ссылка б);        Измени меня(вне s);        Система.Консоль.WriteLine("а =" + а + ", " +                                 "b =" + б + ", " +                                 "s =" + s);    }}

Исключения

Проверенные исключения

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

Проверенные исключения могут способствовать правильной практике программирования, гарантируя устранение всех ошибок. Однако Андерс Хейлсберг, главный архитектор языка C #, утверждает, что они были до некоторой степени экспериментом в Java и что они не показали своей ценности, за исключением небольших примеров программ.^[62][63]

Одна критика заключается в том, что проверенные исключения побуждают программистов использовать пустой блок catch (catch (исключение e) {}),^[64] который незаметно перехватывает исключения, вместо того, чтобы позволить исключениям распространяться на процедуру обработки исключений более высокого уровня. Однако в некоторых случаях цепочка исключений вместо этого можно применить, повторно выбрасывая исключение в исключение оболочки. Например, если объект изменен для доступа к базе данных вместо файла, SQLException может быть пойман и повторно брошен как IOException, поскольку вызывающей стороне может не потребоваться знать внутреннюю работу объекта.

Однако не все программисты согласны с такой позицией. Джеймс Гослинг и другие утверждают, что проверенные исключения полезны, а их неправильное использование вызвало проблемы. Бесшумный перехват исключений возможен, да, но необходимо явно указать, что делать с исключением, в отличие от непроверенных исключений, которые по умолчанию не позволяют ничего делать. Его можно игнорировать, но код должен быть написан явно, чтобы его игнорировать.^[65][66]

Попробуй-поймай-наконец

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

Распространенная причина использования попробуй наконец Blocks - это защита кода управления ресурсами, что гарантирует высвобождение ценных ресурсов в блоке finally. C # имеет с помощью как синтаксическое сокращение этого распространенного сценария, в котором Утилизировать () метод объекта с помощью всегда называется.

Довольно тонкая разница - это момент трассировки стека создается при возникновении исключения. В Java трассировка стека создается в момент создания исключения.

класс Фу {    Исключение вверх = новый Исключение();    int фу() бросает Исключение {        бросить вверх;    }}

Исключение в приведенном выше операторе всегда будет содержать трассировку стека конструктора - независимо от того, как часто вызывается foo. С другой стороны, в C # трассировка стека создается в момент выполнения throw.

класс Фу{    Исключение е = новый Исключение();    int фу()    {        пытаться        {            бросить е;        }        ловить (Исключение е)        {            бросить;        }    }}

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

Наконец блоки

Java позволяет потоку управления оставить Ну наконец то блок пытаться выписку, независимо от того, как она была введена. Это может вызвать другой оператор потока управления (например, вернуть), который должен быть прекращен в середине выполнения. Например:

int фу() {    пытаться {        вернуть 0;    } Ну наконец то {        вернуть 1;    }}

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

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

Дженерики

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

Стирание типов по сравнению с повторными обобщениями

Дженерики в Java являются конструкцией только для языка; они реализованы только в компиляторе. Сгенерированные файлы классов включают общие подписи только в форме метаданных (позволяя компилятору компилировать для них новые классы). Среда выполнения ничего не знает о системе универсальных типов; дженерики не являются частью JVM. Вместо этого универсальные классы и методы преобразуются во время компиляции с помощью процесса, называемого стирание типа. При этом компилятор заменяет все универсальные типы их сырой version и соответствующим образом вставляет приведение / проверку в клиентский код, где используются тип и его методы. Результирующий байт-код не будет содержать ссылок на какие-либо общие типы или параметры (см. Также Дженерики в Java).

Спецификация языка Java намеренно запрещает определенное использование универсальных типов; это необходимо для реализации дженериков через стирание типа, и для обеспечения совместимости миграции.^[67] Исследования по добавлению обобщенных дженериков на платформу Java продолжаются в рамках Проект Валгалла.

C # основан на поддержке дженериков из виртуальной исполнительной системы, то есть это не просто языковая функция. Язык - это просто интерфейс для поддержки кросс-языковых обобщений в CLR. Во время компиляции генерики проверяются на правильность, но генерация кода для осуществлять дженерики откладываются до времени загрузки класса. Клиентский код (код, вызывающий универсальные методы / свойства) полностью скомпилирован и может безопасно предполагать, что универсальные типы являются безопасными по типу. Это называется овеществление. Во время выполнения, когда уникальный набор параметров типа для универсального класса / метода / делегата встречается впервые, загрузчик / проверяющий класс синтезирует конкретный дескриптор класса и сгенерирует реализации метода. Во время генерации реализаций методов все ссылочные типы будут считаться одним типом, поскольку ссылочные типы могут безопасно использовать одни и те же реализации. Это просто с целью реализация код. Различные наборы ссылочных типов по-прежнему будут иметь уникальные дескрипторы типов; их таблицы методов будут просто указывать на один и тот же код.

В следующем списке показаны некоторые различия между Java и C # при управлении универсальными шаблонами. Это не является исчерпывающим:^[68]

Пара<Строка, Строка>[] десять пар = новый Пара[10]; //ОК

объект десять пар = новый Пара<int, строка>[10]; // ОК

общественный класс Искать<K, V> {    общественный V[] getEmptyValues(K ключ) {        вернуть (V[]) новый Объект[0]; // ОК    }}

общественный класс Искать<K, V расширяет Сопоставимый<V>> {    общественный V[] getEmptyValues(K ключ) {        вернуть (V[]) новый Сопоставимый[0];    }}

общественный класс Искать<K, V> {    общественный V[] GetEmptyValues(K ключ) {        вернуть новый V[0]; // ОК    }}

C # позволяет использовать универсальные шаблоны непосредственно для примитивных типов. Вместо этого Java позволяет использовать упакованные типы в качестве параметров типа (например, Список <Целое число> вместо того Список ). За это приходится платить, так как все такие значения должны быть упакованы / распакованы при использовании, и все они должны быть размещены в куче. Однако универсальный тип может быть специализирован с типом массива примитивного типа в Java, например Список позволено.^[73]Несколько сторонних библиотек реализовали базовые коллекции на Java с резервными примитивными массивами, чтобы сохранить время выполнения и оптимизацию памяти, которую обеспечивают примитивные типы.^[74]

Совместимость миграции

Дизайн стирания шрифтов в Java был мотивирован требованием дизайна для достижения совместимость миграции - не путать с Обратная совместимость. В частности, первоначальное требование было "… Должен быть чистый, очевидный путь миграции для API коллекций, которые были введены в платформу Java 2".^[42] Это было разработано таким образом, чтобы любые новые универсальные коллекции могли передаваться методам, ожидающим одного из уже существующих классов коллекции.^[75]

Дженерики C # были введены в язык с сохранением полной обратной совместимости, но не полностью совместимость миграции: Старый код (до C # 2.0) работает без изменений в новой среде выполнения, поддерживающей универсальные типы, без перекомпиляции. Что касается совместимость миграциибыли разработаны новые универсальные классы коллекций и интерфейсы, которые дополняли неуниверсальные коллекции .NET 1.x, а не заменяли их. В дополнение к универсальным интерфейсам коллекции новые универсальные классы коллекции реализуют неуниверсальные интерфейсы коллекции, где это возможно. Это предотвращает использование новых общих коллекций с уже существующими (не имеющими общего характера) методами, если эти методы закодированы для использования коллекции. классы.

Ковариация и контравариантность

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

Функциональное программирование

Закрытие

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

C # поддерживает замыкания как анонимные методы или лямбда-выражения с полнофункциональным закрытие семантика.^[79][80]

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

Когда ссылку на метод можно передать для последующего выполнения, возникает проблема, что делать, когда метод имеет ссылки на переменные / параметры в своей лексической области видимости. Замыкания C # могут обращаться к любой переменной / параметру из своей лексической области видимости. В анонимных внутренних классах Java разрешены только ссылки на конечные члены лексической области видимости, что требует от разработчика отмечать, какие переменные сделать доступными и в каком состоянии (возможно, потребуется упаковка).

Лямбды и деревья выражений

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

C #, в отличие от Java, позволяет использовать лямбда-функции как способ определения специальных структур данных, называемых деревьями выражений. Видны ли они как исполняемая функция или как структура данных, зависит от компилятора. вывод типа и какой тип переменной или параметра им присваивается или приводится. Лямбды и деревья выражений играют ключевую роль в Интегрированный языковой запрос (LINQ).

Метаданные

Эта секция нуждается в расширении. Вы можете помочь добавляя к этому. (Февраль 2015 г.)

Предварительная обработка, компиляция и упаковка

Пространства имен и содержимое файла

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

Оба языка позволяют импортировать классы (например, импорт java.util. * в Java), позволяя ссылаться на класс, используя только его имя. Иногда классы с одинаковыми именами существуют в нескольких пространствах имен или пакетах. На такие классы можно ссылаться, используя полностью определенные имена или импортируя только выбранные классы с другими именами. Для этого Java позволяет импортировать один класс (например, импорт java.util.List).C # позволяет импортировать классы под новым локальным именем, используя следующий синтаксис: с помощью Консоль = System.Console. Также он позволяет импортировать специализации классов в виде с помощью IntList = System.Collections.Generic.List <int>.

Оба языка имеют статический импорт синтаксис, который позволяет использовать краткое имя некоторых или всех статических методов / полей в классе (например, разрешая foo (бар) где foo () может быть статически импортирован из другого класса). C # имеет синтаксис статического класса (не путать со статическими внутренними классами в Java), который ограничивает класс только статическими методами. C # 3.0 представляет методы расширения чтобы пользователи могли статически добавлять метод к типу (например, разрешая foo.bar () где бар() может быть импортированным методом расширения, работающим с типом фу).

В Sun Microsystems Компилятор Java требует, чтобы имя исходного файла соответствовало единственному общедоступному классу внутри него, в то время как C # допускает использование нескольких общедоступных классов в одном файле и не накладывает ограничений на имя файла. C # 2.0 и более поздние версии позволяют разделить определение класса на несколько файлов с помощью частичный ключевое слово в исходном коде. В Java открытый класс всегда находится в собственном исходном файле. В C # файлы исходного кода и разделение логических единиц не связаны тесно.

Условная компиляция

В отличие от Java, C # реализует условная компиляция с помощью директивы препроцессора. Он также обеспечивает Условный атрибут для определения методов, которые вызываются только при определении заданной константы компиляции. Сюда, утверждения может быть предоставлен как фреймворк с помощью метода Debug.Assert (), который оценивается только тогда, когда ОТЛАЖИВАТЬ константа определена. Начиная с версии 1.4, Java предоставляет языковые функции для утверждений, которые по умолчанию отключены во время выполнения, но могут быть включены с помощью -enableassertions или -еа переключатель при вызове JVM.

Потоковые и асинхронные функции

Оба языка включают нить синхронизация механизмы как часть синтаксиса языка.

Параллелизм на основе задач для C #

В .NET Framework 4.0 была представлена ​​новая модель программирования на основе задач, которая заменила существующую асинхронную модель на основе событий. API основан на Задача и Задача классы. Задачи можно составлять и объединять в цепочки.

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

общественный статический класс SomeAsyncCode{    общественный статический Задача<XDocument> GetContentAsync()    {        HttpClient httpClient = новый HttpClient();        вернуть httpClient.GetStringAsync(«www.contoso.com»).Продолжить с((задача) => {            строка responseBodyAsText = задача.Результат;            вернуть XDocument.Разобрать(responseBodyAsText);        });    }}вар т = SomeAsyncCode.GetContentAsync().Продолжить с((задача) => {    вар xmlDocument = задача.Результат;});т.Начните();

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

общественный статический класс SomeAsyncCode{    общественный статический асинхронный Задача<XDocument> GetContentAsync()    {        HttpClient httpClient = новый HttpClient();        строка responseBodyAsText = Ждите httpClient.GetStringAsync(«www.contoso.com»);        вернуть XDocument.Разобрать(responseBodyAsText);    }}вар xmlDocument = Ждите SomeAsyncCode.GetContentAsync();// Задача будет запускаться по вызову с ожиданием.

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

Параллелизм на основе задач для Java

Java поддерживает потоки, начиная с JDK 1.0. Java предлагает высокую гибкость для выполнения потоков, часто называемых задачами. Это делается путем реализации функционального интерфейса ( java.lang.Runnable interface), определяя единственный метод void no-args, как показано в следующем примере:

вар myThread = новый Нить(() -> {    вар threadName = Нить.currentThread().getName();    Система.вне.println("Здравствуйте " + threadName);});myThread.Начните();

Подобно C #, в Java есть механизм более высокого уровня для работы с потоками. Исполнители может выполнять асинхронные задачи, а также управлять группой подпроцессов. Все нити ИсполнительУслуги экземпляры обрабатываются в бассейн. Эта ExecutorService Экземпляр будет повторно использоваться «под капотом» для реванантных задач, поэтому можно запускать столько одновременных задач, сколько хочет программист, на протяжении всего жизненного цикла приложения с использованием одного экземпляра службы-исполнителя.

Вот так выглядит первый пример потока с использованием исполнителей:

ExecutorService исполнитель = Исполнители.newSingleThreadExecutor();исполнитель.Разместить(() -> {    вар threadName = Нить.currentThread().getName();    Система.вне.println("Здравствуйте " + threadName);});

В ExecutorService экземпляр также поддерживает Вызываемый интерфейс, еще один интерфейс с одним методом, например Работоспособен но подпись содержащегося метода Вызываемый возвращает значение. Таким образом, лямбда-выражение также должно возвращать значение.

общественный статический класс SomeAsyncCode {    ExecutorService исполнитель = Исполнители.newSingleThreadExecutor();    общественный статический Будущее<Строка> getContentAsync(){        вернуть исполнитель.Разместить(() -> {                       HttpRequest httpReq = HttpRequest.newBuilder()                .ури(новый URI("https://www.graalvm.org"))                .строить();                        вернуть HttpClient.newHttpClient()                .Отправить(httpReq, BodyHandlers.ofString())                .тело();        });    }}вар webPageResult = SomeAsyncCode.getContentAsync().получить();

Вызов метода получить() блоки текущий поток и ожидает, пока вызываемый объект завершится, прежде чем вернуть значение (в примере, содержимое веб-страницы):

Дополнительные возможности

Числовые приложения

Для адекватной поддержки приложений в области математических и финансовых вычислений существует несколько языковых функций.^[87]

Java strictfp ключевое слово позволяет выполнять строгие вычисления с плавающей запятой для области кода. Строгие вычисления с плавающей запятой требуют, чтобы даже если платформа обеспечивает более высокую точность вычислений, промежуточные результаты должны быть преобразованы в одинарные / двойные. Это гарантирует, что строгие вычисления с плавающей запятой возвращают точно такой же результат на всех платформах. Без строгой плавающей точки реализация платформы может использовать более высокую точность для промежуточных результатов во время вычислений. C # позволяет реализации для данной аппаратной архитектуры всегда использовать более высокую точность для промежуточных результатов, если они доступны, то есть C # не позволяет программисту опционально принудительно использовать промежуточные результаты с потенциально более низкой точностью single / double.^[88]

Хотя арифметика с плавающей запятой в Java в значительной степени основана на IEEE 754 (стандарт для двоичной арифметики с плавающей запятой), некоторые функции не поддерживаются даже при использовании модификатора strictfp, например, флаги исключения и направленные округления, возможности, предусмотренные стандартом IEEE Standard 754 (см. Критика Java, арифметика с плавающей запятой).

C # предоставляет встроенный десятичный тип,^[89] который имеет более высокую точность (но меньший диапазон), чем двойной Java / C #. Тип decimal - это 128-битный тип данных, подходящий для финансовых и денежных расчетов. Десятичный тип может представлять значения в диапазоне от 1,0 × 10.⁻²⁸ примерно до 7,9 × 10²⁸ с 28–29 значащими цифрами.^[90] В структуре используется перегрузка операторов C #, чтобы можно было управлять десятичными числами с помощью таких операторов, как +, -, * и /, как и других примитивных типов данных.

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

В BigInteger,^[3] и Сложный^[91] типы, предоставляемые с C #, позволяют представлять и манипулировать целыми числами произвольной точности и комплексными числами соответственно. В структурах используется перегрузка операторов C #, поэтому экземплярами можно управлять с помощью таких операторов, как +, -, *, и /, как и другие примитивные типы данных. Стандартная библиотека C # не имеет классов для работы с числами произвольной точности с плавающей запятой (см. программное обеспечение для арифметики произвольной точности).

C # может помочь математическим приложениям с проверил и не отмечен операторы, которые позволяют включать или отключать проверку во время выполнения для арифметическое переполнение для региона кода.

Интегрированный языковой запрос (LINQ)

C # s Интегрированный языковой запрос (LINQ) - это набор функций, разработанных для совместной работы, позволяющих выполнять запросы на языке, и является отличительной особенностью C # и Java.

LINQ состоит из следующих функций:

• Методы расширения позволяют расширять существующие интерфейсы или классы новыми методами. Реализации могут быть общими, или интерфейс может иметь специальную реализацию.
• Лямбды позволяют функционально выражать критерии.
• Деревья выражений позволяют конкретной реализации захватывать лямбду как абстрактное синтаксическое дерево а не исполняемый блок. Это может быть использовано реализациями для представления критериев на другом языке, например в виде SQL-предложение where как в случае, например, Linq, LINQ to SQL.
• Анонимные типы и вывод типов поддерживают захват и работу с типом результата запроса. Запрос может как присоединяться, так и проецироваться на источники запроса, что может привести к типу результата, который не может быть назван.
• Выражения запроса для поддержки синтаксиса, знакомого SQL пользователей.
• Типы, допускающие значение NULL (повышенные), чтобы обеспечить лучшее соответствие с поставщиками запросов, которые поддерживают типы, допускающие значение NULL, например, SQL.

Собственная совместимость

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

Кроме того, сторонние библиотеки предоставить Java-Компонентная объектная модель (COM) мост, например, JACOB (свободный) и J-Integra для COM (проприетарный).

Вызов платформы .NET (P / Invoke) предлагает ту же возможность, разрешая вызовы из C # на то, что Microsoft называет unуправляемый код. С помощью атрибутов метаданных программист может точно контролировать параметры и результаты. выстроен, таким образом избегая внешнего связующего кода, необходимого для эквивалентного JNI в Java. P / Invoke обеспечивает почти полный доступ к процедурным API (таким как Win32 или POSIX), но ограниченный доступ к библиотекам классов C ++.

Кроме того, .NET Framework также предоставляет мост .NET-COM, позволяющий доступ к COM-компонентам, как если бы они были первоклассными объектами .NET.

C # также позволяет программисту отключать обычную проверку типов и другие функции безопасности CLR, что затем позволяет использовать переменные-указатели. При использовании этой функции программист должен пометить код с помощью небезопасно ключевое слово. JNI, P / Invoke и «небезопасный» код являются одинаково рискованными функциями, обнажая возможные дыры в безопасности и нестабильность приложения. Преимущество небезопасного управляемого кода перед P / Invoke или JNI заключается в том, что он позволяет программисту продолжать работать в знакомой среде C # для выполнения некоторых задач, которые в противном случае потребовали бы вызова неуправляемого кода. Сборка (программа или библиотека), использующая небезопасный код, должна быть скомпилирована с помощью специального переключателя и будет отмечена как таковая. Это позволяет средам выполнения принимать особые меры предосторожности перед выполнением потенциально опасного кода.

Среды выполнения

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

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

Примеры

Ввод, вывод

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

импорт java.nio.file. *;класс FileIOTest {    общественный статический пустота основной(Строка[] аргументы) бросает Исключение {        вар линии = Файлы.readAllLines(Пути.получить("input.txt"));        Файлы.записывать(Пути.получить("output.txt"), линии);    }}

с помощью System.IO;класс FileIOTest{    общественный статический пустота Основной(строка[] аргументы)    {        вар линии = файл.ReadLines("input.txt");        файл.WriteAllLines("output.txt", линии);    }}

Интеграция типов, определяемых библиотекой

C # позволяет интегрировать типы, определяемые библиотекой, с существующими типами и операторами, используя настраиваемые неявные / явные преобразования и перегрузку операторов, как показано в следующем примере:

вар большое количество =    новый BigInteger("123456789012345678901234567890");вар ответ = большое количество.умножать(новый BigInteger("42"));вар квадрат = большое количество.умножать(большое количество);вар сумма = большое количество.Добавить(большое количество);

вар большое количество =    BigInteger.Разобрать("123456789012345678901234567890");вар ответ = большое количество*42;вар квадрат = большое количество*большое количество;вар сумма = большое количество + большое количество;

Делегаты C # и эквивалентные конструкции Java

    // целевой класс    класс Цель {        общественный логический targetMethod(Строка аргумент) {            // сделай что-нибудь            вернуть правда;        }    }    // Применение    пустота сделай что-нибудь() {        // создаем цель с помощью целевого метода        вар цель = новый Цель();        // захватываем ссылку на метод        Функция<Строка, Булево> ivk = цель::targetMethod;        // вызывает указанный метод        логический результат = ivk.применять("строка аргументов");    }

    // целевой класс    класс Цель    {        общественный bool TargetMethod(строка аргумент)        {            // сделай что-нибудь            вернуть правда;        }    }    // Применение    пустота Сделай что-нибудь()    {        // создаем цель с помощью целевого метода        вар цель = новый Цель();        // захватываем делегат для последующего вызова        Func<строка, bool> dlg = цель.TargetMethod;        // вызываем делегата        bool результат = dlg("строка аргументов");    }

Тип подъемный

вар а = Необязательный.из(42);вар б = Необязательный.пустой();// orElse (0) возвращает 0, если значение b равно нулювар c = а.получить() * б.orElse(0);

int? а = 42;int? б = значение NULL;// c получит нулевое значение// потому что * снят и один из операндов нулевойint? c = а * б;

Совместимость с динамическими языками

В этом примере показано, как можно использовать Java и C # для создания и вызова экземпляра класса, реализованного на другом языке программирования. Класс «Глубокая мысль» реализован с помощью Язык программирования Ruby и представляет собой простой калькулятор, который умножит два входных значения (а и б) когда Рассчитать вызывается метод. Помимо обычного способа, в Java есть GraalVM, виртуальная машина, способная запускать любой реализованный язык программирования.

Контекст полиглот = Контекст.newBuilder().allowAllAccess(правда).строить();//РубинЦенность rubyArray = полиглот.оценка("Рубин", "[1,2,42,4]");int rubyResult = rubyArray.getArrayElement(2).asInt();// PythonЦенность pythonArray = контекст.оценка("питон", "[1,2,42,4]");int pythonResult = pythonArray.getArrayElement(2).asInt();// JavaScriptЦенность jsArray = полиглот.оценка("js", "[1,2,42,4]");int jsResult = jsArray.getArrayElement(2).asInt();//РЦенность rArray = полиглот.оценка("Р", "c (1,2,42,4)");int rResult = rArray.getArrayElement(2).asInt();// LLVM (в данном случае C, но может быть C ++, Go, Basic и т. Д.)Источник источник = Источник.newBuilder("llvm", новый файл("C_Program.bc")).строить();Ценность cpart = полиглот.оценка(источник);cpart.getMember("основной").выполнять();

// инициализируем двигательвар призываемый = новый ScriptEngineManager().getEngineByName("джруби");вар rubyFile = новый FileReader("Deepoughtt.rb");двигатель.оценка(fr);

// инициализируем двигательвар время выполнения = Скрипт.CreateFromConfiguration();динамичный глобалы = время выполнения.Глобалы;время выполнения.ExecuteFile("Deepoughtt.rb");

// создаем новый экземпляр калькулятора «Глубокая мысль»вар расчет = глобалы.Глубокая мысль.@new();// устанавливаем входные значения калькуляторарасчет.а = 6;расчет.б = 7;// вычисляем результатвар ответ = расчет.Рассчитать();

// создаем новый экземпляр калькулятора «Глубокая мысль»вар calcClass = двигатель.оценка("Глубокая мысль");вар расчет = призываемый.invokeMethod(calcClass, "новый");// устанавливаем входные значения калькуляторапризываемый.invokeMethod(расчет, "а =", 6);призываемый.invokeMethod(расчет, "b =", 7);// вычисляем результатвар ответ = призываемый.invokeMethod(расчет, "Рассчитать");

Последовательность Фибоначчи

Этот пример показывает, как Последовательность Фибоначчи могут быть реализованы с использованием двух языков. Версия C # использует преимущества C # методы генератора. Версия Java использует преимущества Ручей ссылки на интерфейсы и методы. И в примерах Java, и в C # используется K&R стиль для форматирования кода классов, методов и операторов.

// Последовательность ФибоначчиРучей.генерировать(новый Поставщик<Целое число>() {    int а = 0;    int б = 1;    общественный Целое число получить() {        int темп = а;        а = б;        б = а + темп;        вернуть темп;    }}).предел(10).для каждого(Система.вне::println);

// Последовательность Фибоначчиобщественный IEnumerable<int> Фибоначчи() {    int а = 0;    int б = 1;    в то время как (правда)     {        Уступать вернуть а;        (а, б) = (б, а + б);    }}

// выводим 10 первых чисел Фибоначчидля каждого (вар Это в Фибоначчи().Взять(10)) {    Консоль.WriteLine(Это);}

запись Пара(int Икс, int y);Ручей.повторять(новый Пара(0,1), п -> новый Пара(п.y(), п.Икс() + п.y()))    .предел(10)    .карта(п -> п.Икс())    .для каждого(Система.вне::println);

Смотрите также

• Сравнение C # и VB.NET
• Сравнение Java и C ++
• Сравнение платформ Java и .NET
• Язык программирования Java

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

внешние ссылки

• Переход на C # и .NET Framework в MSDN
• C # и Java: сравнение языков программирования в MSDN
• Java против C # - код для сравнения кода
• Обзор производительности на девяти языках
• Сеть разработчиков Microsoft (MSDN): Язык программирования C # для разработчиков Java
• Стандартная спецификация языка C # ECMA-334
• Спецификация языка Java (Sun)
• Состояние C #: остается ли он жизнеспособным?