2017

PEMROGRAMAN LANJUT Sistem Informasi FILKOM UB Semester Genap 2016/2017

POLIMORPHISM

Dr. Eng. Herman Tolle Fakultas Ilmu Komputer, Universitas Brawijaya

Kata Kunci • Polymorphism | Polimorfisme • Supertype, Subtype • Static Polymorphism | Static Binding • Dynamic Polymorphism • Dynamic Binding • Casting

Polymorphism • Polymorphism | Polimorfisme • Morph à berubah bentuk

• Kemampuan dari sebuah objek untuk berubah bentuk menyesuaikan dengan referensi objek yang ditentukan oleh program yang kita buat • Static Polymorphism dan Dynamic Polymorphism

Polymorphism Polymorphism means that a variable of a supertype can refer to a subtype object. 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 GeometricObject and GeometricObject is a supertype for Circle. 4

Polymorphism Polymorphism: sebuah variabel dari sebuah supertype dapat merefer ke sebuah objek subtype Sebuah kelas dapat dianggap sebagai sebuah tipe data Sebuah type yang didefinisikan oleh subclass disebut subtype, dan tipe yang didefiniskan oleh kelas induknya disebut supertype. Circle is a subtype of GeometricObject and GeometricObject is a supertype for Circle. 5

Polymorphism, Dynamic Binding and Generic Programming public class PolymorphismDemo { public static void main(String[] args) { m(new GraduateStudent()); m(new Student()); m(new Person()); m(new Object()); } public static void m(Object x) { System.out.println(x.toString()); } }

Method m takes a parameter of the Object type. You can invoke it with any object. An object of a subtype can be used wherever its supertype value is required. This feature is known as polymorphism.

class GraduateStudent extends Student { } class Student extends Person { public String toString() { return "Student"; } } class Person extends Object { public String toString() { return "Person"; } }

When the method m(Object x) is executed, the argument x’s toString method is invoked. x may be an instance of GraduateStudent, Student, Person, or Object. Classes GraduateStudent, Student, Person, and Object have their own implementation of the toString method. Which implementation is used will be determined dynamically by the Java Virtual Machine at runtime. This capability is known as dynamic binding. 6

Static Polymorphism • In Java, static polymorphism is achieved through method overloading. • Method overloading means there are several methods present in a class having the same name but different types/order/number of parameters. • At compile time, Java knows which method to invoke by checking the method signatures. • This is called compile time polymorphism or static binding.

7

Demo Overload class DemoOverload{ public int add(int x, return x+y; } public int add(int x, return x+y+z; } public int add(double return (int)x+y; } public int add(int x, return x+(int)y; } }

