Inheritance and Polymorphism Object Oriented Programming 1 Inheritance

Inheritance and Polymorphism Object Oriented Programming 1

Inheritance �Object-oriented programming allows you to define new classes from existing classes. This is called inheritance. �Inheritance is an important and powerful feature for reusing software/code. Suppose you need to define classes to model circles, rectangles, and triangles. These classes have many common features. Object Oriented Programming 2

�Inheritance enables you to define a general class (i. e. , a superclass) and later extend it to more specialized classes (i. e. , subclasses). Object Oriented Programming 3

Cont. �In Java terminology, a class C 1 extended from another class C 2 is called a subclass, and C 2 is called a superclass. �A superclass is also referred to as a parent class or a base class, and a subclass as a child class, an extended class, or a derived class. �Simple. Geometric. Object. java, Circle. From. Simple. Geometric. Object. java, Rectangle. From. Simple. Geometric. Object. java, Test. Circle. Rectangle. java Object Oriented Programming 4

Cont. � Contrary to the conventional interpretation, a subclass is not a subset of its superclass. In fact, a subclass usually contains more information and methods than its superclass. � Private data fields in a superclass are not accessible outside the class. Therefore, they cannot be used directly in a subclass. They can, however, be accessed/mutated through public accessors/mutators if defined in the superclass. � Not all relationships should be modeled using inheritance. For example, a square is a rectangle, but you should not extend a Square class from a Rectangle class, because the width and height properties are not appropriate for a square. Instead, you should define a Square class to extend the 5 Object Oriented Programming

Cont. �Do not blindly extend a class just for the sake of reusing methods. For example, it makes no sense for a Tree class to extend a Person class, even though they share common properties such as height and weight. �Some programming languages allow you to derive a subclass from several classes. This capability is known as multiple inheritance. Java, however, does not allow multiple inheritance. A Java class may inherit directly from only one superclass. This restriction is known as single inheritance. If you use the extends keyword to define a subclass, it allows only one parent class. Object Oriented Programming 6

super keyword �A subclass inherits accessible data fields and methods from its superclass. Does it inherit constructors? Can the superclass’s constructors be invoked from a subclass? �The keyword super refers to the superclass and can be used to invoke the superclass’s methods and constructors. Object Oriented Programming 7

Calling constructor of superclass �Unlike properties and methods, the constructors of a superclass are not inherited by a subclass. �They can only be invoked from the constructors of the subclasses using the keyword super(), or super(parameters); �The statement super() or super(arguments) must be the first statement of the subclass’s constructor; this is the only way to explicitly invoke a superclass constructor. Object Oriented Programming 8

Construction chaining �A constructor may invoke an overloaded constructor or its superclass constructor. If neither is invoked explicitly, the compiler automatically puts super() as the first statement in the constructor. Object Oriented Programming 9

Object Oriented Programming 10

Calling method of superclass �The keyword super can also be used to reference a method other than the constructor in the superclass. �The syntax is: super. method(parameters); �It is not necessary to put super before get. Date. Created() in this case, however, because get. Date. Created is a method in the Geometric. Object class and is inherited by the Circle class. �Apple. java �If possible, you should provide a no-arg constructor for every class to make the class easy to extend and to avoid errors. Object Oriented Programming 11

Overriding �A subclass inherits methods from a superclass. Sometimes it is necessary for the subclass to modify the implementation of a method defined in the superclass. This is referred to as method overriding. �To override a method, the method must be defined in the subclass using the same signature and the same return type as in its superclass. Object Oriented Programming 12

Cont. �The to. String() method is defined in the Geometric. Object class and modified in the Circle class. Both methods can be used in the Circle class. �To invoke the to. String method defined in the Geometric. Object class from the Circle class, use super. to. String(). Object Oriented Programming 13

