Java for Humans {Polymorphism}

In our short look at polymorphism at work in both the Class Inheritance and Abstract Classes & Interfaces chapters, we got a glimpse at how powerful polymorphism is. In both chapters, we learned that any object that can pass more than one test, that is any object that is of more than one type, is considered polymorphic. With that said, we can define polymorphism as the ability of an object to take on more than one form. is-a Why is Polymorphism Important & Useful Polymorphism is one of the most important concepts in object oriented programming. It is what allows us to say that all types in Java are the type of its class as well as the type of the Object class; we’ve learned that all objects in Java are instances of the Object class because of Java’s class hierarchy. One Functionality for All We learned in the Class Inheritance chapter that If we can say an instance of a class can be of more than one type, we can build functionality for one class that works for any class that extends it. We created a Human class that our Warrior, Archer, and FireArcher all inherited from. That allowed us to create methods that accepted them all as parameters because we could group them all as being Human. That is polymorphism at work. One Collection for All Remember in the three Data Structures chapters that with any data structure, collection, we can only store elements of the same type: each element of a String array must be of type String and each element in a Human LinkedList must be of type Human. In the HashMaps chapter, we saw that if we don’t explicitly specify the type of our keys and values, Java implicitly sets the map to store keys of type Object and values also of type Object because every class in Java extends the Object class provided by Java. This is only legal because of polymorphism. Let’s revisit our Conquer game example from earlier to see how we can collect all our friends in the game in a single list. The classes of the different characters in the game will be omitted from this chapter, so make sure to open the supporting source code. Remember that we have a Character interface that every character class implements, an Human class that all human character class extends, and an abstract Pet class that all pet classes extend. We will focus on the Human class and its subclasses because while a user can have a pet, a user who plays our game can only be a human character. Let’s create a Human instance for ourself, , and a couple Human instances to represent other users: abstract currentUser _//the Human character representing the current user_Human currentUser = Archer( ); new "ModernNerd" _//other Human characters playing the game_Archer human2 = Archer( );Human human3 = FireArcher( );Warrior human4 = Warrior( );Taoist human5 = Taoist( ); new "Tom" new "Christina" new "Tyrone" new "Jerome" We are the currentUser Human instance which is also an Archer instance. Notice that is like our character: its of type Human but is instantiated as a FireArcher. Again, that’s the beauty of polymorphism. Let’s take a look at the Human class: human3 Human Character { LinkedList friendsList = LinkedList<>();... public abstract class implements private new **public** LinkedList getFriends() { **return** friendsList; } ... } It has a LinkedList, , that accepts Human instances as elements. We will use this to hold our list of friends. Let’s get it and store a reference to it in a local variable and add the other characters to it because they are our friends: friendsList _/*store a reference to current user'sfriend list in a local variable*/_LinkedList currentUserFriendsList = currentUser.getFriendsList(); //add other user's to current user's friend listcurrentUserFriendsList.add(human2);currentUserFriendsList.add(human3);currentUserFriendsList.add(human4);currentUserFriendsList.add(human5); System. .printf( , currentUser.getFriendsList().size()); out "Current user has %d friends." //prints "Current user has 4 friends." Now we have four friends in our list. Remembered that each element in our list is stored as a Human instance, so if we want to retrieve a friend from the list, it will be returned as a Human. Let’s retrieve “Tom”, which is also an Archer: human2, Human ourFriendTomTheHuman = currentUserFriendsList.get(0); (ourFriendTom Archer) {System. .println( ); if instanceof out "\nOur friend Tom is an instance of the Archer class" Archer ourFriendTomTheArcher = (Archer) ourFriendTomTheHuman; System.**_out_**.println(**"Tom can find more arrows for battle."**); ourFriendTomTheArcher.findArrows(); } {System. .println( ); else out "\nOur friend Tom is NOT an instance of the Archer class" System. .println( ); //ourFriendTom.findArrows(); doesn't work out "Tom cannot go find arrows because he is not an Archer" ourFriendTomTheHuman.attack(currentUser); } /*Prints:Our friend Tom is an instance of the Archer classTom: Found 5 arrows!Tom: I now have 8 arrows.*/ There’s a couple new things happening in that code snippet, so let’s walk through it line by line. In the first line, we call the get() instance method on our LinkedList holding our friends and get the first element which is at index zero (0). This is Tom who we know was an archer before we added him to the list. However, he was returned to us as a Human, so we call him for now. ourFriendTomTheHuman Type Casting If we want to turn Tom back into an Archer, we must him to one. Type casting in Java is the act of casting, or converting, one type, a class or interface, into another type. As usual, we should check to make sure Tom is actually an Archer disguised as a Human before we try to cast him back to an Archer. We do the check in the next line of code by using the operator in an statement. The operator returns if the object on the left is an instance of the class on the right, and it returns otherwise. In this case, it returns true because Tom is indeed an instance of the Archer class as we already knew. Now we are inside the first block of the statement. cast instanceof if-then instanceof true false if-then After printing that Tom is an instance of the Archer class, on the next line, we cast the object to an Archer and save this new copy of Tom to a new Archer variable called . As you can see, to an object, we simply put the class of type we want to cast our object to inside of a set of opening and closing parenthesis to the left of the variable holding the object. ourFriendTomTheHuman ourFriendTomTheArcher type cast You can type cast primitive values like ints and doubles, too. Do some more research on type casting because it is a handy tool. Now that we have converted Tom from being a Human back to an Archer, we can call its instance method so it can find more arrows to use in battle. If we had not converted Tom back to an Archer, he could not call the findArrows() instance method because he would not be of type Archer. However, Tom could always call the attack() instance method of Human because all Human instances have an attack method. This is where it gets a little tricky, so stick with me: findArrows() ourFriendTomTheHuman.attack(human3); /*Prints:Tom: Attacking Christina with my arrows!Christina: I've been hit. My health now = 99.0*/ Because Tom was instantiated as an Archer before being added to our LinkedList of Human objects, he still has access to the abstract Human methods that were already implemented by the Archer class and made available to Tom when he was instantiated. With that said, if we make attack , “Christina”, he still attacks with his arrows. The only problem here is, because would not be able to find arrows after he uses it all, his attack() method will be useless at that point. That is why we should cast him back to an Archer. ourFriendTomTheHuman human3 ourFriendTomTheHuman By now, I hope you understand why polymorphism is so special to object oriented programming. Moving forward, be sure to employ polymorphism in your Java programming career. Take a look at the supporting source code and change things around to practice more. Next Chapter _Congratulations on making it this far. Really, you have accomplish a great feat. The final test of how far you have…_medium.com Java for Humans {Building a GUI Fighting Game} Table of Contents _I am writing this book to teach anybody with the slightest bit of interest in computer science, software engineering…_medium.com Java for Humans {Table of Contents}