Kelas Dalam Java Dijelaskan: Desain, Sintaks, dan Penggunaan Praktis
Dalam bab ini, kita akan membahas kelas dalam Java.
Kelas Bersarang
Di Java, sama seperti metode, variabel dari sebuah kelas juga dapat memiliki kelas lain sebagai anggotanya. Menulis kelas di dalam kelas lain diizinkan di Java. Kelas yang ditulis di dalam disebut kelas bersarang, dan kelas yang menahan kelas dalam disebut kelas luar.
Sintaks
Berikut adalah sintaks untuk menulis kelas bersarang. Di sini, kelas Outer_Demo adalah kelas luar dan kelas Inner_Demo adalah kelas bersarang.
class Outer_Demo { class Inner_Demo { } } Kelas bersarang dibagi menjadi dua tipe:
Kelas Dalam (Kelas Bersarang Non-statis)
Kelas dalam adalah mekanisme keamanan di Java. Kita tahu sebuah kelas tidak dapat dikaitkan dengan pengubah akses private, tetapi jika kita memiliki kelas sebagai anggota dari kelas lain, maka kelas dalam dapat dibuat private. Dan ini juga digunakan untuk mengakses anggota private dari sebuah kelas.
Kelas dalam ada tiga tipe tergantung pada bagaimana dan di mana Anda mendefinisikannya. Mereka adalah:
- Kelas Dalam
- Kelas Dalam Lokal Metode
- Kelas Dalam Anonim
Kelas Dalam
Membuat kelas dalam cukup sederhana. Anda hanya perlu menulis kelas di dalam kelas. Tidak seperti kelas, kelas dalam dapat bersifat private dan setelah Anda mendeklarasikan kelas dalam sebagai private, ia tidak dapat diakses dari objek di luar kelas.
Berikut adalah program untuk membuat kelas dalam dan mengaksesnya. Dalam contoh yang diberikan, kita membuat kelas dalam private dan mengakses kelas melalui suatu metode.
Contoh
Live Demo
class Outer_Demo { int num; // inner class private class Inner_Demo { public void print() { System.out.println("This is an inner class"); } } // Accessing he inner class from the method within void display_Inner() { Inner_Demo inner = new Inner_Demo(); inner.print(); } } public class My_class { public static void main(String args[]) { // Instantiating the outer class Outer_Demo outer = new Outer_Demo(); // Accessing the display_Inner() method. outer.display_Inner(); } } Di sini Anda dapat melihat bahwa Outer_Demo adalah kelas luar, Inner_Demo adalah kelas dalam, display_Inner() adalah metode di dalamnya tempat kita membuat instance kelas dalam, dan metode ini dipanggil dari metode main.
Jika Anda mengkompilasi dan menjalankan program di atas, Anda akan mendapatkan hasil berikut:
Keluaran
This is an inner class.
Mengakses Anggota Private
Seperti yang disebutkan sebelumnya, kelas dalam juga digunakan untuk mengakses anggota private dari sebuah kelas. Misalnya, sebuah kelas memiliki anggota private untuk mengaksesnya. Tulis kelas dalam di dalamnya, kembalikan anggota private dari suatu metode dalam kelas dalam, misalnya, getValue(), dan akhirnya dari kelas lain (yang ingin mengakses anggota private) panggil metode getValue() dari kelas dalam.
Untuk membuat instance kelas dalam, awalnya Anda harus membuat instance kelas luar. Kemudian, menggunakan objek kelas luar, berikut adalah cara Anda dapat membuat instance kelas dalam.
Outer_Demo outer = new Outer_Demo(); Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
Program berikut menunjukkan cara mengakses anggota private dari sebuah kelas menggunakan kelas dalam.
Contoh
Live Demo
class Outer_Demo { // private variable of the outer class private int num = 175; // inner class public class Inner_Demo { public int getNum() { System.out.println("This is the getnum method of the inner class"); return num; } } } public class My_class2 { public static void main(String args[]) { // Instantiating the outer class Outer_Demo outer = new Outer_Demo(); // Instantiating the inner class Outer_Demo.Inner_Demo inner = outer.new Inner_Demo(); System.out.println(inner.getNum()); } } Jika Anda mengkompilasi dan menjalankan program di atas, Anda akan mendapatkan hasil berikut:
Keluaran
This is the getnum method of the inner class: 175
Kelas Dalam Lokal Metode
Di Java, kita dapat menulis kelas di dalam suatu metode dan ini akan menjadi tipe lokal. Sama seperti variabel lokal, cakupan kelas dalam terbatas dalam metode tersebut.
Kelas dalam lokal metode hanya dapat diinstantiasi dalam metode tempat kelas dalam didefinisikan. Program berikut menunjukkan cara menggunakan kelas dalam lokal metode.
Contoh
Live Demo
public class Outerclass { // instance method of the outer class void my_Method() { int num = 23; // method-local inner class class MethodInner_Demo { public void print() { System.out.println("This is method inner class "+num); } } // end of inner class // Accessing the inner class MethodInner_Demo inner = new MethodInner_Demo(); inner.print(); } public static void main(String args[]) { Outerclass outer = new Outerclass(); outer.my_Method(); } } Jika Anda mengkompilasi dan menjalankan program di atas, Anda akan mendapatkan hasil berikut:
Keluaran
This is method inner class 23
Kelas Dalam Anonim
Sebuah kelas dalam yang dideklarasikan tanpa nama kelas dikenal sebagai kelas dalam anonim. Dalam kasus kelas dalam anonim, kita mendeklarasikan dan membuat instance mereka pada saat yang sama. Secara umum, mereka digunakan setiap kali Anda perlu mengganti metode dari sebuah kelas atau antarmuka. Sintaks kelas dalam anonim adalah sebagai berikut:
Sintaks
AnonymousInner an_inner = new AnonymousInner() { public void my_method() { ........ ........ } }; Program berikut menunjukkan cara mengganti metode dari sebuah kelas menggunakan kelas dalam anonim.
Contoh
Live Demo
abstract class AnonymousInner { public abstract void mymethod(); } public class Outer_class { public static void main(String args[]) { AnonymousInner inner = new AnonymousInner() { public void mymethod() { System.out.println("This is an example of anonymous inner class"); } }; inner.mymethod(); } } Jika Anda mengkompilasi dan menjalankan program di atas, Anda akan mendapatkan hasil berikut:
Keluaran
This is an example of anonymous inner class
Dengan cara yang sama, Anda dapat mengganti metode dari kelas konkret serta antarmuka menggunakan kelas dalam anonim.
Kelas Dalam Anonim sebagai Argumen
Secara umum, jika suatu metode menerima objek dari antarmuka, kelas abstrak, atau kelas konkret, maka kita dapat mengimplementasikan antarmuka, memperluas kelas abstrak, dan melewatkan objek ke metode. Jika itu adalah kelas, kita dapat langsung melewatkannya ke metode.
Namun dalam ketiga kasus tersebut, Anda dapat melewatkan kelas dalam anonim ke metode. Berikut adalah sintaks untuk melewatkan kelas dalam anonim sebagai argumen metode:
obj.my_Method(new My_Class() { public void Do() { ..... ..... } }); Program berikut menunjukkan cara melewatkan kelas dalam anonim sebagai argumen metode.
Contoh
Live Demo
// interface interface Message { String greet(); } public class My_class { // method which accepts the object of interface Message public void displayMessage(Message m) { System.out.println(m.greet() + ", This is an example of anonymous inner class as an argument"); } public static void main(String args[]) { // Instantiating the class My_class obj = new My_class(); // Passing an anonymous inner class as an argument obj.displayMessage(new Message() { public String greet() { return "Hello"; } }); } } Jika Anda mengkompilasi dan menjalankan program di atas, ia memberi Anda hasil berikut:
Keluaran
Hello, This is an example of anonymous inner class as an argument
Kelas Bersarang Statis
Sebuah kelas dalam statis adalah kelas bersarang yang merupakan anggota statis dari kelas luar. Ia dapat diakses tanpa membuat instance kelas luar, menggunakan anggota statis lain. Sama seperti anggota statis, kelas bersarang statis tidak memiliki akses ke variabel instance dan metode kelas luar. Sintaks kelas bersarang statis adalah sebagai berikut:
Sintaks
class MyOuter { static class Nested_Demo { } } Membuat instance kelas bersarang statis sedikit berbeda dari membuat instance kelas dalam. Program berikut menunjukkan cara menggunakan kelas bersarang statis.
Contoh
Live Demo
public class Outer { static class Nested_Demo { public void my_method() { System.out.println("This is my nested class"); } } public static void main(String args[]) { Outer.Nested_Demo nested = new Outer.Nested_Demo(); nested.my_method(); } } Jika Anda mengkompilasi dan menjalankan program di atas, Anda akan mendapatkan hasil berikut:
Keluaran
This is my nested class