Cont. Several points are worth noting: ■ An instance method can be overridden only if it is accessible. Thus a private method cannot be overridden, because it is not accessible outside its own class. If a method defined in a subclass is private in its superclass, the two methods are completely unrelated. ■ Like an instance method, a static method can be inherited. However, a static method cannot be overridden. If a static method defined in the superclass is redefined in a subclass, the method defined in the superclass is hidden. The hidden static methods can be invoked using the syntax Super. Class. Name. static. Method. Name. Object Oriented Programming 14

Output - Test 1. java Object Oriented Programming 15

Overriding Vs Overloading �Overloading means to define multiple methods with the same name but different signatures. �Overriding means to provide a new implementation for a method in the subclass. Object Oriented Programming 16

Cont. �Overridden methods are in different classes related by inheritance; overloaded methods can be either in the same class or different classes related by inheritance. �Overridden methods have the same signature and return type; overloaded methods have the same name but a different parameter list. Object Oriented Programming 17

@Override – annotation @Override annotation is used when we override a method in sub class. – override. java � Using @Override annotation while overriding a method is considered as a best practice for coding in java because of the following two advantages: 1) If programmer makes any mistake such as wrong method name, wrong parameter types while overriding, you would get a compile time error. As by using this annotation you instruct compiler that you are overriding this method. If you don’t use the annotation the sub class method would behave as a new method (not the overriding method) in sub class. 2) It improves the readability of the code. So if you change the signature of overridden method then all the sub classes that overrides the particular method would throw a compilation error, which would eventually help you to change the signature in the sub classes. If you have lots of classes in your application then this annotation would really help you to identify the classes that require changes when you change the signature of a method. � Object Oriented Programming 18

Object Class and to. String method �Every class in Java is descended from the java. lang. Object class. Object Oriented Programming 19

Design a class named Triangle that extends Geometric. Object. The class contains: ■ Three double data fields named side 1, side 2, and side 3 with default values 1. 0 to denote three sides of the triangle. ■ A no-arg constructor that creates a default triangle. ■ A constructor that creates a triangle with the specified side 1, side 2, and side 3. ■ The accessor methods for all three data fields. ■ A method named get. Area() that returns the area of this triangle. ■ A method named get. Perimeter() that returns the perimeter of this triangle. ■ A method named to. String() that returns a string description for the triangle. The to. String() method is implemented as follows: return "Triangle: side 1 = " + side 1 + " side 2 = " + side 2 + " side 3 = " + side 3; Write a test program that prompts the user to enter three sides of the triangle, a color, and a Boolean value to indicate whether the triangle is filled. The program should create a Triangle object with these sides and set the color and filled properties using the input. The program should display the area, perimeter, color, and true or false to indicate whether it is filled or not. Object Oriented Programming 20

Polymorphism � Polymorphism means that a variable of a supertype can refer to a subtype object. � First, let us define two useful terms: subtype and supertype. A class defines a type. � A type defined by a subclass is called a subtype, and a type defined by its superclass is called a supertype. Therefore, you can say that Circle is a subtype of Geometric. Object and Geometric. Object is a supertype for Circle. � A subclass is a specialization of its superclass; every instance of a subclass is also an instance of its superclass, but not vice versa. � Therefore, you can always pass an instance of a subclass to a parameter of its superclass type. Object Oriented Programming 21

Static Vs Dynamic binding �Connecting a method call to the method body is known as binding. There are two types of binding �Static Binding (also known as Early Binding). �Dynamic Binding (also known as Late Binding). Object Oriented Programming 22

Dynamic Binding �A method can be implemented in several classes along the inheritance chain. The JVM decides which method is invoked at runtime. � The type that declares a variable is called the variable’s declared type. Here o’s declared type is Object. � A variable of a reference type can hold a null value or a reference to an instance of the declared type. � The actual type of the variable is the actual class for the object referenced by the variable. � Here o’s actual type is Geometric. Object, because o references an object created using new Geometric. Object(). � Which to. String() method is invoked by o is determined by o’s actual type. This is known as dynamic binding. Object Oriented Programming 23

