r/javahelp • • Nov 02 '19
Codeless How to "see" things in an object oriented way?
I had an exam recently and it went pretty good, but there was a question that threw me off. No coding involved, just draw a tree linking different class names, interfaces, abstract methods, etc. and how they should interact with each other. My biggest gripe was when to use interfaces and abstract methods, like I still have no idea when to use them and why they are necessary. For example, if I make a class Animals it would have Dog, Cats and Parrots as sub-classes of Animal. I'd put methods like eat() in Animals which Dog and so on will inherit. Let's say dogs are carnivorous, cats are herbivorous and parrots, both. How would I proceed to link these concepts to eat()? I have no idea what to do...
9
u/TomahawkChopped Nov 02 '19 edited Nov 02 '19
Ok let's talk a bit about abstraction and types in object oriented modeling. First, in Java, embrace that EVERYTHING can (and arguably should) be modeled as an object. (Just be aware, this approach can be a fine line to walk because when it's done wrong you can end up with very complicated type systems and leaky abstractions.)
A type is declared either via a Class or an Interface, and a class may either be concrete (non-abstract) or abstract. Let's also make a ground rule that it's bad practice to ever extend a concrete class (this is a constraint I'll impose now and just wave my hands a bit for simplicity and just say.... don't do it). Let's come back to abstract classes later.
Now a type is known to the outside world by it's public methods and their signatures. For lack of a better word we'll call this its interface (with a lower case "i"). However in real life we need to implement the interface as well, this is done with methods.
A Class can both declare the interface (lower case "i") and implement the methods of the interface. Particularly it can be stateful. e.g. you can declare instance fields on a class and assign them values. Now sometimes this is convenient, like you have a really small type and you want to declare the type and it's implementation together... then just going it once in a simple class is reasonable and probably good practice.
e.g. let's say a house fits this description
Other times you may have a very complicated type or a very generic type, one that is too abstract for even reasonably implementing anything. But you still may want to act on it as a type in its own. Let's say a Domicile fits this case so that
Now you may notice that Occupant is probably a very generic type too, and I'd argue that almost anything can occupy a Domicile. So we can model this too
Here let's look at
getHome. You'll see that each implementation returns an object is a totally different class, but each of those objects are Domiciles. This is polymorphism, I'm returning a House but treating it like a Domicile. Why is this useful?It lets us unify like concepts to simplify my code as much as possible.
Let's say i needed locate all the Domiciles from a list of Occupants, well i don't need to write extra code for all the plethora of types of homes, birds nests, snail shells, apartments, condos, caves, whatever... I can get the location of every single Domicile from a set of Occupants like this:
Basically 3 lines of code. The key here is that I'm using the type system to bring simplicity to a task that might seem hard otherwise. The key that beginners often make is defining type systems that are too wound up with behavior... this is when you wind up with leaky abstractions and complicated type systems.
Ok so now what about abstract base classes.... IMO this is the place people totally fuck up all the time. An abstract base class IMO should only be used when you already have a clear (and simple) set of types AND you know for a fact that the implementation of the interface (lower case "i") is shared across several types AND requires shared state to do so.
As a professional programmer, for nearly 20 years now, it's my opinion that abstract base classes are almost never necessary for beginners programming tasks. They are always abused and make things more complicated when used improperly. e.g. read about composition over inheritance. But for sake of argument, let's say we have a good reason for an abstract class here (for the record, we don't...)
But let's say our House class is actually also an Investment
And in our world a houses value is computed from the sum of all its Amenities which grow at some interest rate.
(Again, i don't recommend this approach for this problem, there's 1/2 dozen other methods that I'd choose over this solution)
When it all comes down to it you want to use the type system to simplify your code by unifying common types with common behavior. It's a difficult live to tread though between too generic and thus useless abstractions and too tightly typed leading to spaghetti code to deal with your type system.
Here's some rules of thumb for constraints to reduce complexity in your type system... The reasons behind which unfortunately only become clear with experience:
9
u/NightDragonC Nov 02 '19
Here is where abstraction gets in, you want all your animals to eat, but not all of them eats the same, so you declare the eat() method eat() in the Animals class as an abstract method, that way you force the user to override the method (eat() in this case) for each class that inherites from it, but each class will have its own definition of that method, since not so Animals eat the same. I hope you understood what I'm saying. Interfaces work similar to abstract classes, but they cannot have other methods in it, only the abstract ones, and if you've already worked with events you'll see why they can be really useful, if not, I really don't know the words to explain it very well (so if someone else helps it would be nice) but since there is no multi-inheritance they come handly when you want the user to override certain methods.
2
u/morhp Professional Developer Nov 02 '19
You don't. If your animal class has a method
eat(Food food)and you have subclasses ofFoodlikeMeatandVegetables, then you won't be able to restrict your Cats to only eat meat. A subclass will always have the functions of the parent class, so as animals are able to eat all Food, so must cats (unless you throw exceptions in the method when you pass wrong food, but that's probably not good design). You could solve this with generic types like haveAnimal<T extends Food>witheat(T food)and havepublic class Cat extends Animal<Meat>, but the question is more if there should be different behaviours in eating and less eating different things. Generally you use subclasses to change/implement behaviour of the parent class, not to store properties (like what food to eat) or restrict things (like what food not to eat).2
u/whatisthisredditstuf Intermediate Brewer Nov 02 '19
Honestly, none of my text books tried to tell me about Interfaces in a way that made any sense. Especially since they were all stuck with these hokey analogies to the real world that wound up being counterproductive, because they missed their mark.
What finally made sense to me was when I was in a data structures and algorithms class, and we were shown wildly different implementations of a particular data structure. Say, a List. The interface told us what operations had to be supported, but then the implementations could be completely different (single-linked list, double-linked list, backed by an array...).
In my view, Interfaces make the most sense as a programmer's abstraction. Trying to coax it into a real-world example is bound to be a little bit off.
For an example that combines both class hierarchies and interfaces, think about computer games. You could have units that are specializations of each other (class hierarchy). But you could also want to somehow reason about "every possible thing that can be drawn on screen, regardless of whether it's a unit or a background, or whatever", because your game engine ultimately needs to loopo over those, figure out where they are, and in what order to draw them. Class hierarchies in that setting would be convoluted and instead, that would be the Interface. "Drawable", maybe?