Почему Множественное наследование не позволяется в Java или C#?
Если проблема не устранена, см. Ниже шаги.
Шаг 1 - Добавить комментарий на уровне контроллера
// GET api/documentation
///
/// This is how we create a documentation
///
/// Get()
Шаг 2 - Создать свойство Страница свойств проекта и настроить вывод XML для документации
Шаг 3 - Конфигурация HelpPage
Чтобы настроить HelpPageConfig для использования нашей документации xml файл, перейдите к ~\Areas\HelpPage\HelpPageConfig.cs.
По умолчанию оператор config.SetDocumentationProvider закомментирован. Используйте это утверждение и укажите местоположение DocumentationProvider в нашем XML-файле:
public static void Register(HttpConfiguration config)
{
// Uncomment the following to use the documentation from XML documentation file.
config.SetDocumentationProvider(
new XmlDocumentationProvider(
HttpContext.Current.Server.MapPath("~/App_Data/Documentation.xml")));
}
РЕДАКТИРОВАТЬ:
Местоположение HelpPageConfig в новом проекте Web API 2.2 создан в VS2013 является ~\Areas\HelpPage\App_Start\HelpPageConfig.cs
9 ответов
Короткий ответ: потому что разработчики языка решили этого не делать.
В принципе, казалось, что разработчики .NET и Java не допускают множественное наследование, потому что они рассуждали, что добавление MI добавили слишком большую сложность языкам, но принесли слишком мало преимуществ .
Для более увлекательного и подробного чтения в Интернете доступны некоторые статьи с интервью с некоторыми из языковые дизайнеры. Например, для .NET Крис Брамм (который работал в MS над CLR) объяснил причины, по которым они решили не делать этого:
На самом деле разные языки имеют разные ожидания относительно того, как MI работает. Например, как бывают конфликты решены и есть ли дубликаты баз объединены или избыточны. Прежде чем мы сможем реализовать MI в CLR, мы должны сделать обзор всех языков, рисунок из общих понятий и решить как выразить их в языковой нейтральный манер. Мы бы также должны решить, принадлежит ли МИ CLS и что это будет значить для языки, которым не нужна эта концепция (предположительно, например, VB.NET). Из конечно, это бизнес, которым мы занимаемся как общеязыковая среда выполнения, но мы не успел сделать это для МИ пока.
Количество мест, где ИМ действительно подходит, на самом деле весьма маленький. Во многих случаях несколько наследование интерфейса может получить работу сделано вместо этого. В других случаях вы можете уметь использовать инкапсуляцию и делегация. Если бы мы добавили немного другая конструкция, например примеси, это было бы больше мощный?
Наследование множественных реализаций значительно усложняет реализация. Эта сложность влияет литье, верстка, отгрузка, доступ к полю, сериализация, идентификация сравнения, проверяемость, отражение, дженерики и, возможно, много других мест.
Вы можете прочитать статью полностью здесь.
Для Java вы можете прочитать эту статью :
Причины пропуска нескольких наследование от языка Java в основном проистекают из "простой, объектной" ориентированная и знакомая "цель. Как простой язык, создатели Java хотел язык, на котором большинство разработчиков мог понять без обширных повышение квалификации. С этой целью они работали над сделать язык похожим на C ++ как возможно (знакомо) без ношения над ненужной сложностью C ++ (просто).
По мнению разработчиков, несколько наследование вызывает больше проблем и путаница, чем это решает. Так они режут множественное наследование от языка (так же, как они режут оператора перегрузка). Обширный дизайнерский Опыт C ++ научил их, что множественное наследование просто не стоит головная боль.
Другая причина состоит в том, что одинарное наследование делает приведение типов тривиальным, не генерируя никаких инструкций ассемблера (кроме проверки совместимости типов, где это необходимо). Если у вас было множественное наследование, вам нужно будет выяснить, где в дочернем классе начинается определенный родитель. Так что производительность, безусловно, является преимуществом (хотя и не единственным).
Я отношусь к утверждению, что «Множественное наследование не разрешено в Java» с долей скепсиса.
Множественное наследование определяется, когда «Тип» наследуется от более чем одного «Типа» . И интерфейсы также классифицируются как типы по своему поведению. Итак, у Java есть множественное наследование. Просто так безопаснее.
Multiple Inheritance is
- hard to understand
- hard to debug (for example, if you mix classes from multiple frameworks that have identically-named methods deep down, quite unexpected synergies can occur)
- easy to mis-use
- not really that useful
- hard to implement, especially if you want it done correctly and efficiently
Therefore, it can be considered a wise choice to not include Multiple Inheritance into the Java language.
В C ++ множественное наследование было основной головной болью при неправильном использовании. Чтобы избежать этих популярных проблем проектирования, в современных языках (java, C #) вместо этого было принудительно реализовано "наследование" множественных интерфейсов.
Основная (хотя и не единственная) причина, по которой люди избегают MI, - это так называемая «проблема алмаза», приводящая к двусмысленности в вашей реализации. Эта статья в Википедии обсуждает это и объясняет лучше, чем я мог. MI также может привести к более сложному коду, и многие разработчики объектно-ориентированных приложений утверждают, что вам не нужен MI, и если вы его используете, ваша модель, вероятно, неверна. Я не уверен, что согласен с этим последним пунктом, но всегда полезно сохранять простоту.
Множественное наследование реализации недопустимо.
Проблема в том, что компилятор / среда выполнения не может понять, что делать, если у вас есть классы Cowboy и Artist, оба с реализациями для метода draw (), а затем вы пытаетесь создать новый тип CowboyArtist. Что происходит, когда вы вызываете метод draw ()? Кто-то лежит мертвым на улице, или у вас есть прекрасная акварель?
Я думаю, это называется проблемой наследования двойного ромба.
В старые времена (70-е годы), когда информатика была больше наукой и меньше массовым производством, у программистов было время подумать о хорошем дизайне и хорошей реализации и, как следствие, о продуктах (программах) имел высокое качество (например, разработка и реализация TCP / IP). В настоящее время, когда все программируют, а менеджеры меняют спецификации до истечения крайних сроков, трудно отследить тонкие проблемы, подобные описанной в ссылке на википедию из сообщения Стива Хая; поэтому «множественное наследование» ограничено конструкцией компилятора. Если вам это нравится, вы все равно можете использовать C ++ .... и получите всю необходимую свободу :)
Потому что у Java философия проектирования сильно отличается от C ++. (Я не собираюсь здесь обсуждать C #.)
При разработке C ++ Страуструп хотел включить полезные функции, независимо от того, как они могут быть использованы неправильно. Можно сильно облажаться с множественным наследованием, перегрузкой операторов, шаблонами и различными другими функциями, но с ними также можно делать некоторые очень хорошие вещи.
Философия дизайна Java заключается в том, чтобы сделать упор на безопасность языковых конструкций. В результате есть вещи, которые делать намного более неудобно, но вы можете быть гораздо более уверены в том, что код, на который вы смотрите, означает то, что вы думаете.
Кроме того, Java в значительной степени была реакция C ++ и Smalltalk, самых известных объектно-ориентированных языков. Существует множество других объектно-ориентированных языков (Common Lisp был фактически первым, который был стандартизирован) с различными объектно-ориентированными системами, которые лучше обрабатывают MI.
Не говоря уже о том, что вполне возможно реализовать MI на Java, используя интерфейсы, композицию, и делегирование. Он более явный, чем в C ++, и поэтому неудобен в использовании, но даст вам то, что вы с большей вероятностью поймете с первого взгляда.
Здесь нет правильного ответа. Есть разные ответы, и какой из них лучше для конкретной ситуации, зависит от приложений и индивидуальных предпочтений.
и поэтому более неуклюжий в использовании, но даст вам то, что вы, скорее всего, поймете с первого взгляда.Здесь нет правильного ответа. Есть разные ответы, и какой из них лучше для конкретной ситуации, зависит от приложений и индивидуальных предпочтений.
и поэтому более неуклюжий в использовании, но даст вам то, что вы, скорее всего, поймете с первого взгляда.Здесь нет правильного ответа. Есть разные ответы, и какой из них лучше для конкретной ситуации, зависит от приложений и индивидуальных предпочтений.