Inheritance
Assuming that the component is implemented as aclass in an OO language, inheritance can be used as a white-box technique to specialize the component for its context. Using inheriance, the component (re)user can define a subclass and add the application-specific behaviour to the component behaviour. Depending on the OO language that was used to implement the component, different mechanisms may be available to control the specialization of component behaviour. By defining operations as abstract, the component developer can require the component user to extend those operations. Similary, by defining operations as final, the component developer can block the component user to extend behaviour that would potentially lead to inconsistencies. Inheritance has a number of associated disadvantages, especially due to the fact that forms a logical entity is divided over multiple components. This may, among others, complicate the understandability and testing of components
Extensions
An extension is a variation point where the component user provides one out of several variants of some behaviour. The strategy design pattern is a typical example of using extensions. The underlying idea is to factor out functionality that may vary form stable functionality and to model the variable functionality as an independent entity. The different instances of variable functionality are implemented as variants and the component user can either select an existing variant or develop a new variant
Configuration
A third approach to handling variability is to include all variants at all variantion points into the component and to provide an interface to the component user. This interface allows the user to set parameters that select particular variants at the variantion points. Through the use of , for instance, procedure parameters, components can even be configured for invoking component.
Template instantiation
Components, at times, need to be configured with application-specific types. A typical example is list-handling or queue component that needs to be configured with the type of element that is to be stored in the use of templates, I.e. component definitions that can be instantiated for particular types. Templates are particularly useful for performing type adaptation.
Generation
The final type of variability mechanism to be discussed here is the notion of a component generator. The typical use of this approach is that the component user prepares a specification in some language, e.g a domain-specific or component-specific language. This specification is taken as input by a generator, or high-level compiler, that translates the specification into, generally, a source-code-level component that can be incorporated into the product ar pplication that component user is concerned with. Typcal examples of this approach can be found in graphical user interfaces where either a graphical or textual specification is used to generate a source-code component that implements the desired functionality
참고 : Design & use of software architecture p225
