1. POLYMORPHISM Chapter 6

2. Chapter 5 6.0 Polymorphism  Polymorphism concept  Abstract classes and methods  Method overriding  Concrete sub classes and methods  Array of super classes  Interfaces

3. Polymorphism concept  Polymorphism means “having many forms”  It is the ability to use the same name to refer to methods that perform different tasks.  Ability of a variable to have more than one type – hold values of different types.  Let us code generically like parameter, it lets us write code that is both general and tailored to a particular situation.

4. Polymorphism concept  Advantages :-  Allows different (but related) objects the flexibility to respond differently to the same message.  Allow objects to treat other objects in a general way.  Code sharing  Disadvantages :-  When you use it, you must treat different objects in a general way  Just by looking at the source code, it is not possible to determine which code is executed.

5. Polymorphism concept  To expand the usage and the effectiveness of polymorphism, we have to apply the concept of abstract class and the array  Method Overriding: a subclass inherits methods from a superclass, and the subclass modify the implementation of a method defined in the superclass  Method Overloading define multiple methods with the same name but different signatures

6. Abstract Class

7.  An abstract class is a common solution when we know the subclass is likely to override the superclass.  Main reason :-  To avoid redundant codes  Several concrete classes have some common code that can be implemented in a single superclass.  A class is declared as abstract by including the keyword abstract in the class’s header line, example: abstract class student { }

8. Abstract Class  Similar to a concrete class :-  Is compiled with a bytecode file xyz.class if the class name is xyz.  Has either public, protected, private or package accessibility  Cannot be public unless it has the same name as its source code file.  Serves as type for declaring variables and parameters  May include constructors  May include methods, classes and interfaces  Difference to a concrete class :-  May contain abstract method  Cannot be instantiated

9. Abstract Methods  Describes a behavior or action for a method in the abstract class.  Defining a method that is deferred.  Specified in the parentclass but must be implemented in a child class.  Has no code body, no braces { } – contains only a header line.  A placeholder that requires all derived classes to override and complete the method.  All of the abstract methods must be overridden by methods in the concrete (complete) subclasses.  Advantage : conceptual – allows the programmer to think of an activity as associated with an abstraction at a higher level.  An abstract methods cannot be declared as either static or final.  Example : abstract public void getmessage();

10. Example of abstract class and method public abstract class Shape { private double x, y; public abstract double getArea(); public abstract double getCircumference(); public double getX(){ return x; } public double getY(){ return y; } public void setX(double x){ this.x = x; } public void setY(double y){ this.y = y; } }

11. public abstract class Card{ String recipient; public abstract void greeting(); } Example of abstract class and method class HariRaya extends Card{ public HariRaya(String r){ recipient = r; } public void greeting(){ System.out.println(“Dear “ + recipient + “, \n Selamat Hari Raya”); } class Birthday extends Card{ public Birthday(String r){ recipient = r; } public void greeting(){ System.out.println(“Dear “ + recipient + “, \n Happy Birthday”); } class CardApp { public static void main(String[] args) { Card c; c = new Birthday(“Miss X”); c.greeting(); c = new HariRaya(“Mr Y”); c.greeting(); }

12. Array in Polymorphism  Similar to implement the array in the inheritance concept. But we want the reference of array which is comes from the parent class.  You might want to create a superclass reference and treat subclass objects as superclass objects so you can create an array of different objects that share the same ancestry.  Manipulate an array of subclass objects by invoking the appropriate method for each subclass.  Elements in a single array must be of the same type.

13. Array in Polymorphism From the previous slide example – CardApp class CardArrayApp { public static void main(String[] args) { Card[] c = new Card[12]; Birthday B = new Birthday(“Miss X”); HariRaya H = new HariRaya(“MR Y”); c[0] = B; c[1] = H; for (int j = 0; j <= 1; j++) c[j].greeting(); }

14. Method Overriding  When a class defines a method using the same name, return type, and arguments as a method in its superclass, the method in the class overrides the method in the superclass.  When the method is invoked for an object of the class, it is the new definition of the method that is called, not the superclass’s old definition.  The overriding method must have the same name, arguments and return type as the overriden method.  Typically used for abstract method.  Can occur in two different forms :-  Replacement A method can replace the method in parent class. Code in parent class is not executed at all.  Refinement Combines the code from parent and child class – the use of keyword super (constructor)

15. Interface  Consists of constants and abstract methods only.  Cannot be instantiated  Purpose to specify a set of requirements for classes to implement.  Requirements as a “contract” between implementing class and any client class that uses it.  Important part of OOD is to create the interface when class implementation will be done later.  Description of a capability  List the methods that a class must implement to carry out that capability.  A class may implement several interfaces  An interface may be implemented by several classes  All abstract methods declared in an interface must be public and abstract.

16. Interface  Different from class :-  Declared only method headers and public constants  Has no constructors  Cannot be instantiated  Can be implemented by class  Cannot implement an interface  Cannot extend a class  Can extend several other interfaces.

17. Interface  Has the general syntax : interface interfacename{ //constant declarations; //abstract method declarations; }  A class that is derived from an interface by using keyword implements class classname implements interfacename{ //override definitions of all abstract //methods ; }

18. Example : Interface public abstract class Animal{ } public class Dog extends Animal { } public interface Worker{ } public class WorkingDog extends Dog implements Worker { } public class DemoWorkingDog{ }

19. 19 Superclass: Animal

20. Subclass: Dog

21. Interface: Worker

22. Subclass: WorkingDog

23. Application

24. Output ?