Java OOP | Interface
Interface Di Java
Di java untuk mencapai abstraction selain menggunakan abstract class. Kita juga dapat mencapai abstraction dengan Interface.
Interface merupakan kelas abstrak yang sebenarnya di java. Yang digunakan bertujuan untuk mencapai abstraksi. Hanya dengan mengelompokkan abstract method yang tidak memiliki body implementasi dan menerapkan jenis pewarisan multiple.
Point penting yang harus diingat
- Untuk membuat antarmuka gunakanan keyword interface sebelum nama interface
- Interface tidak bisa di buat/instance sebagai object
- Method interface tidak memiliki body implementasi
- Secara default method interface public asbtract
- Secara default attribute interface public static final
- Di interface tidak bisa membuat method constructor
- Sejak java 8 kita bisa membuat method interface yang memiliki body implementasi dengan keyword default
- Sejak java 8 kita bisa membuat method static dalam interface
- Sejak java 9 kita bisa membuat method private dalam interface
- Di interface kita dapat menerapkan jenis multiple inheritance
Sintaks dasar membuat Interface di java
public interface InterfaceName {
/* mendeklarasikan attribute secara otomatis constanta */
/* medeklarasikan method asbtract */
/* mendeklarasikan method non-abstract sejak java 8 */
}
Untuk membuat sebuah interface gunakanan keyword interface. Setiap kelas yang mewarisi/implements interface harus mengimplemntasikan abstract method dalam interface.
Hubungan Class dan Interface
Untuk mewarisi interface gunakanan keyword implements. Dengan interface kita dapat menerapkan multiple inheritance dimana kelas dijava dapat mewarisi lebih dari satu kelas Parent yaitu interface.
Demonstrasi single inheritance dengan interface:
public interface Email {
/*interface method, secara default public abstract*/
boolean sendMessage(String message);
}
public class Employe implements Email {
/*implementasi interface method*/
public boolean sendMessage(String message) {
if(!message.isBlank()) { /*jika tidak blank*/
System.out.println("Message sent success");
return true;
}
return false;
}
}
File: Main.java
public class Main {
public static void main(String[] args) {
Employe employe = new Employe(); //membuat object Employe
employe.sendMessage("Hello I'am Dewaprogrammer"); //memangil method interface
/*OUTPUT:
Message sent success
*/
}
}
Demonstrasi multiple inheritance dengan interface:
public interface Car {
float getSpeedLimit();
int getCapacity();
}
public interface Repair {
boolean getStatusRepair();
}
public class Toyota implements Car, Repair{
/*implementasi interface method: Car*/
public float getSpeedLimit() {
return 200.0F;
}
/*implementasi interface method: Car*/
public int getCapacity() {
return 8;
}
/*implementasi interface method: Repair*/
public boolean getStatusRepair() {
return false;
}
}
File: Main.java
public class Main {
public static void main(String[] args) {
Toyota toyota = new Toyota(); /*membuat object Toyota*/
System.out.println("Speed Limit Toyota: "+toyota.getSpeedLimit()+" Km");
System.out.println("Toyota Capacity: "+toyota.getCapacity());
System.out.println("Maintance Repair: "+toyota.getStatusRepair());
/*OUTPUT:
Speed Limit Toyota: 200.0 Km
Toyota Capacity: 8
Maintance Repair: false
*/
}
}
Interface Inheritance
Untuk mewarisi interface ke interface yang lain gunakan keyword extends.
Demonstrasi single interface inheritance:
public interface Repair {
boolean getStatusRepair();
}
public interface Car extends Repair {
/*interface method Car*/
float getSpeedLimit();
/*interface method Car*/
int getCapacity();
}
/*kelas implementasi interface Car dan Repair*/
public class Toyota implements Car{
/*implementasi interface method: Car*/
public float getSpeedLimit() {
return 200.0F;
}
/*implementasi interface method: Car*/
public int getCapacity() {
return 8;
}
/*implementasi interface method: Repair*/
public boolean getStatusRepair() {
return false;
}
}
Demonstrasi multiple interface inheritance:
public interface Repair {
boolean getStatusRepair();
}
public interface Category {
void getCategory(String category);
}
public interface Car extends Repair, Category {
/*interface method Car*/
float getSpeedLimit();
/*interface method Car*/
int getCapacity();
}
/*kelas implementasi interface*/
public class Toyota implements Car{
/*implementasi interface method: Car*/
public float getSpeedLimit() {
return 200.0F;
}
/*implementasi interface method: Car*/
public int getCapacity() {
return 8;
}
/*implementasi interface method: Repair*/
public boolean getStatusRepair() {
return false;
}
/*implementasi interface method: Category*/
public void getCategory(String category) {
System.out.println("Toyota Category: "+category);
}
}
Default Method Interface
Sejak java 8 kita bisa membuat method pada interface yang memiliki body implementasi. Dengan keyword default.
Dengan membuat default method maka semua kelas turunannya tidak wajib melakukan override. Hanya diberi Opsi apakah ingin mengoverride atau tidak
Contoh demonstrasi default method interface:
public interface Car {
/*...*/
/*default interface method*/
default boolean isBig() {
return true;
}
}
public class Toyota implements Car {
/*...*/
/*lakukan override default method interface disini*/
}
public class Main {
public static void main(String[] args) {
Car toyota = new Toyota(); /*membuat object Toyota*/
System.out.println("Toyota Car isBig: "+toyota.isBig());
/*OUTPUT:
Toyota Car isBig true
*/
}
}
Static Method Interface
Sejak Java 8 Kita bisa membuat static method di interface.
Contoh demonstrasi static method interface:
public interface Animal {
/*static method interface*/
static void sleep() {
System.out.println("Zzzz");
}
}
public class Tiger implements Animal {
public void seyHello() {
System.out.println("Hello Tiger");
}
}
public class Main {
public static void main(String[] args) {
Animal tiger = new Tiger() /*membuat object tiger*/
tiger.seyHello() //OUTPUT: Hello Tiger
/*memanggil static method interface*/
Animal.sleep() //OUTPUT: Zzzz
}
}
Posting Komentar