Cont. �That is, Cn is the most general class, and C 1 is the most specific class. �In Java, Cn is the Object class. If o invokes a method p, the JVM searches for the implementation of the method p in C 1, C 2, . . . , Cn-1, and Cn, in this order, until it is found. �Once an implementation is found, the search stops and the first-found implementation is invoked. �staticbinding. java and dynamicbinding. java Object Oriented Programming 24

Casting Objects �One object reference can be typecast into another object reference. This is called casting object. Dynamic. Binding. Demo. java m(new Student()); Object o = new Student(); // Implicit casting m(o); �Suppose you want to assign the object reference o to a variable of the Student type using the following statement: Student b = o; // generate compile error Object Oriented Programming 25

Cont. �Why does the statement Object o = new Student() work but Student b = o doesn’t? �The reason is that a Student object is always an instance of Object, but an Object is not necessarily an instance of Student. �Even though you can see that o is really a Student object, the compiler is not clever enough to know it. �Fruit supertype; Apple and Organe subtype Object Oriented Programming 26

Cont. �To tell the compiler that o is a Student object, use explicit casting. The syntax is similar to the one used for casting among primitive data types. �Student b = (Student)o; // Explicit casting �Upcasting (implicit) and downcasting (explicit) �Instance of operator �Casting. Demo. java Object Oriented Programming 27

Cont. �You may be wondering why casting is necessary? �The variable my. Object is declared Object. �The declared type decides which method to match at compile time. �Using my. Object. get. Diameter() would cause a compile error, because the Object class does not have the get. Diameter method. Object Oriented Programming 28

Cont. �Why not define my. Object as a Circle type in the first place? �To enable generic programming, it is a good practice to define a variable with a supertype, which can accept an object of any subtype. Object Oriented Programming 29

Casting primitive type Vs reference type �Casting a primitive type value is different from casting an object reference. Casting a primitive type value returns a new value. For example: Object Oriented Programming 30

ex_11. java Virtual. Demo. java Object Oriented Programming 31

Object Oriented Programming 32

Object’s equal method �Like the to. String() method, the equals(Object) method is another useful method defined in the Object class. public boolean equals(Object o) �This method tests whether two objects are equal. (This implementation checks whether two reference variables point to the same object using the == operator) �The syntax for invoking it is: object 1. equals(object 2); Object Oriented Programming 33

Cont. �You should override this method in your custom class to test whether two distinct objects have the same content. �The equals method is overridden in many classes in the Java API, such as java. lang. String and java. util. Date, to compare whether the contents of two objects are equal. �The equals method in the String class is inherited from the Object class and is overridden in the String class to test whether two strings are identical in content. �Circle_equals. java Object Oriented Programming 34

Protected data and methods �A protected member of a class can be accessed from a subclass. �Often it is desirable to allow subclasses to access data fields or methods defined in the superclass, but not to allow nonsubclasses to access these data fields and methods. �The modifiers private, protected, and public are known as visibility or accessibility modifiers because they specify how classes and class members are accessed. Object Oriented Programming 35

Object Oriented Programming 36

Cont. � Your class can be used in two ways: (1) for creating instances of the class and (2) for defining subclasses by extending the class. � Make the members private if they are not intended for use from outside the class. � Make the members public if they are intended for the users of the class. � Make the fields or methods protected if they are intended for the extenders of the class but not for the users of the class. � The private and protected modifiers can be used only for members of the class. � The public modifier and the default modifier (i. e. , no modifier) can be used on members of the class as well as on the class. Object Oriented Programming 37

Object Oriented Programming 38

Preventing extending or overriding �You may occasionally want to prevent classes from being extended. �public final class A { } �You also can define a method to be final; a final method cannot be overridden by its subclasses. Object Oriented Programming 39

Abstract Class �In the inheritance hierarchy, classes become more specific and concrete with each new subclass. �If you move from a subclass back up to a superclass, the classes become more general and less specific. �Class design should ensure that a superclass contains common features of its subclasses. �Sometimes a superclass is so abstract that it cannot be used to create any specific instances. Such a class is referred to as an abstract class. �Test. Geometric. Object. java Object Oriented Programming 40

