Object Oriented Programming and Parting Thoughts

While this blog will still be open for the foreseeable future, this will most likely be my last post for some time. This made me think on what would be a fitting final post for this class. After spending the last three posts discussing a pretty involved topic, I figured it would be fitting to take a step back and remind myself exactly what I have been working with for this, and many other semesters. Thus, for this final post, I will be examining Object Oriented Programming as a whole, defining exactly what it is and why it has such significance.

So first and foremost, let’s determine exactly what makes a programming language object oriented. For this week I found an extremely extensive blog post discussing all different components of object oriented programming. I mistakenly assumed that only specific languages, such as Java, could be defined as object oriented, but this concept is not so rigid. This is less of an attribute a language can have and more of a method of programming. It revolves around using classes and objects to represent general ideas that can be instantiated as different instances of objects. Think of it as giving yourself a template within your program that can be reused for others. To specify, this semester we had a program storing different types of ducks with different attributes. In this program you could define a general duck class with all relevant methods and a general duck object with attributes shared by all. Now, when calling this class, you can set unique values for each duck created to represent different types rather than specifying each duck as its own object. This is the general idea, but as always I encourage any readers to refer to my source for a more in depth definition.

So why is Object Oriented Programming significant? If you asked me a year ago I would have said, because my professors talk about it so much. But I have since learned that there are a multitude of benefits that come with this method of programming. This can be summarized in by four specific principles, being inheritance, encapsulation, abstraction, and polymorphism. To summarize, these principles focus on making objects to contain information, only showing what your user needs and hiding other information. Additionally these objects, and their methods, will be able to perform similar tasks and should be accessible by any child classes. These allow for an overall more flexible program, resulting in less work for the programmer without compromising on program complexity or functionality. Often this will allow a complex program to be broken down into more sensible components.

This blog has been fun to post on and, more importantly, has forced me to actually sit down and confront the meanings of some of these more complex subjects. As always, please refer to the source if you want a more substantial walkthrough of Object Oriented Programming, but I hope I could give you the jist of its meaning and importance.



Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Create your website at WordPress.com
Get started
%d bloggers like this: