Jenkov’s article is about a core concept of java and other object-oriented programming languages; interfaces. As basic as the concept is to programmers, it’s important to have a full understanding of such core concepts. And that’s where I think this article excels. It does a great job at making the information much more learn-able, digestible. Far better than the oracle libraries, Jenkov explains how to implement and work with interfaces in projects. His article does a good job of explaining what’s in the examples and code. The first he speaks of, after what an interface is and how to implement it, is implementing multiple interfaces. Unimpressive it may be, but it helped me. It’s not like the code was hard to learn or understand. It’s just a huge help to how I learn to see everything completely explained. Just looking at an example isn’t always helpful to me. Although in the case of implementing multiple interfaces, it would have been.
Beyond just what we can do with interfaces and inheritance, he explains how interfaces relate and operate with core concepts in object-oriented programming. Opting to discuss the usefulness of interfaces as well as how to implement them. This portion of his work was most beneficial to me. To not only know how to create interfaces but to also know how to use them effectively. Paired with his explanations, he gives examples of good coding practices with interfaces. But he doesn’t explain only what interfaces can do. He also warns of the short comings of interfaces.
Sure, they are awesome examples of polymorphism in programming but, they can be broken. One of the things to be cautious of is having overlapping method signatures. Something I learned; Java classes can only implement a method with a given signature once. Thus, having the same signature in two interfaces is a problem. However, it shouldn’t be too much of a pain as long as the programmer remembers what they’ve already written.
Another great lesson I got from this writing was on how inheritance can work with interfaces. I hadn’t known before that interfaces could inherit from one another and any class inheriting from a child interface got everything from the parent as well. The article gave me a good overview on how interfaces work as well as ideas and understanding on how and when to use them.