Interface-based programming, also known as interface-based architecture, is an architectural pattern for implementing modular programming at the component level in an object-oriented programming language which does not have a module system. An example of such a language is Java, which (as of 2015), does not have a module system at the level of components. Java has a package system, but Java software components typically consist of multiple Java packages – and in any case, interface programming can provide advantages over merely using Java packages, even if a component only consists of a single Java package.
| Attributes | Values |
|---|
| rdf:type
| |
| rdfs:label
| - Programmazione basata sull'interfaccia (it)
- Interface-based programming (en)
- 基于接口编程 (zh)
|
| rdfs:comment
| - Interface-based programming, also known as interface-based architecture, is an architectural pattern for implementing modular programming at the component level in an object-oriented programming language which does not have a module system. An example of such a language is Java, which (as of 2015), does not have a module system at the level of components. Java has a package system, but Java software components typically consist of multiple Java packages – and in any case, interface programming can provide advantages over merely using Java packages, even if a component only consists of a single Java package. (en)
- La programmazione basata sull'interfaccia è un concetto che ha una stretta relazione con la programmazione modulare e la programmazione orientata agli oggetti. La programmazione modulare definisce l'applicazione come un insieme di moduli interdipendenti. Ciò aumenta la modularità dell'applicazione e quindi la sua manutenibilità. La complessità totale del sistema viene notevolmente ridotta. La programmazione basata sull'interfaccia aggiunge di più alla programmazione modulare in quanto sostiene che le interfacce debbano essere aggiunte a questi moduli. L'intero sistema è quindi visto come componenti e le interfacce che li aiutano ad agire insieme. (it)
- 基于接口编程（Interface-based programming）也称基于接口的架构（interface-based architecture），它是一种在没有模块系统的面向对象程序设计语言中的组件层面实现模块化编程的架构模式。符合此例的一个语言是Java，截至2015年，它没有组件级别的模块系统。Java有一个包（package）系统，但Java软件组件通常由多个Java包组成——并且在任何情况下，接口编程可以提供优于仅使用Java包的优势，即使组件仅由单个Java包组成。 基于接口的编程将应用程序定义为组件的集合，其中组件间的应用程序接口（API）调用可能只通过抽象化接口完成，而没有具体的类。类的实例化一般通过使用如工厂模式等技术的其他接口完成。 这种方式被认为增加了应用程序的模块性并因而增加了。但是，有必要谨慎考虑——仅将应用程序分解成通过接口通信的任意组件本身不能保证低耦合性或高內聚性，这两项通常被认为是可维护性的另外两项关键属性。 (zh)
|
| dcterms:subject
| |
| Wikipage page ID
| |
| Wikipage revision ID
| |
| Link from a Wikipage to another Wikipage
| |
| Link from a Wikipage to an external page
| |
| sameAs
| |
| dbp:wikiPageUsesTemplate
| |
| has abstract
| - Interface-based programming, also known as interface-based architecture, is an architectural pattern for implementing modular programming at the component level in an object-oriented programming language which does not have a module system. An example of such a language is Java, which (as of 2015), does not have a module system at the level of components. Java has a package system, but Java software components typically consist of multiple Java packages – and in any case, interface programming can provide advantages over merely using Java packages, even if a component only consists of a single Java package. Interface-based programming defines the application as a collection of components, in which Application Programming Interface (API) calls between components may only be made through abstract interfaces, not concrete classes. Instances of classes will generally be obtained through other interfaces using techniques such as the Factory pattern. This is claimed to increase the modularity of the application and hence its maintainability. However, some caution is warranted – merely splitting an application into arbitrary components communicating via interfaces does not in itself guarantee low coupling or high cohesion, two other attributes that are commonly regarded as key for maintainability. An interface-based architecture can be used when third parties – or indeed separate teams within the same organisation – develop additional components or plugins for an established system. The codebase of the Eclipse IDE is an example of interface-based programming. Eclipse plugin vendors just have to develop components that satisfy the interface specified by the parent application vendor, the Eclipse Foundation. Indeed, in Eclipse, even the original components such as the Java Development Tools are themselves plugins. This is somewhat like a mobile phone manufacturer specifying a mobile charger interface (pin arrangement, expected direct current voltage, etc.) and both the manufacturer and third parties making their own mobile phone chargers that comply with this standard interface specification. (en)
- La programmazione basata sull'interfaccia è un concetto che ha una stretta relazione con la programmazione modulare e la programmazione orientata agli oggetti. La programmazione modulare definisce l'applicazione come un insieme di moduli interdipendenti. Ciò aumenta la modularità dell'applicazione e quindi la sua manutenibilità. La complessità totale del sistema viene notevolmente ridotta. La programmazione basata sull'interfaccia aggiunge di più alla programmazione modulare in quanto sostiene che le interfacce debbano essere aggiunte a questi moduli. L'intero sistema è quindi visto come componenti e le interfacce che li aiutano ad agire insieme. Ciò è particolarmente utile quando terzi sviluppano componenti aggiuntivi per il sistema stabilito. Devono solo sviluppare componenti che soddisfano l'interfaccia specificata dal fornitore dell'applicazione principale. Ciò è un po' come un produttore di telefonia mobile che specifica un'interfaccia per un caricatore di cellulare e altri costruiscono i propri caricatori di cellulare, aderendo a tali standard/interfacce (disposizione dei pin, conversione di tensione AC-DC ecc.). Un altro esempio è IEEE 1394 (Firewire) che è accettato da entrambi i produttori del tuo computer portatile e della tua fotocamera digitale. Conseguentemente chi pubblica le interfacce assicura che non cambierà l'interfaccia e il sottoscrittore si impegna a implementare l'interfaccia nel suo insieme, senza alcuna variazione. Si dice dunque che un'interfaccia è un accordo contrattuale e il paradigma di programmazione basato su ciò è definito come "programmazione basata sull'interfaccia". (it)
- 基于接口编程（Interface-based programming）也称基于接口的架构（interface-based architecture），它是一种在没有模块系统的面向对象程序设计语言中的组件层面实现模块化编程的架构模式。符合此例的一个语言是Java，截至2015年，它没有组件级别的模块系统。Java有一个包（package）系统，但Java软件组件通常由多个Java包组成——并且在任何情况下，接口编程可以提供优于仅使用Java包的优势，即使组件仅由单个Java包组成。 基于接口的编程将应用程序定义为组件的集合，其中组件间的应用程序接口（API）调用可能只通过抽象化接口完成，而没有具体的类。类的实例化一般通过使用如工厂模式等技术的其他接口完成。 这种方式被认为增加了应用程序的模块性并因而增加了。但是，有必要谨慎考虑——仅将应用程序分解成通过接口通信的任意组件本身不能保证低耦合性或高內聚性，这两项通常被认为是可维护性的另外两项关键属性。 当第三方（或同一个组织内的另一个团队）为已建立的系统开发了额外的组件或插件时，可以使用基于接口体系结构。Eclipse IDE的代码库就是基于接口编程的一个例子。Eclipse插件插件供应商只需开发满足父应用程序供应商Eclipse基金会指定接口的组件。在Eclipse中，哪怕“Java开发工具”等原始组件本身也是一个插件。这有点像移动电话制造商制定的移动充电器接口（引脚布局、预期直流電电压等）和，制造商和第三方都制造符合这种标准接口规范的手机充电器。 (zh)
|
| gold:hypernym
| |
| prov:wasDerivedFrom
| |
| page length (characters) of wiki page
| |
| foaf:isPrimaryTopicOf
| |
| is Link from a Wikipage to another Wikipage
of | |
| is Wikipage redirect
of | |
| is foaf:primaryTopic
of | |
![[RDF Data]](/fct/images/sw-rdf-blue.png)
![[cxml]](/fct/images/cxml_doc.png)
![[csv]](/fct/images/csv_doc.png)
![[text]](/fct/images/ntriples_doc.png)
![[turtle]](/fct/images/n3turtle_doc.png)
![[ld+json]](/fct/images/jsonld_doc.png)
![[rdf+json]](/fct/images/json_doc.png)
![[rdf+xml]](/fct/images/xml_doc.png)
![[atom+xml]](/fct/images/atom_doc.png)
![[html]](/fct/images/html_doc.png)