Cont. An abstract method cannot be contained in a nonabstract class. If a subclass of an abstract superclass does not implement all the abstract methods, the subclass must be defined as abstract. In other words, in a nonabstract subclass extended from an abstract class, all the abstract methods must be implemented. Also note that abstract methods are nonstatic. � An abstract class cannot be instantiated using the new operator, but you can still define its constructors, which are invoked in the constructors of its subclasses. For instance, the constructors of Geometric. Object are invoked in the Circle class and the Rectangle class. � A class that contains abstract methods must be abstract. However, it is possible to define an abstract class that doesn’t contain any abstract methods. In this case, you cannot create instances of the class using the new operator. This class is Object Oriented Programming 41 used as a base class for defining subclasses. �

Cont. A subclass can be abstract even if its superclass is concrete. For example, the Object class is concrete, but its subclasses, such as Geometric. Object, may be abstract. � You cannot create an instance from an abstract class using the new operator, but an abstract class can be used as a data type. Therefore, the following statement, which creates an array whose elements are of the Geometric. Object type, is correct. Geometric. Object[] objects = new Geometric. Object[10]; You can then create an instance of Geometric. Object and assign its reference to the array like this: objects[0] = new Circle(); � Object Oriented Programming 42

Why abstract methods? �You may be wondering what advantage is gained by defining the methods get. Area() and get. Perimeter() as abstract in the Geometric. Object class. �Note that you could not define the equal. Area method for comparing whether two geometric objects have the same area if the get. Area method were not defined in Geometric. Object Oriented Programming 43

Abstract method must be inside abstract class and it does not have body It should be public abstract class A Abstract method must be inside abstract class legal Object Oriented Programming 44

Program �Design a new Triangle class that extends the abstract Geometric. Object class and then implement the Triangle class. Write a test program that prompts the user to enter three sides of the triangle, a color, and a Boolean value to indicate whether the triangle is filled. The program should create a Triangle object with these sides and set the color and filled properties using the input. The program should display the area, perimeter, color, and true or false to indicate whether it is filled or not. Object Oriented Programming 45

Interfaces �An interface is a class-like construct that contains only constants and abstract methods. �In many ways an interface is similar to an abstract class, but its intent is to specify common behavior for objects of related classes or unrelated classes. �Using interface, you can specify what a class must do, but not how it does it. Object Oriented Programming 46

Cont. � Interfaces are syntactically similar to classes, but they lack instance variables, and, as a general rule, their methods are declared without any body. In practice, this means that you can define interfaces that don’t make assumptions about how they are implemented. � An interface is treated like a special class in Java. Each interface is, just like a regular class. compiled into a separate bytecode file � You can use an interface as a data type for a reference variable, as the result of casting, and so on. � As with an abstract class, you cannot create an instance from an interface using the new operator. Object Oriented Programming 47

Cont. �Variables are implicitly final and static, meaning they cannot be changed by the implementing class. �They must also be initialized. All methods and variables are implicitly public. �interface_1. java Object Oriented Programming 48

Accessing implementation through interface reference �You can declare variables of interface as object references that use an interface rather. �Any instance of any class that implements the declared interface can be referred to by such a variable. �When you call a method through one of these references, the correct version will be called based on the actual instance of the interface being referred to. �This is one of the key features of interfaces. �interface_2. java and interface_3. java Object Oriented Programming 49

Variables in interface �You can use interfaces to import shared constants into multiple classes by simply declaring an interface that contains variables that are initialized to the desired values. �Implementing class does not implement any method. �It is as if that class were importing the constant fields into the class name space as final variables. Object Oriented Programming 50

Interface can be extended �One interface can inherit another by use of the keyword extends. �When a class implements an interface that inherits another interface, it must provide implementations for all methods required by the interface inheritance chain. �interface_4. java Object Oriented Programming 51

