Di dalam Java polymorphism dibagi menjadi dua tipe:
- Compile time Polymorphism (Overloading)
- Runtime Polymorphism (Overriding)
class MultiplyFun {
// Metode dengan 2 parameter
static int Multiply(int a, int b)
{
return a * b;
}
// Metod dengan nama sama tetapi 2 double parameter
static double Multiply(double a, double b)
{
return a * b;
}
}
class Main {
public static void main(String[] args)
{
System.out.println(MultiplyFun.Multiply(2, 4));
System.out.println(MultiplyFun.Multiply(5.5, 6.3));
}
}
8
34.65
Metode Overriding: Metode ini dikenal sebagai Pengiriman Metode Dinamis yaitu proses di mana panggilan fungsi ke metode yang akan diganti diselesaikan pada saat proses. Jenis polimorfisme ini dicapai dengan Metode Penimpaan. Metode ini terjadi ketika kelas turunan memiliki definisi untuk salah satu fungsi anggota kelas dasar dan fungsi dasar tersebut akan diganti (overrriden).
// Java program for Method overriding
class Parent {
void Print()
{
System.out.println("parent class");
}
}
class subclass1 extends Parent {
void Print()
{
System.out.println("subclass1");
}
}
class subclass2 extends Parent {
void Print()
{
System.out.println("subclass2");
}
}
class TestPolymorphism3 {
public static void main(String[] args)
{
Parent a;
a = new subclass1();
a.Print();
a = new subclass2();
a.Print();
}
}
subclass1
subclass2
class derived-class extends base-class { //methods and fields }
// kelas induk
class Sepeda {
// kelas sepeda memiliki dua atribut (fields)
public int gear;
public int speed;
// kelas sepeda memiliki satu konstruktor
public Sepeda(int gear, int speed) {
this.gear = gear;
this.speed = speed;
}
// kelas sepeda memiliki tiga metode
public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {
speed += increment;
}
// toString() adalah metode untuk cetak info dari sepeda
public String toString() {
return("nomor gear adalah "+gear
+"\n"
+ "kecepatan sepeda adalah "+speed);
}
}
// kelas turunan
class SepedaGunung extends Sepeda {
//pada subclass SepedaGunung ditambahkan lagi satu field
public int seatHeight;
//kelas SepedaGunung memiliki satu konstruktor
public SepedaGunung(int gear,int speed,
int startHeight)
{
// memanggil konstruktor dari kelas induk (Sepeda)
super(gear, speed);
seatHeight = startHeight;
}
//ditambahakan lagi satu metod baru
public void setHeight(int newValue)
{
seatHeight = newValue;
}
// overriding toString() method
@Override
public String toString()
{
return (super.toString()+
"\n tinggi kursi adalah "+seatHeight);
}
}
// driver class
public class Tes
{
public static void main(String args[])
{
SepedaGunung sg= new SepedaGunung(3, 100, 25);
System.out.println(sg.toString());
}
}
// Java program untuk demo enkapsulasi
public class Encapsulate
{
// private variables declared
// these can only be accessed by
// public methods of class
private String Name;
private int Age;
// get method for age to access
// private variable Age
public int getAge()
{
return Age;
}
// get method for name to access
// private variable Name
public String getName()
{
return Name;
}
// set method for age to access
// private variable age
public void setAge( int newAge)
{
Age = newAge;
}
// set method for name to access
// private variable Name
public void setName(String newName)
{
Name = newName;
}
}
Dalam program di atas kelas Encapsulate dienkapsulasi saat variabel dideklarasikan sebagai privat. Metode getter seperti getAge (), getName () diatur sebagai publik, metode ini digunakan untuk mengakses variabel ini. Metode setter seperti setName (), setAge (), juga dideklarasikan sebagai publik dan digunakan untuk melakukan setting nilai variabel.
Program untuk mengakses variable kelas dari Encapsulate adalah seperti di bawah ini:
public class TestEncapsulation
{
public static void main (String[] args)
{
Encapsulate obj = new Encapsulate();
// setting values of the variables
obj.setName("Munarso");
obj.setAge(25);
// Displaying values of the variables
System.out.println("Name: " + obj.getName());
System.out.println("Age: " + obj.getAge());
}
}
// concept of Abstraction
abstract class Shape
{
String color;
// these are abstract methods
abstract double area();
public abstract String toString();
// abstract class can have constructor
public Shape(String color) {
System.out.println("Shape constructor called");
this.color = color;
}
// this is a concrete method
public String getColor() {
return color;
}
}
class Circle extends Shape
{
double radius;
public Circle(String color,double radius) {
// calling Shape constructor
super(color);
System.out.println("Circle constructor called");
this.radius = radius;
}
@Override
double area() {
return Math.PI * Math.pow(radius, 2);
}
@Override
public String toString() {
return "Circle color is " + super.color +
"and area is : " + area();
}
}
class Rectangle extends Shape{
double length;
double width;
public Rectangle(String color,double length,double width) {
// calling Shape constructor
super(color);
System.out.println("Rectangle constructor called");
this.length = length;
this.width = width;
}
@Override
double area() {
return length*width;
}
@Override
public String toString() {
return "Rectangle color is " + super.color +
"and area is : " + area();
}
}
public class Test
{
public static void main(String[] args)
{
Shape s1 = new Circle("Red", 2.2);
Shape s2 = new Rectangle("Yellow", 2, 4);
System.out.println(s1.toString());
System.out.println(s2.toString());
}
}
Output:
Shape constructor called
Circle constructor called
Shape constructor called
Rectangle constructor called
Circle color is Red and area is : 15.205308443374602
Rectangle color is Yellow and area is : 8.0
0 Komentar