Object Oriented Programming Issues
Programming errors are a common issue with any programming practice. In case of Object Oriented Programming such error might be because of considering the type of object instead of the membership it is associated with. When this happens, the advantages of polymorphism and inheritance are weakened.
A D V E R T I S E M E N T
Many such errors arise while creating an application with an object oriented programming approach. OOP supports code centrality, which is connected to inheritance. Code centrality makes the code more expensive to maintain.
The costs involved with maintaining code can become high when large applications
are involved, even more serious while involved at higher levels of the system. Usually
developers who are maintaining lower level classes avoid to make
changes in the code in order to correct a bug. These developers ask someone
else to fix the issue. However, code centrality can be obtained with techniques
which are secure. Another issue related to OOP is that
lists of exclusive options may not match changes that occur within the real
However, OOP techniques like "composition" can
be helpful in solving many such problems. Yet, the
composition technique resembles network data structures, and it may not be a
good alternative. Another way to avoid this is to look at only the
specific objects that are available, and model relationships among them. It
is to be noted that there could be complications between inheritance and
polymorphism. Using the relational model might be
better because it has a mathematical structure which is based on relational
calculus and predicate calculus. Unfortunately, OOP does not have a structure
which is based on mathematical models.
Another issue to be noted is that object oriented programming resembles the
navigational database systems that were used during the 1960s. According to this class of users the relational database is merely a replacement. However, this is
not necessarily the aim of OOP. Relational database modeling is based on premises which are different from those
that OOP is based on. However, there are connections between the two
because relational database tables are used with OOP models.
Yet another issue that arises for OOPs is that of necessity of copying. Another issue with
object oriented programming is impedance mismatch. This occurs
between the relational database and the OOP, which in turn occurs as a result of difference between the scale and
emphasis among operations performed by databases and objects.
Database transactions tend to be much larger than object oriented programming
objects. While databases can be useful when it comes to storing information
among objects, the data related to the objects should only be stored once data
has been summarized and collected.
The representation of an object should never be added to a database. Because the objects are small, it doesn't make much sense for OOP to be so complex, yet it can be said that there is no
performance overhead which is created by object oriented programming. Every domain is modelled independently of the othersand the
scale of the architecture is dependent on the information that is
stored within the database. Another issue associated with OOPs is that of the connections between
the database schemas.
The paradigm that is to be used dependens on the needs of the person that is using it. While OOP may be a better
approach in some situations, it may not be the best approach in other.