Course : Course Name

Effective Period : July 2020

Polymorphism

Session 4
 Learning Outcomes

LO 1 EXPLAIN Object Oriented concept

LO 2 SOLVE the algorithm problem using Object
Oriented concept
LO 3 CONSTRUCT a simple application with Object
Oriented concept
 Contents

Outline
• Introduction
• Types of polymorphism
• Implementing Polymorphism
• Casting object
• The instanceof Operator
• The ArrayList Class
Introduction
• What is Polymorphism and why do we need that?

• Polymorphism means many forms / shapes

• It is one of the 3 pillars of OOP besides encapsulation
and inheritance
• Efficient and less redundancy
Types of Polymorphism
1) Static Polymorphism
• This can be achieved by using overloading method
• Overloading means there are several methods
present in a class having the same name but
different types / order / number of parameters
• It is known as well as compile time polymorphism or
static binding
• At compile time, Java known which method to invoke
by checking the method signatures
Static Polymorphism
• Example
• public class Calculator{
public int add(int x, int y){
return x+y;
}

public int add(int x, int y, int z){

return x+y+z;
}

public double add(double x, double y){

return x+y;
}

public double add(double x, double y, double z){

return x+y+z;
}
}
 Contoh Lengkap

• Static Polymorphisme
class DisplayOverload {
public void show(int num) {
public class
System.out.println("Display an integer: " + num); StaticPolymorphismExample {
}
public static void main(String[]
public void show(String str) {
args) {
System.out.println("Display a string: " + str);
} DisplayOverload obj = new
public void show(byte num) {
DisplayOverload();
System.out.println("Display a byte: " + num);
obj.show(5);
}
obj.show("Hello Polymorphism");
public void show(int num1, double num2) {
System.out.println("Display an integer and a double: " + num1 + obj.show(100, 123.456);
", " + num2);
} obj.show(123.456, 100);
public void show(double num2, int num1) {
obj.show((byte) 101); // Explicitly
System.out.println("Display a double and an integer: " + num2 + casting to match the byte parameter
", " + num1);
}
method
// ... you can add more overloaded methods with different
}
parameter lists }
}
Types of Polymorphism
2) Dynamic Polymorphism
• This can be achieved by
1) overriding a particular method of the superclass
2) Implementing Abstract
3) Implementing Interface
• As the method to call is determined at runtime
• It is known as well as dynamic binding
Dynamic Polymorphism (1)
• Example – Overriding a particular method of the superclass

• public class Vehicle{

public void move(){
System.out.println("Vehicle can move!");
}
}

class MotorBike extends Vehicle{

public void move(){
System.out.println("Motorbike can move!");
}
}
2) Dynamic Polymorphism
• Contoh lainnya:
class Animal {
void sound() { In this code, even though
}
System.out.println("The animal makes a sound"); the type of obj is Animal, the
} output will be "The dog
class Dog extends Animal { barks" because the sound
void sound() {
System.out.println("The dog barks");
method of the Dog class
} overrides the Animal class's
}
sound method, and the
public class TestPolymorphism {
public static void main(String args[]) {
actual object type is Dog.
Animal obj = new Dog();
obj.sound();
}
This decision is made at
} runtime, which is why it's
known as dynamic
polymorphism.
Dynamic Polymorphism (2)
• Abstract Class
• Declare general characteristic of a subclass
• Declared abstractly
• Could not create an object using operator new
• Only use as a superclass from other classes and form
in abstract
• Declared using keyword abstract
• Superclass have to be real so it can be abstracted to
subclass
Dynamic Polymorphism (3)
• Abstract Class
• A template of design for subclass
• Provides an abstract funcstion too (abstract class)
• Function is overridden in subclass
• An object should be able to implement all abstract
method in an abstract class
Dynamic Polymorphism (4)
• Example – Implementing Abstract Class
• abstract class Shape{ //Declaration of abstract class
private int x,y;
public abstract double computeArea(); //Declaration of abstract
method
}
 Dynamic Polymorphism (5)
Example – Implementing Abstract Class
• class Rectangle extends Shape{ • Class Rectangle is
private double width = 12; inheritance of abstract
private double height = 20;
public double computeArea(){ class Shape (using
return width * height; extends keyword)
}
} • computeArea() function
that overridden from its
class Circle extends Shape{
private double radius = 20;
superclass
public double computeArea(){ • The same happened
return Math.PI * radius *
radius;
with Circle class
}
}
 Contoh Shape Class