Default Interface methods �Prior to JDK 8, an interface could not define any implementation whatsoever. �A default method lets you define a default implementation for an interface method. �A primary motivation for the default method was to provide a means by which interfaces could be expanded without breaking existing code. �Thus, the addition of a default method will not cause preexisting code to break. Object Oriented Programming 52

Multiple inheritance issue �Assume that two interfaces called Alpha and Beta are implemented by a class called My. Class. �What happens if both Alpha and Beta provide a method called reset( ) for which both declare a default implementation? Is the version by Alpha or the version by Beta used by My. Class? �Or, consider a situation in which Beta extends Alpha. Which version of the default method is used? Or, what if My. Class provides its own implementation of the method? Object Oriented Programming 53

Cont. �First, in all cases, a class implementation takes priority over an interface default implementation. In this case, both defaults are overridden by My. Class’ implementation. �If My. Class implements both Alpha and Beta, but does not override reset( ), then an error will occur. �If Beta extends Alpha, then Beta’s version of reset( ) will be used. �For example, if Beta wants to refer to Alpha’s default for reset( ), it can use this statement: Alpha. super. reset(); Object Oriented Programming 54

Static methods in interface �JDK 8 added another new capability to interface: the ability to define or more static methods. �Thus, no implementation of the interface is necessary, and no instance of the interface is required, in order to call a static method. �Static interface methods are not inherited by either an implementing class or a subinterface. Object Oriented Programming 55

Abstract class Interface can have only abstract methods. 1) Abstract class can have abstract and Since Java 8, it can have default and non-abstract methods. static methods also. 2) Abstract class doesn't support multiple Interface supports multiple inheritance. 3) Abstract class can have final, nonfinal, static and non-static variables. Interface has only static and final variables. 4) Abstract class can provide the implementation of interface. Interface can't provide the implementation of abstract class. 5) The abstract keyword is used to declare abstract class. The interface keyword is used to declare interface. 6) An abstract class can extend another An interface can extend another Java class and implement multiple Java interface only. interfaces. 7) An abstract class can be extended using keyword "extends". An interface can be implemented using keyword "implements". 8) A Java abstract class can have class Members of a Java interface are public members like private, protected, etc. by default. 9)Example: public abstract class Shape{ public abstract void draw(); } Example: public interface Drawable{ void draw(); } Object Oriented Programming 56

When to use what? Consider using abstract classes if any of these statements apply to your situation: � In java application, there are some related classes that need to share some lines of code then you can put these lines of code within abstract class and this abstract class should be extended by all these related classes. � You can define non-static or non-final field(s) in abstract class, so that via a method you can access and modify the state of Object to which they belong. � You can expect that the classes that extend an abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private). Consider using interfaces if any of these statements apply to your situation: � It is total abstraction, All methods declared within an interface must be implemented by the class(es) that implements this interface. � A class can implement more than one interface. It is called multiple inheritance. � You want to specify the behavior of a particular data type, but not concerned about who implements its behavior. Object Oriented Programming 57

Array. List Class �A very useful class for storing objects �You can create an array to store objects. But, once the array is created, its size is fixed. �Array. List class, which can be used to store an unlimited number of objects. Object Oriented Programming 58

Cont. �Array. List is known as a generic class with a generic type E. �You can specify a concrete type to replace E when creating an Array. List. �For example, the following statement creates an Array. List and assigns its reference to variable cities. �This Array. List object can be used to store strings. Array. List<String> cities = new Array. List<String>(); � This Array. List object can be used to store dates. Array. List<java. util. Date> (); dates = new Test. Array. List. java Object Oriented Programming 59

Object Oriented Programming 60

Cont. �Suppose you want to create an Array. List for storing integers. Can you use the following code to create a list? Array. List<int> list = new Array. List<>(); �No. This will not work because the elements stored in an Array. List must be of an object type. �You cannot use a primitive data type such as int to replace a generic type. However, you can create an Array. List for storing Integer objects as follows: Array. List<Integer> list = new Array. List<>(); Distinct. Numbers. java Object Oriented Programming 61