Dependency inversion principle
http://dbpedia.org/resource/Dependency_inversion_principle an entity of type: WikicatSoftwareDesignPatterns
Das Dependency Inversion Principle (DIP, englisch für Abhängigkeits-Umkehr-Prinzip) ist ein Prinzip beim objektorientierten Entwurf von Software. Es beschäftigt sich mit der Abhängigkeit von Modulen. Im Allgemeinen wird das DIP beschrieben durch: Module höherer Ebenen sollten nicht von Modulen niedrigerer Ebenen abhängen.Beide sollten von Abstraktionen abhängen.Abstraktionen sollten nicht von Details abhängen.Details sollten von Abstraktionen abhängen.
rdf:langString
객체 지향 프로그래밍에서 의존관계 역전 원칙은 소프트웨어 모듈들을 분리하는 특정 형식을 지칭한다. 이 원칙을 따르면, 상위 계층(정책 결정)이 하위 계층(세부 사항)에 의존하는 전통적인 의존관계를 반전(역전)시킴으로써 상위 계층이 하위 계층의 구현으로부터 독립되게 할 수 있다. 이 원칙은 다음과 같은 내용을 담고 있다. 첫째, 상위 모듈은 하위 모듈에 의존해서는 안된다. 상위 모듈과 하위 모듈 모두 추상화에 의존해야 한다.둘째, 추상화는 세부 사항에 의존해서는 안된다. 세부사항이 추상화에 의존해야 한다. 이 원칙은 '상위와 하위 객체 모두가 동일한 추상화에 의존해야 한다'는 객체 지향적 설계의 대원칙을 제공한다.
rdf:langString
在面向对象编程领域中，依赖反转原则（Dependency inversion principle，DIP）是指一种特定的解耦（传统的依赖关系建立在高层次上，而具体的策略设置则应用在低层次的模块上）形式，使得高层次的模块不依赖于低层次的模块的实现细节，依赖关系被颠倒（反转），从而使得低层次模块依赖于高层次模块的需求抽象。 该原则规定： 1.
* 高层次的模块不应该依赖于低层次的模块，两者都应该依赖于抽象接口。 2.
* 抽象接口不应该依赖于具体实现。而具体实现则应该依赖于抽象接口。 该原则颠倒了一部分人对于面向对象设计的认识方式。如高层次和低层次对象都应该依赖于相同的抽象接口。
rdf:langString
In object-oriented design, the dependency inversion principle is a specific methodology for loosely coupling software modules. When following this principle, the conventional dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are reversed, thus rendering high-level modules independent of the low-level module implementation details. The principle states:
rdf:langString
En el diseño orientado a objetos, el principio de inversión de dependencia es una forma específica de desacoplar módulos de software. Al seguir este principio, las relaciones de dependencia convencionales establecidas desde los módulos de alto nivel de establecimiento de políticas a los módulos de dependencia de bajo nivel se invierten, lo que hace que los módulos de alto nivel sean independientes de los detalles de implementación del módulo de bajo nivel. El principio establece:
rdf:langString
En programmation orientée objet, le principe d'inversion des dépendances (dependency inversion principle) fait référence à une forme spécifique de découplage des modules logiciels. Il correspond au « D » de l'acronyme SOLID. En suivant ce principe, la relation de dépendance conventionnelle que les modules de haut niveau ont, par rapport aux modules de bas niveau, est inversée dans le but de rendre les premiers indépendants des seconds. Les deux assertions de ce principe sont :
rdf:langString
Nella programmazione orientata agli oggetti, il principio di inversione delle dipendenze (o della dipendenza; in inglese dependency inversion principle, abbreviato in DIP) è una tecnica di disaccoppiamento dei moduli software, che consiste nel rovesciare la pratica tradizionale secondo cui i moduli di alto livello dipendono da quelli di basso livello. Il principio fu formulato per la prima volta da Robert C. Martin, che lo sintetizzò nel seguente modo: L'inversione delle dipendenze è un concetto correlato, ma non del tutto sovrapposto, a quello dell'inversione del controllo.
rdf:langString
依存性逆転の原則または依存関係逆転の原則（dependency inversion principle）とは、オブジェクト指向設計の用語であり、ソフトウェアモジュールの疎結合を確立する特別な形態を表現したコンセプトである。SOLIDの五原則の一つとして知られる。 オブジェクト指向における従来の依存関係とは、上位モジュールから下位モジュールへの方向性であり、仕様定義を担う上位モジュールを、詳細実装を担う下位モジュールから独立させて、各下位モジュールを別個保存するというものだったが、それに対して依存性逆転原則は以下二点を提唱している。 この上位モジュールと下位モジュールの双方が抽象に依存しなければならないという内容は、それまでの人々のオブジェクト指向の常識を覆しているものだった。 この二点の背景にある考えとは、上位モジュールと下位モジュールの相互作用を設計する際は、その相互作用自体も抽象的に考える必要があるということである。上位モジュールの抽象化だけではなく、それを詳細化する下位モジュールへの見方も変えて、インターフェースの使い方も変えることを求めている。多くの場合、相互作用を抽象的に捉えることは、追加のコーディングパターンを増やすことなくコンポーネント間の結合を減らせることに繋がる。これはより軽量で小規模な実装依存性相互作用スキーマを実現する。
rdf:langString
Принцип инверсии зависимостей (англ. dependency inversion principle, DIP) — принцип объектно-ориентированного программирования, суть которого состоит в том, что классы должны зависеть от абстракций, а не от конкретных деталей. Используется для минимизации зацепления в компьютерных программах. Входит в пятёрку принципов SOLID. Принцип был выведен в трудах Роберта Мартина. Формулировка:
* A. High level modules should not depend upon low level modules. Both should depend upon abstractions.
* B. Abstractions should not depend upon details. Details should depend upon abstractions.
rdf:langString
No paradigma de orientação a objetos, o Principio da inversão de dependência refere-se a uma forma específica de desacoplamento de módulos de software que determina a inversão das relações de dependência: partem de módulos de alto nível, responsáveis pelas diretrizes, para os de baixo nível. Assim, os módulos de alto nível tornam-se independentes dos detalhes de implementação dos de baixo nível. O princípio estabelece que:
rdf:langString
Принцип інве́рсії зале́жностей (англ. Dependency Inversion Principle, DIP) — один з п'яти SOLID-принципів об'єктно-орієнтованого проєктування програм, суть якого полягає у розриві зв'язності між програмними модулями вищого та нижчого рівнів за допомогою спільних абстракцій. Принцип формулюється наступним чином:
* Модулі вищого рівня не повинні залежати від модулів нижчого рівня. Обидва типи модулів повинні залежати від абстракцій.
* Абстракції не повинні залежати від деталей реалізації. Деталі реалізації повинні залежати від абстракцій.
rdf:langString
rdf:langString
Dependency-Inversion-Prinzip
rdf:langString
Principio de inversión de la dependencia
rdf:langString
Dependency inversion principle
rdf:langString
Inversion des dépendances
rdf:langString
Principio di inversione delle dipendenze
rdf:langString
依存性逆転の原則
rdf:langString
의존관계 역전 원칙
rdf:langString
Princípio da inversão de dependência
rdf:langString
Принцип инверсии зависимостей
rdf:langString
Принцип інверсії залежностей
rdf:langString
依赖反转原则
xsd:integer
3158597
xsd:integer
1123295811
rdf:langString
Das Dependency Inversion Principle (DIP, englisch für Abhängigkeits-Umkehr-Prinzip) ist ein Prinzip beim objektorientierten Entwurf von Software. Es beschäftigt sich mit der Abhängigkeit von Modulen. Im Allgemeinen wird das DIP beschrieben durch: Module höherer Ebenen sollten nicht von Modulen niedrigerer Ebenen abhängen.Beide sollten von Abstraktionen abhängen.Abstraktionen sollten nicht von Details abhängen.Details sollten von Abstraktionen abhängen.
rdf:langString
In object-oriented design, the dependency inversion principle is a specific methodology for loosely coupling software modules. When following this principle, the conventional dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are reversed, thus rendering high-level modules independent of the low-level module implementation details. The principle states: 1.
* High-level modules should not import anything from low-level modules. Both should depend on abstractions (e.g., interfaces). 2.
* Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions. By dictating that both high-level and low-level objects must depend on the same abstraction, this design principle inverts the way some people may think about object-oriented programming. The idea behind points A and B of this principle is that when designing the interaction between a high-level module and a low-level one, the interaction should be thought of as an abstract interaction between them. This not only has implications on the design of the high-level module, but also on the low-level one: the low-level one should be designed with the interaction in mind and it may be necessary to change its usage interface. In many cases, thinking about the interaction in itself as an abstract concept allows the coupling of the components to be reduced without introducing additional coding patterns, allowing only a lighter and less implementation-dependent interaction schema. When the discovered abstract interaction schema(s) between two modules is/are generic and generalization makes sense, this design principle also leads to the following dependency inversion coding pattern.
rdf:langString
En el diseño orientado a objetos, el principio de inversión de dependencia es una forma específica de desacoplar módulos de software. Al seguir este principio, las relaciones de dependencia convencionales establecidas desde los módulos de alto nivel de establecimiento de políticas a los módulos de dependencia de bajo nivel se invierten, lo que hace que los módulos de alto nivel sean independientes de los detalles de implementación del módulo de bajo nivel. El principio establece: 1.
* Los módulos de alto nivel no deberían depender de los módulos de bajo nivel. Ambos deberían depender de abstracciones (p.ej., interfaces). 2.
* Las abstracciones no deberían depender de los detalles. Los detalles (implementaciones concretas) deben depender de abstracciones. Al dictar que tanto los objetos de alto nivel como los de bajo nivel deben depender de la misma abstracción, este principio de diseño invierte la forma en que algunas personas pueden pensar sobre la programación orientada a objetos. La idea detrás de los puntos 1 y 2 de este principio es que al diseñar la interacción entre un módulo de alto nivel y uno de bajo nivel, la interacción debe considerarse como una interacción abstracta entre ellos. Esto no solo tiene implicaciones en el diseño del módulo de alto nivel, sino también en el de bajo nivel: el de bajo nivel debe diseñarse teniendo en cuenta la interacción y puede ser necesario cambiar su interfaz de uso. En muchos casos, pensar en la interacción en sí misma como un concepto abstracto permite reducir el acoplamiento de los componentes sin introducir patrones de codificación adicionales, permitiendo solo un esquema de interacción más ligero y menos dependiente de la implementación. Cuando el/los esquema/s de interacción abstracta descubierto/s entre dos módulos es/son genéricos y la generalización tiene sentido, este principio de diseño también conduce al siguiente patrón de codificación de inversión de dependencia.
rdf:langString
En programmation orientée objet, le principe d'inversion des dépendances (dependency inversion principle) fait référence à une forme spécifique de découplage des modules logiciels. Il correspond au « D » de l'acronyme SOLID. En suivant ce principe, la relation de dépendance conventionnelle que les modules de haut niveau ont, par rapport aux modules de bas niveau, est inversée dans le but de rendre les premiers indépendants des seconds. Les deux assertions de ce principe sont : 1.
* Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau. Les deux doivent dépendre d'abstractions. 2.
* Les abstractions ne doivent pas dépendre des détails. Les détails doivent dépendre des abstractions.
rdf:langString
依存性逆転の原則または依存関係逆転の原則（dependency inversion principle）とは、オブジェクト指向設計の用語であり、ソフトウェアモジュールの疎結合を確立する特別な形態を表現したコンセプトである。SOLIDの五原則の一つとして知られる。 オブジェクト指向における従来の依存関係とは、上位モジュールから下位モジュールへの方向性であり、仕様定義を担う上位モジュールを、詳細実装を担う下位モジュールから独立させて、各下位モジュールを別個保存するというものだったが、それに対して依存性逆転原則は以下二点を提唱している。 1.
* 上位モジュールはいかなるものも下位モジュールから持ち込んではならない。双方とも抽象（例としてインターフェース）に依存するべきである。"High-level modules should not import anything from low-level modules. Both should depend on abstractions (e.g., interfaces)." 2.
* 抽象は詳細に依存してはならない。詳細（具象的な実装内容）が抽象に依存するべきである。"Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions." この上位モジュールと下位モジュールの双方が抽象に依存しなければならないという内容は、それまでの人々のオブジェクト指向の常識を覆しているものだった。 この二点の背景にある考えとは、上位モジュールと下位モジュールの相互作用を設計する際は、その相互作用自体も抽象的に考える必要があるということである。上位モジュールの抽象化だけではなく、それを詳細化する下位モジュールへの見方も変えて、インターフェースの使い方も変えることを求めている。多くの場合、相互作用を抽象的に捉えることは、追加のコーディングパターンを増やすことなくコンポーネント間の結合を減らせることに繋がる。これはより軽量で小規模な実装依存性相互作用スキーマを実現する。 モジュール間で見出された抽象的相互作用スキーマが汎用的な意味をなしているならば、この設計原則は依存性逆転のコーディングパターンを適切な方向に導く。
rdf:langString
객체 지향 프로그래밍에서 의존관계 역전 원칙은 소프트웨어 모듈들을 분리하는 특정 형식을 지칭한다. 이 원칙을 따르면, 상위 계층(정책 결정)이 하위 계층(세부 사항)에 의존하는 전통적인 의존관계를 반전(역전)시킴으로써 상위 계층이 하위 계층의 구현으로부터 독립되게 할 수 있다. 이 원칙은 다음과 같은 내용을 담고 있다. 첫째, 상위 모듈은 하위 모듈에 의존해서는 안된다. 상위 모듈과 하위 모듈 모두 추상화에 의존해야 한다.둘째, 추상화는 세부 사항에 의존해서는 안된다. 세부사항이 추상화에 의존해야 한다. 이 원칙은 '상위와 하위 객체 모두가 동일한 추상화에 의존해야 한다'는 객체 지향적 설계의 대원칙을 제공한다.
rdf:langString
Nella programmazione orientata agli oggetti, il principio di inversione delle dipendenze (o della dipendenza; in inglese dependency inversion principle, abbreviato in DIP) è una tecnica di disaccoppiamento dei moduli software, che consiste nel rovesciare la pratica tradizionale secondo cui i moduli di alto livello dipendono da quelli di basso livello. Il principio fu formulato per la prima volta da Robert C. Martin, che lo sintetizzò nel seguente modo: I moduli di alto livello non devono dipendere da quelli di basso livello. Entrambi devono dipendere da astrazioni;Le astrazioni non devono dipendere dai dettagli; sono i dettagli che dipendono dalle astrazioni. Il principio di inversione delle dipendenze è uno dei cinque principi SOLID della programmazione a oggetti. Nella sua presentazione del principio, Martin lo descrisse come una generalizzazione dell'applicazione combinata di altri due principi SOLID, il principio aperto/chiuso e il principio di sostituzione di Liskov. L'inversione delle dipendenze è un concetto correlato, ma non del tutto sovrapposto, a quello dell'inversione del controllo.
rdf:langString
No paradigma de orientação a objetos, o Principio da inversão de dependência refere-se a uma forma específica de desacoplamento de módulos de software que determina a inversão das relações de dependência: partem de módulos de alto nível, responsáveis pelas diretrizes, para os de baixo nível. Assim, os módulos de alto nível tornam-se independentes dos detalhes de implementação dos de baixo nível. O princípio estabelece que: 1.
* Módulos de alto nível não devem incorporar (ou incluir) nada dos módulos de baixo nível. Ambos devem trabalhar apenas com abstrações, ou seja, interfaces. 2.
* Abstrações não devem depender de detalhes de implementação, mas os detalhes é que devem depender de abstrações. Ao definir que os objetos de alto e baixo nível devem fundamentar-se nas mesmas abstrações, este princípio de projeto inverte a maneira como as pessoas geralmente raciocinam dentro do paradigma de orientação a objetos. A ideia que está por trás dos itens A e B é que, no projeto de integração de módulos de alto e baixo nível, a sua interação deve ser feita de forma abstrata. Este princípio não acarreta consequências apenas no desenvolvimento dos módulos de alto nível, mas também nos de baixo nível, que precisam ser produzidos com a noção de interação e de possibilidade de mudança na interface de uso. Muitas vezes, quando se pensa na interação como um conceito abstrato, é possível reduzir o acoplamento dos componentes sem introduzir novos padrões de código, o que torna o modelo de interação mais leve e menos dependente de implementação.
rdf:langString
在面向对象编程领域中，依赖反转原则（Dependency inversion principle，DIP）是指一种特定的解耦（传统的依赖关系建立在高层次上，而具体的策略设置则应用在低层次的模块上）形式，使得高层次的模块不依赖于低层次的模块的实现细节，依赖关系被颠倒（反转），从而使得低层次模块依赖于高层次模块的需求抽象。 该原则规定： 1.
* 高层次的模块不应该依赖于低层次的模块，两者都应该依赖于抽象接口。 2.
* 抽象接口不应该依赖于具体实现。而具体实现则应该依赖于抽象接口。 该原则颠倒了一部分人对于面向对象设计的认识方式。如高层次和低层次对象都应该依赖于相同的抽象接口。
rdf:langString
Принцип инверсии зависимостей (англ. dependency inversion principle, DIP) — принцип объектно-ориентированного программирования, суть которого состоит в том, что классы должны зависеть от абстракций, а не от конкретных деталей. Используется для минимизации зацепления в компьютерных программах. Входит в пятёрку принципов SOLID. Принцип был выведен в трудах Роберта Мартина. Формулировка:
* A. High level modules should not depend upon low level modules. Both should depend upon abstractions.
* B. Abstractions should not depend upon details. Details should depend upon abstractions. Формулировка на русском языке:
* A. Модули верхних уровней не должны зависеть от модулей нижних уровней. Оба типа модулей должны зависеть от абстракций.
* B. Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.
rdf:langString
Принцип інве́рсії зале́жностей (англ. Dependency Inversion Principle, DIP) — один з п'яти SOLID-принципів об'єктно-орієнтованого проєктування програм, суть якого полягає у розриві зв'язності між програмними модулями вищого та нижчого рівнів за допомогою спільних абстракцій. Принцип формулюється наступним чином:
* Модулі вищого рівня не повинні залежати від модулів нижчого рівня. Обидва типи модулів повинні залежати від абстракцій.
* Абстракції не повинні залежати від деталей реалізації. Деталі реалізації повинні залежати від абстракцій. Принцип інверсії залежностей вирішує проблеми невдалого проєктування програм.
xsd:nonNegativeInteger
17089