abstract class Shape { class Rectangle extends Shape {
String color; double width; In this example, Shape is an
double height;
// constructor to set the color abstract class with abstract
Shape(String color) { Rectangle(String color, double width, double
this.color = color; height) { methods area() and
super(color);
}
this.width = width; describe().
// abstract method to calculate area this.height = height;
abstract double area(); }

// abstract method to describe the shape @Override The classes Circle and
double area() {
abstract String describe();
return width * height; Rectangle extend Shape
// non-abstract method
String getColor() {
}
and provide concrete
}
return color; @Override
String describe() { implementations for these
} return "A rectangle with width " + width + " and
height " + height + " and color " + getColor(); methods.
class Circle extends Shape { }
double radius; }

Circle(String color, double radius) { public class TestShapes { When methods like
super(color);
this.radius = radius;
public static void main(String[] args) {
Shape shape1 = new Circle("Red", 2.2); describe() and area() are
} Shape shape2 = new Rectangle("Blue", 2, 3);
called on a Shape reference
@Override
double area() {
System.out.println(shape1.describe());
System.out.println("Area: " + shape1.area());
pointing to a Circle or
}
return Math.PI * Math.pow(radius, 2);
System.out.println(shape2.describe());
Rectangle object, the
@Override }
System.out.println("Area: " + shape2.area());
corresponding method for
String describe() {
return "A circle with radius " + radius + " and color " +
}
the actual object type
getColor();
}
(Circle or Rectangle) is
} executed at runtime.
Dynamic Polymorphism (6)
• Example – Interface Class
• Consist only of constants and abstract methods
• Can not make an object with the new operator
• Create a subclass that has more than one superclass
(Multiple inheritance solution)
• Not inherited but implemented
• Declared using keyword interface
• In subclass using keyword implements
Dynamic Polymorphism (7)
• Example – Interface Class
• Each interface is compiled into bytecode lines, just
like regular class
• All method declared in interface should be
overridden by implementing class
Dynamic Polymorphism (8)
• Example – Implementing Interface Class
• interface Animal { //Declare interface class
public void eat(); //Abstract method
public void travel(); //Abstract method
}
• public class Mammal implements Animal { //Using implement if you want
// to use interface class Shape
public void eat() { //Function in interface class Animal
// should be overridden in subclass point
System.out.println("Mammal eats");
}

public void travel() { //Function in interface class Animal

// should be overridden in subclass point
System.out.println("Mammal travels");
}
Contoh kelas Abstract dan bukan Abstract

Abstract Konkrit
abstract class Kendaraan { class Kendaraan {
abstract void bergerak(); void bergerak() {
} System.out.println("Kendaraan bergerak.");
}
class Mobil extends Kendaraan { }
void bergerak() {
class Mobil extends Kendaraan {
System.out.println("Mobil berjalan di jalan raya."); @Override
} void bergerak() {
} System.out.println("Mobil berjalan di jalan raya.");
}
class Perahu extends Kendaraan { }
void bergerak() {
class Perahu extends Kendaraan {
System.out.println("Perahu berlayar di laut.");
@Override
} void bergerak() {
} System.out.println("Perahu berlayar di laut.");
}
public class Main { }
public static void main(String[] args) {
Kendaraan mobil = new Mobil(); public class Main { public static void main(String[] args)
Kendaraan perahu = new Perahu(); { Kendaraan kendaraan = new Kendaraan(); // Error: Kendaraan
adalah kelas abstrak dan tidak bisa diinstansiasi
mobil.bergerak(); // Output: Mobil berjalan di jalan raya. Kendaraan mobil = new Mobil(); // Ini benar, karena Mobil
perahu.bergerak(); // Output: Perahu berlayar di laut. adalah subkelas konkret dari Kendaraan mobil.bergerak(); //
} Output akan benar: Mobil berjalan di jalan raya. } }
}

Pada baris Kendaraan kendaraan = new Kendaraan(); akan terjadi error kompilasi karena Kendaraan adalah kelas
abstrak. Java melarang pembuatan objek langsung dari kelas abstrak karena kelas abstrak biasanya tidak memiliki
implementasi lengkap. Kesalahan ini memaksa kita untuk hanya membuat objek dari kelas-kelas konkret yang telah
menyediakan implementasi untuk semua metode abstraknya. Ini adalah bagaimana Java menerapkan konsep
polimorfisme dinamis melalui kelas abstrak.
Interface VS Abstract Class
Casting Object (1)
• Converting an object from a class to other
type class in an inheritance hierarchy
• There are 2 kind of Casting Object :
1. Implicit Casting
Object obj = new MountainBike();
2. Explicit Casting
MountainBike myBike = (MountainBike) obj;
• Error if:
Student b = o;
• Because a student object is an instance of Object, but
an Object is not necessarily an instance of Student.
Casting Object (2)
• To ensure that the object is an instance of
another object before attempting a casting
• Object myObject = new Circle();
//Peform casting if myObject is an instance of Circle
if (myObject instanceof Circle){
system.out.println("This is an instance of Circle")
}
ArrayList
• To construct ArrayList :
ArrayList<String> cityList = new ArrayList<String>();

• To add String in the object list:

cityList.add("Aachen");
cityList.add("Dresden");
cityList.add("Hamburg");

• To remove a specific String in the object list:

cityList.remove("Dresden");

• To remove the cityList by specifying the index:

cityList.remove(1);
 Contoh program lengkap

// Kelas Bicycle dengan atribut, constructor, dan metode

public class Bicycle { // Kelas MountainBike yang merupakan turunan dari Bicycle
private int gear; public class MountainBike extends Bicycle {
private int speed; private int seatHeight;

// Constructor
// Constructor
public Bicycle(int gear, int speed) {
public MountainBike(int gear, int speed, int startHeight) {
this.gear = gear;
this.speed = speed; super(gear, speed);
} seatHeight = startHeight;
}
// Metode untuk meningkatkan kecepatan sepeda
public void speedUp(int increment) { // Metode khusus untuk MountainBike
speed += increment; public void setSeatHeight(int newHeight) {
} seatHeight = newHeight;
}
// Metode untuk mengurangi kecepatan sepeda
public void applyBrake(int decrement) {
// Getter untuk seatHeight
speed -= decrement;
public int getSeatHeight() {
}
return seatHeight;
// Getter dan Setter }
public int getGear() { }
return gear;
} // Kelas utama untuk menunjukkan casting objek
public class Main {
public void setGear(int gear) { public static void main(String[] args) {
this.gear = gear; // Implicit casting ke Bicycle
}
Bicycle bike = new MountainBike(3, 100, 25);

public int getSpeed() {

// Explicit casting kembali ke MountainBike
return speed;
} if (bike instanceof MountainBike) {
MountainBike mountainBike = (MountainBike) bike;
public void setSpeed(int speed) { mountainBike.setSeatHeight(30);
this.speed = speed; }
} }
} }
Dalam contoh ini, kita memiliki dua kelas: Bicycle dan MountainBike. MountainBike adalah subclass dari Bicycle. Dalam main method, kita menciptakan instance
dari MountainBike, tetapi menugaskannya ke variabel tipe Bicycle. Ini merupakan implicit casting. Kemudian kita melakukan explicit casting untuk mengubahnya
kembali ke MountainBike setelah memeriksa dengan instanceof bahwa objek tersebut memang instance dari MountainBike.
 program lengkap terpisah

// Bicycle.java
// Kelas Bicycle dengan atribut gear dan speed beserta setter dan getter-nya
// MountainBike.java
// Kelas MountainBike menambahkan atribut
public class Bicycle {
private int gear; seatHeight
private int speed;
// Implicit casting terjadi ketika sebuah
public Bicycle(int gear, int speed) { MountainBike dianggap sebagai Bicycle
this.gear = gear;
this.speed = speed;
}
public class MountainBike extends Bicycle {
// Method untuk meningkatkan kecepatan sepeda private int seatHeight;
public void speedUp(int increment) {
speed += increment;
}
public MountainBike(int gear, int speed, int
// Method untuk mengurangi kecepatan sepeda startHeight) {
public void applyBrake(int decrement) {
speed -= decrement; super(gear, speed);
}
seatHeight = startHeight;
// Getter untuk gear }
public int getGear() {
return gear;
}
// Method untuk mengatur tinggi seat
// Setter untuk gear
public void setGear(int gear) {
public void setSeatHeight(int newHeight) {
this.gear = gear; seatHeight = newHeight;
}
}
// Getter untuk speed
public int getSpeed() {
return speed; // Getter untuk seatHeight
}
public int getSeatHeight() {
// Setter untuk speed
public void setSpeed(int speed) { return seatHeight;
}
this.speed = speed;
}
} }
Setiap file di atas harus disimpan dengan nama yang sesuai (Bicycle.java, MountainBike.java, Main.java) dalam direktori yang sama. Untuk menjalankan program
ini, Anda harus mengkompilasi setiap file dan menjalankan Main.java:
// Main.java
// File utama yang menggabungkan semua komponen dan menunjukkan implicit dan explicit
casting

import java.util.ArrayList;

public class Main {

public static void main(String[] args) {
// Implicit casting - MountainBike dianggap sebagai Bicycle
Bicycle bike = new MountainBike(3, 100, 25);

// Kita tidak perlu cast secara eksplisit untuk mengakses metode dari tipe Bicycle
bike.speedUp(10); // Bekerja karena speedUp ada di Bicycle

// Explicit casting diperlukan untuk mengakses metode khusus dari MountainBike

if (bike instanceof MountainBike) {
// Verifikasi bahwa objek tersebut adalah instance dari MountainBike sebelum casting
MountainBike mountainBike = (MountainBike) bike;
mountainBike.setSeatHeight(30); // Bekerja karena sekarang kita tahu bike adalah
MountainBike
}

// Penggunaan ArrayList untuk menyimpan nama-nama kota

ArrayList<String> cityList = new ArrayList<>();
cityList.add("New York");
cityList.add("London");
cityList.add("Paris");
cityList.remove("London"); // Menghapus "London" dari daftar

// Menampilkan isi ArrayList

for (String city : cityList) {
System.out.println(city);
}
}
}
 Reference

• Introduction to Javaa Programming. 10ed. Liang.

Chapter 11
• https://www.sitepoint.com/quick-guide-to-polymorphis
m-in-java/
• http://www3.ntu.edu.sg/home/ehchua/programming/j
ava/j3b_oopinheritancepolymorphism.html
• https://docs.oracle.com/javase/tutorial/java/IandI/subc
lasses.html

Bina Nusantara