Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
Two of the OOP metrics, Coupling Between Object classes (CBO) and Polymorphism Factor (PF) both measure coupling.
Is there an instance where of them has a higher coupling while another has a lower coupling? Is interface inheritance one such situation?
Also, how does each of them measure coupling?
The coupling between object classes (CBO) is a metric proposed by Chidamber & Kemerer to measure for a class to how much other classes it is coupled. A coupling means that an object of one class use methods or properties of an object in another class.
The polymorphic factor (PF) is a metric proposed by Abreu & Melo to measure how much a derived type overrides a method from the base class. It's calculated by counting the number of overridden methods compared to the number of methods.
These are independent measures, so in theory you can find any kind of relationship. But let's have a look at an an example to show how they relate in practice.
Suppose you have classes for representing different shapes (Circle, Square, etc...) and a class Figure, composed of several shapes. Figure has a draw() function that invokes a drawing method for each of its shapes.
draw_circle(), draw_square(), ...). Figure must then be coupled to all the shapes, with a lot of conditionals to cope with the different shapes. Every time you add a new shape, you add a new coupling.
Shape and overrides the polymorphic draw() function. Figure only knows about Shape.
Figure only invokes the draw() on a Shape object .N/(2+N) because Figure::draw() and Shape::draw() are no overrides, but Shape::draw() is overridden by N shapesThe common assumption is that a system with low coupling is easier to maintain. Therefore, many design patterns intend to reduce coupling. In most of the cases, polymorphism is the enabler for a decoupling.
Abstraction is the key, not the language feature used to implement it. Interface inheritance and normal inheritance are two ways to achieve abstraction. Interface inheritance requires you to provide an implementation for the interface functions (i.e. to provide an override for abstract functions which are not defined). It hence increases mathematically PF. However, some languages like C++ don't have interfaces but use pure virtual functions eventually with multiple inheritance to do the same, with identical PF. In our example, the inheritance is the enable for reducing coupling.
