Lesson 7 - Inheritance and polymorphism in Java

Java OOP Inheritance and polymorphism in Java

In the previous lesson, Arena with warriors in Java, we made an arena that simulates two warriors in battle. In today's tutorial we're going to expand our knowledge of object-oriented programming. In the introduction of this course, we mentioned that the OOP is based on three fundamental concepts: encapsulation, inheritance and polymorphism. We're already familiar with the encapsulation and have used the private access modifier. Today, we're going to be taking a look at the two remaining concepts.

Inheritance

Inheritance is one of the basic features of OOP and is used to create new data structures based on old ones. Let's look at a simple example:

Imagine that we were hired to create a database that will keep track of animals at a zoo :) There will be two types of users in our system: users and administrators. Users will be common zookeepers who will be able to edit information about the animals, e.g. their weight or wingspan. The administrator will be able to modify animal data as well and add or delete animals from the database.

We will also add the administrator's phone number so he or she can be contacted in case of system failure. It'd be pointless and confusing to fully define both classes since they have many properties and methods in common. Both the user and the administrator will have names, ages and be able to log in and log out. We won't write out an example. Today will mostly be about going over the concepts, we'll program a fully functioning example in the next lesson:

public class User {
        private String name;
        private String password;
        private int age;

        public boolean logIn(String password) {
                // ...
        }

        public boolean logOut() {
                // ...
        }

        public void setWeight(Animal animal) {
                // ...
        }

        // ...

}

All I did was make a general outline of the class, but I'm sure you get the gist of it. Without knowing what inheritance is, one would define our Administrator class like so:

public class Admin {
        private String name;
        private String password;
        private int age;
        private String telNumber;

        public boolean logIn(String password) {
                // ...
        }

        public boolean logOut() {
                // ...
        }

        public void setWeight(Animal animal) {
                // ...
        }

        public void addAnimal(Animal animal) {

        }

        public void removeAnimal(Animal animal) {

        }

        // ...

}

We see that there our code is very redundant in this class. All further changes would have to take a place in both classes, it'd make the code very complicated. Now, we'll write out the administrator class using inheritance. We'll let the Administrator class to be inherited from the User class. We don't have to declare fields and methods again, Java will add them automatically:

public class Admin extends User {
        private String telNumber;

        public void addAnimal(Animal animal) {

        }

        public void removeAnimal(Animal animal) {

        }

        // ...
}

We see that we've used the "extends" keyword for inheritance.

In the example above, the private fields won't be accessible in the descendant. Only the fields and methods with the public modifier will. Private fields and methods are understood as having a special logic that belongs to a certain class. Meaning that, they are hidden from the descendant - even if the descendant is actually using the same logic, it is unable to change it. To achieve the desired result, we'll use new access modifier - protected.

The protected modifier makes a field or a method accessible to the class descendants from any package or to any class from the same package. So the descendant is now able to access it. There can be a problem with a fact that the field is publicly accessible, therefore, we often create separated packages for classes which are not related. Protected attributes then aren't accessible from other packages.

The beginning of the User class look like the following:

public class User {
        protected String name;
        protected String password;
        protected int age;

        // ...

Now, when we create user and administrator instances, they'll both have name fields and logIn() methods. Java will inherit the User class and redeclare all its fields automatically.

The advantages of using inheritance are clear. We wouldn't have to copy the same fields to two classes. Then, all we'd have to do is declare new ones. The rest will be inherited. The benefits are tremendous, we can extend existing components of new methods and reuse them. We wouldn't have to write lots of redundant code, and most importantly - when we change a single field in the parent class, this change is inherited everywhere automatically. We wouldn't need to change something manually in 20 classes, which could potentially cause errors. We're humans and we'll always make mistakes, we have to use programming techniques like inheritance to be more efficient.

The parent class is sometimes called an ancestor, our User class, and the class that inherits from it, a descendant, our Administrator class. The descendant may add new methods or override the existing methods of the parent class (see example below). Sometimes, you may encounter the terms superclass and subclass which essentially mean the same thing.

Another way to design the object model would be to create a User parent class whose sole purpose would be inheritance. The User would be then inherited by Attendant and Admin classes. This technique would be useful if we had lots of user types. In that case, we're talking about a class hierarchy, which we'll get into further along in this online course. Our example was simple so two classes were enough. There are things we call design patterns that are established and approved object models that are used for most situations. All of that stuff is advanced and interesting, and I promise we'll get to them later as well. In object modeling, we draw inheritance as an empty arrow pointing to the parent class. In our case, the graphical notation would look like this:

Object inheritance – graphical notation

Inheritance and the data type

The biggest advantage to using inheritance is that if we create a variable of the parent data type, we can store the descendants in it as well. We are able to do this because a descendant always includes everything that the parent class does, therefore, it meets the "requirements" of the data type (more accurately it provides the necessary interface). What all descendants are is the parent class with some extra stuff. That way, we are able to create an array of User data type and store there both users and administrators. Here is an example of the re-assignment of a descendant to an ancestor and vice-versa:

User u = new User("John Newman", 33);
Admin a = new Admin("Jack White", 25);
// now we assign the administrator to the variable of the User type:
u = a;
// It's fine since the User class is its parent class
// If we try in conversely, we'll receive an error:
a = u;

There are many constructs in Java, that allow us to work with data types of inherited instances. We'll go over them in detail during the course. For now, we'll demonstrate how we can verify the data type of the instance in a variable:

User u = new Admin("Jack White", 25);
if (u instanceof Admin) {
        System.out.println("The user given has been identified as an administrator");
} else {
        System.out.println("The user given is not an administrator");
}

We can ask whether the object is of a given type using the instanceof operator. The code above checks whether there is a user or his descendant, administrator, in the u variable.

Languages can support either simple or "multiple inheritance". With simple inheritance, a class can inherit only from one other class. With the "multiple inheritance", a class can inherit from several classes at the same time. Multiple inheritance never became as popular. We'll discuss why and show you how to work around it later. Java only supports simple inheritance. You would encounter multiple inheritance in the C++ language.

Polymorphism

Polymorphism allows you to use a unified interface to work with objects of different types. Imagine that we have, for example, many objects representing geometric shapes (circles, squares, triangles, and so on). It'd certainly be helpful if we could communicate with them in some unified way even though they're different. We can create a GeometricShape class containing a color field and a render() method. All the geometric shapes would then inherit an interface from this class. Now you may be thinking, "But the circle and square object would render differently!." Well, polymorphism allows us to override the render() method in every subclass so it will do what we want. The interface will be unified and we won't have to think about which method to call to render different objects.

Polymorphism is often explained using animals. All having a speak() method in their interface, but each animal performs it differently.

Polymorphism

The essence of polymorphism is a method or methods, that all descendants have defined with the same heads, but with different method bodies. We'll use polymorphism along with inheritance in the next lesson, Arena with a mage in Java (inheritance and polymorphism), on our warriors in the arena. We'll add a mage who will inherit warrior's fields and behavior and override the warrior's attacking method to use mana. We won't be able to tell that he's not a pure warrior from the outside since it will have the same interface. It'll be fun :)


 

 

Article has been written for you by David Capka
Avatar
Do you like this article?
1 votes
The author is a programmer, who likes web technologies and being the lead/chief article writer at ICT.social. He shares his knowledge with the community and is always looking to improve. He believes that anyone can do what they set their mind to.
Unicorn College The author learned IT at the Unicorn College - a prestigious college providing education on IT and economics.
Activities (3)

 

 

Comments

To maintain the quality of discussion, we only allow registered members to comment. Sign in. If you're new, Sign up, it's free.

No one has commented yet - be the first!