int y) {

//method 1

int y, int z){

//method 2

x, int y){ //method 3

double y){ //method 4

class Test { public static void main(String[] args){ DemoOverload demo=new DemoOverload(); System.out.println(demo.add(2,3)); //method 1 System.out.println(demo.add(2,3,4)); //method System.out.println(demo.add(2,3.4)); //method System.out.println(demo.add(2.5,3)); //method } } Results?

called 2 called 4 called 3 called

Dynamic Polymorphism: • Misalkan suatu subclass meng-override suatu metode dari superclass nya • Anggap jika dalam program kita membuat suatu objek dari subclass dan meng-assign-kan ke referensi superclass • Maka jika kita memanggil metode yg di-override dari superclass td, yang akan dipanggil (dikerjakan) adalah versi metode dari subclass-nya

class Vehicle{ public void move(){ System.out.println(“Vehicles can move!!”); } } class MotorBike extends Vehicle{ public void move(){ System.out.println(“MotorBike can move and accelerate too!!”); } }

class Test{ public static void main(String[] args){ Vehicle vh=new MotorBike(); vh.move(); // prints MotorBike can move and accelerate too!! vh=new Vehicle(); vh.move(); // prints Vehicles can move!! } }

Contoh public class Bicycle {} public class RoadBike extends Bicycle {} public class MountainBike extends Bicycle {} public class TestBikes { public static void main(String[] args){ Bicycle bike01, bike02, bike03; bike01 = new Bicycle(20, 10, 1); bike02 = new MountainBike(20, 10, 5, "Dual"); bike03 = new RoadBike(40, 20, 8, 23); bike01.printDescription(); bike02.printDescription(); bike03.printDescription(); } }

• An object in Java that passes more than one ISA tests is polymorphic in nature • Sebuah objek yang dapat diisi oleh lebih dari satu bentuk IS-A ß Polimorfism • Static polymorphism in Java is achieved by method overloading • Dynamic polymorphism in Java is achieved by method overriding

Contoh • Class induk Person dan subclass Student, kita tambahkan subclass lain dari Person yaitu Employee. • Dalam Java, kita dapat membuat referensi yang merupakan tipe dari superclass ke sebuah object dari subclass tersebut. Sebagai contohnya,

public static void main(String[] args) { Person ref; Student studentObject = new Student(); Employee employeeObject = new Employee(); ref = studentObject; //Person menunjuk kepada object Student //beberapa kode di sini }

• Sekarang dimisalkan kita punya method getName dalam superclass Person kita, dan kita override method ini dalam kedua subclasses Student dan Employee, public class Person { public String getName(){ System.out.println(“Person Name:” + name); return name; } } public class Student extends Person { public String getName(){ System.out.println(“Student Name:” + name); return name; } } public class Employee extends Person { public String getName(){ System.out.println(“Employee Name:” + name); return name; }

public static void main(String[] args) { Person ref; Student studentObject = new Student(); Employee employeeObject = new Employee(); ref = studentObject; //Person menunjuk kepada object Student String temp = ref.getName(); //getName dari Student class dipanggil System.out.println( temp );

ref = employeeObject; //Person menunjuk kepada object Employee String temp = ref.getName(); //getName dari Employee class dipanggil System.out.println( temp ); }

• Ketika kita mencoba memanggil method getName dari reference Person ref, method getName dari object Student akan dipanggil. • Sekarang, jika kita berikan ref ke object Employee, method getName dari Employee akan dipanggil. • Kemampuan dari reference untuk mengubah sifat menurut object apa yang dijadikan acuan dinamakan polimorfisme. • Polimorfisme menyediakan multiobject dari subclasses yang berbeda untuk diperlakukan sebagai object dari superclass tunggal, secara otomatis menunjuk method yang tepat untuk menggunakannya ke particular object berdasar subclass yang termasuk di dalamnya

• Contoh lain yang menunjukkan properti polimorfisme adalah ketika kita mencoba melalui reference ke method. • Misalkan kita punya method static printInformation yang mengakibatkan object Person sebagai reference, kita dapat mereference dari tipe Employee dan tipe Student ke method ini selama itu masih subclass dari class Person.

public static main( String[] args ) { Student studentObject = new Student(); Employee employeeObject = new Employee(); printInformation( studentObject ); printInformation( employeeObject ); } public static printInformation( Person p ) { . . . . }

Method Matching vs. Binding • Matching a method signature and binding a method implementation are two issues. • The compiler finds a matching method according to parameter type, number of parameters, and order of the parameters at compilation time. • A method may be implemented in several subclasses. • The Java Virtual Machine dynamically binds the implementation of the method at runtime. 20

Generic Programming public class PolymorphismDemo { public static void main(String[] args) { m(new GraduateStudent()); m(new Student()); m(new Person()); m(new Object()); } public static void m(Object x) { System.out.println(x.toString()); } } class GraduateStudent extends Student { } class Student extends Person { public String toString() { return "Student"; } } class Person extends Object { public String toString() { return "Person"; } }

Polymorphism allows methods to be used generically for a wide range of object arguments. This is known as generic programming. If a method’s parameter type is a superclass (e.g., Object), you may pass an object to this method of any of the parameter’s subclasses (e.g., Student or String). When an object (e.g., a Student object or a String object) is used in the method, the particular implementation of the method of the object that is invoked (e.g., toString) is determined 21 dynamically.

Casting Objects You have already used the casting operator to convert variables of one primitive type to another. Casting can also be used to convert an object of one class type to another within an inheritance hierarchy. In the preceding section, the statement m(new Student());

assigns the object new Student() to a parameter of the Object type. This statement is equivalent to: Object o = new Student(); // Implicit casting m(o); The statement Object o = new Student(), known as implicit casting, is legal because an instance of Student is automatically an instance of Object. 22

Why Casting Is Necessary? Suppose you want to assign the object reference o to a variable of the Student type using the following statement: Student b = o;

A compile error would occur. Why does the statement Object o = new Student() work and the statement Student b = o doesn’t? This is because 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 so clever to know it. To tell the compiler that o is a Student object, use an explicit casting. The syntax is similar to the one used for casting among primitive data types. Enclose the target object type in parentheses and place it before the object to be cast, as follows: 23 Student b = (Student)o; // Explicit casting

Casting from Superclass to Subclass Explicit casting must be used when casting an object from a superclass to a subclass. This type of casting may not always succeed. Apple x = (Apple)fruit; Orange x = (Orange)fruit;

24

The instanceof Operator Use the instanceof operator to test whether an object is an instance of a class: Object myObject = new Circle(); ... // Some lines of code /** Perform casting if myObject is an instance of Circle */ if (myObject instanceof Circle) { System.out.println("The circle diameter is " + ((Circle)myObject).getDiameter()); ... } 25

Summary • Static Polymorphism à Method overloading • Dynamic Polymorphism à Method overriding • Sebuah objek (dengan tipe data) dari class induk, dapat diisi dengan objek dari class turunannya ß Polymorphism • Polimorfism adalah kemampuan dari Bahasa pemrograman untuk memproses objek secara berbeda tergantung pada tipe data atau class nya • More specifically, it is the ability to redefine methods for derived classes. Kemampuan untuk mendefiniskan ulang metode berdasarkan kelas turunannya