Struktur Class Lanjutan
Subtopik Struktur Class Lanjutan
For-each loop Varargs
Autoboxing dan Unboxing
Enum
Static
Inner class
“regular” inner class
Method-local inner class
Anonymous inner class
Advanced or Enhanced For Loop
For-each loop diperkenal di Java versi 5.
Umumnya digunakan untuk menjejaki (traverse)
array atau unsur dalam collection.
Kegunaan:
Membuat code lebih mudah dibaca
Mengeliminasi kemungkinan error
Syntax:
Contoh for-each loop
class ForEachExample1{
public static void main (String args[]){ int arr[]={12,13,14,44}; for(int i:arr){ System.out.println(i); } } } import java.util.*; class ForEachExample2{ public static void main
(String args[]){
ArrayList<String> list=new ArrayList <String>(); list.add(“ade"); list.add(“irma"); list.add(“sari"); for(String s:list){ System.out.println(s); } }
Variable Argument (varargs)
Varargs membolehkan method untuk argumen yang
belum diketahui jumlahnya.
Sebelum adanya varargs, biasanya kita
menggunakan overloaded method atau array
sebagai parameter. Namun hal ini mempersulit code maintenance.
Jika kita tidak tahu berapa parameter yang akan
diantar pada method, maka gunakan varargs.
Syntax varargs (… setelah tipe data):
Contoh penggunaan varargs
class VarargsExample1{
static void display(String... values){
System.out.println("display method invoked ");
}
public static void main(String
args[]){ display();//zero argument display("my","name","is","varargs"); //four arguments } class VarargsExample2{
static void display(String... values){
System.out.println("display method invoked "); for(String s:values){ System.out.println(s); } }
public static void main(String args[]){
display();//zero argument display("hello");//one argument display("my","name","is","varargs"); //four arguments } }
Aturan penggunaan varargs
Ada aturan sewaktu menggunakan varargs, jika
tidak diikuti maka code tidak berhasil dikompil
Hanya boleh ada satu varargs dalam method.
Varargs haruslah argumen yang paling akhir.
Contoh varargs yang salah:
void method(String... a, int... b){}//Compile time error void method(int... a, String b){}//Compile time error
Contoh varargs
class VarargsExample3{
static void display(int num, String... values){
System.out.println("number is "+num);
for(String s:values){
System.out.println(s); }
}
public static void main(String args[]){
display(500,"hello");//one argument
display(1000,"my","name","is","varargs");//four arguments }
Autoboxing dan Boxing
Boxing
Konversi otomatis dari tipe data primitif ke class
Wrappernya.
Unboxing
Konvers otomatis dari class Wrapper ke tipe data
primitifnya.
Keuntungan:
Contoh
Autoboxing Unboxing
class BoxingExample1{
public static void main(String
args[]){
int a=50;
Integer a2=new Integer(a); //Boxing
Integer a3=5;//Boxing
System.out.println(a2+" "+a3);
class UnboxingExample1{
public static void main(String
args[]){
Integer i=new Integer(50);
int a=i;
System.out.println(a); }
Contoh pada operator perbandingan
class UnboxingExample2{
public static void main(String args[]){
Integer i=new Integer(50);
if(i<100){ //unboxing internally
System.out.println(i); }
} }
Pada method overloading
Autoboxing dan unboxing juga dapat dilakukan pada
method overloading.
Namun ada aturan prioritas:
Widening beats boxing
Widening beats varargs
Contoh widening beats boxing
class Boxing1{
static void m(int i){System.out.println("int");}
static void m(Integer i){System.out.println("Integer");} public static void main(String args[]){
short s=30;
m(s); }
Contoh widening beats varargs
class Boxing2{
static void m(int i, int i2){System.out.println("int int");} static void m(Integer... i){System.out.println("Integer...");}
public static void main(String args[]){ short s1=30,s2=40;
m(s1,s2); }
Contoh boxing beats varargs
class Boxing3{
static void m(Integer i){System.out.println("Integer");}
static void m(Integer... i){System.out.println("Integer...");}
public static void main(String args[]){ int a=30;
m(a); }
Enum
Enum merupakan tipe data yang mengandung
kumpulan konstan yang tetap.
Enum juga dapat dianggap seperti class yang
memiliki beberapa nilai konstan yang tetap.
Contoh digunakan untuk hari dalam seminggu
(SENIN, SELASA, RABU, KAMIS, JUMAT, SABTU, MINGGU).
Contoh lainnya untuk arah mata angin (UTARA,
SELATAN, BARAT, TIMUR).
Enum adalah static dan final (secara implisit) Mulai diperkenalkan pada Java versi 5.
Point penting pada Enum
Enum memperbaiki type safety
Enum dapat digunakan pada switch Enum dapat dijejaki (traverse)
Enum dapat memiliki field, constructor dan method Enum tidak dapat extend class lain karena secara
bawaan Enum adalah subclass dari class Enum
Contoh sederhana
class EnumExample1{
public enum Season { WINTER, SPRING, SUMMER, FALL } public static void main(String[] args) {
for (Season s : Season.values())
System.out.println(s); }}
Method values() pada enum
Java compiler secara otomatis menambah method
values() ketika mencipta enum.
Method values() mengembalikan array yang
Enum di luar class
Enum juga bisa didefinisikan di luar class, karena enum
mirip dengan class
enum Season { WINTER, SPRING, SUMMER, FALL } class EnumExample2{
public static void main(String[] args) {
Season s=Season.WINTER; System.out.println(s);
Peraturan lainnya
Enum memiliki private constructor.
Dapatkan kita mencipta objek dari enum dengan keyword
new? Tidak, kenapa?
Enum boleh memiliki method abstract. Enum dapat dipakai pada switch-case
Contoh pada switch-case
class EnumExample5{
enum Day{ SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY} public static void main(String args[]){
Day day=Day.MONDAY; switch(day){ case SUNDAY: System.out.println("sunday"); break; case MONDAY: System.out.println("monday"); break; default: System.out.println("other day"); }
Static
Modifier static biasanya dipergunakan untuk
membuat method atau variable yang menyatakan milik dari kelas, bukan milik objek (sehingga
independen terhadap objek)
Yang dapat diberi modifier static:
Variable (atau class variable)
Method (atau class method)
Initialization block (static initializer)
Inner class dalam class lain (bukan dalam method)
Selain dari itu tidak bisa (constructor, class,
Java Static Variable
Bila variable diberi modifier static, maka variable
tersebut menjadi milik kelas.
Pengertian menjadi milik kelas adalah, kita dapat
mengakses atau menggunakannya tanpa proses instansiasi objek dari kelas tersebut (yang kita butuhkan hanya kelas tersebut dapat diakses).
Static variable akan disharing oleh semua objek
Java Static Variable
Static variable digunakan untuk atribut yang bernilai
sama untuk seluruh objek class tersebut
Nama perusahaan
Nama universitas
Static variable hanya menggunakan memori sekali
pada class saat class tersebut diloading.
Keuntungan:
Kondisi tidak pakai variabel statis
Andai ada class Student yang mewakili student di
Unsyiah. class Student{ int NIM; String name; String college=“Unsyiah"; }
NIM dan name jelas akan berbeda untuk setiap
objek Student. Namun semuanya adalah mahasiswa di Unsyiah.
Kalau kita buat college sebagai static maka memory
Contoh
class Student8{ int NIM;
String name;
static String college ="Unsyiah";
Student8(int r,String n){ NIM = r;
name = n; }
void display (){System.out.println(NIM+" "+name+" "+college);} public static void main(String args[]){
Student8 s1 = new Student8(111,"Karan"); Student8 s2 = new Student8(222,"Aryan"); s1.display();
Ilustrasi
Bandingkan
class Counter{
int count=0;//will get memory when
//instance is created Counter(){
count++;
System.out.println(count); }
public static void main(String args[]){
Counter c1=new Counter(); Counter c2=new Counter(); Counter c3=new Counter();
}
class Counter2{
static int count=0;//will get memory
//only once and retain its value Counter2(){
count++;
System.out.println(count); }
public static void main(String args[]){
Counter2 c1=new Counter2(); Counter2 c2=new Counter2(); Counter2 c3=new Counter2();
Java Static Method
Method static adalah method milik class. Method static dapat dipanggil tanpa perlu
menciptakan objek dari class tersebut.
Method static dapat mengakses data static dan
dapat merubah nilainya.
static method dan static variable ikut diwariskan
Contoh
class Student9{ int NIM;
String name;
static String college = “Unsyiah"; static void change(){
college = “USK"; }
Student9(int r, String n){ NIM = r;
name = n;
void display (){System.out.println(NIM+"
"+name+" "+college);}
public static void main(String args[]){
Student9.change();
Student9 s1 = new Student9 (111, "Karan");
Student9 s2 = new Student9 (222, "Aryan");
Student9 s3 = new Student9 (333, "Sonoo");
s1.display(); s2.display(); s3.display(); }
Batasan pada method static
Ada 2 batasan bagi method static:
Method static tidak dapat menggunakan variable
non-static atau memanggil method non-non-static secara langsung
Kata kunci this dan super tidak dapat digunakan pada
bagian yang static
Apakah boleh coding di bawah?
class A{
int a=40;//non static
public static void main(String args[]){
System.out.println(a); }
Kenapa method main pada Java static?
Andaikan method main non-static maka JVM perlu
mencipta objek terlebih dahulu baru memanggil method main() -> extra memory allocation
Java Static Block
Java static block juga disebut initialization block
(block initializer)
Digunakan untuk menginisialisasi unsur data yang
static.
Akan dieksekusi sebelum method main pada saat
loading class.
Sifatnya:
initializer block tidak memiliki nama.
initializer block tidak memiliki parameter.
Contoh
class A2{
static{System.out.println("static block is invoked");} public static void main(String args[]){
System.out.println("Hello main"); }
Dapatkah kita eksekusi program tanpa
method main()?
class A3{ static{
System.out.println("static block is invoked"); System.exit(0);
} }
Pada Java versi sebelum 7, hal ini tidak masalah Namun pada Java versi 7 ke atas, akan ada error
Static import
Static import diperkenalkan pada Java versi 5 Static import dapat dipergunakan bila kita ingin
mengakses member static dari kelas lain tanpa harus mengetik nama kelas.
Member static disini adalah :
static variable
static method
Penulisannya:
Contoh deklarasi
Contoh deklarasi yang mungkin dari static import:
Cara 1 : import static
namaPackage.namaKelas.namaMemberStatic;
Cara 2 : import static namaPackage.namaKelas.*;
Kita harus tetap menggunakan nama kelas untuk
memanggil suatu member static, bila nama dari member static tersebut ternyata dimiliki oleh lebih dari 1 kelas yang di-import static.
Inner class
Suatu class yang berada di dalam class yang lain. Ada 4 jenis inner class:
“Regular” Inner class
Method-local inner class
Anonymous inner class
“Regular” Inner class
Kata “Regular” di atas memiliki maksud bahwa inner
class yang dibahas di sini adalah inner class yang bukan static / method-local / anonymous.
Inner class didefinisikan (ditulis) di dalam kurung
Contoh
class MyOuter { class MyInner {
} }
MyInner adalah inner class.
Jika coding di atas dikompilasi maka akan ada 2 file
.class yaitu MyOuter.class dan MyOuter$MyInner.class
Sebuah inner class tidak dapat memiliki member static.
Objek dari inner class memiliki akses ke semua member
Objek inner class
Untuk membuat objek dari inner class, harus
membuat objek dari outer class terlebih dahulu.
Objek dari inner class dapat dibuat:
Dari dalam outer class
Dari luar outer class
class A { void buatInstanceKelasB() { B b = new B(); } class B { }
Objek di dalam dan luar outer class
class A { void buatInstanceKelasB() { B b = new B(); } class B { } } class A { class B { void sesuatuDiKelasB() { System.out.println("Hello, ini di method kelas B"); } }}public class Contoh {
public static void main(String[] args) {
A a = new A(); A.B b = a.new B();
b.sesuatuDiKelasB(); }
}
This pada inner class
Aturan inner class dalam hal mereferensi dirinya
sendiri atau instance dari outer class adalah sebagai berikut :
Untuk merujuk pada dirinya sendiri (instance dari inner
class) dari dalam inner class, dapat digunakan
referensi this atauNamaOuterClass.NamaInnerClass.this.
Untuk merujuk pada instance dari outer classnya dari
dalam inner class, dapat digunakan referensi NamaOuterClass.this.
Contoh
class A { int i = 10; class B { int i = 11; class C { int i = 12; void lakukanSesuatu() { System.out.println("A.this.i = " + A.this.i); System.out.println("A.B.this.i = " + A.B.this.i); System.out.println("A.B.C.this.i = " + A.B.C.this.i); System.out.println("this.i = " + this.i); } } } }public class BelajarInnerClass05 { public static void main(String[] args) {
A.B.C c = new A().new B().new C(); c.lakukanSesuatu();
} }
Method-local inner class
Method-local inner class adalah inner class yang dideklarasikan di dalam
method.
Mendeklarasikan method-local inner class tidak berarti kita membuat instance dari
class tersebut. Jadi, sebelum kita menggunakan inner class tersebut, kita harus membuat instancenya dari suatu tempat di dalam method dan setelah definisi inner class tersebut. class A { //1 void myMethod() { //2 class B { //3 int i = 10; void lakukanSesuatu() { //4 System.out.println(" i = " + i); } //4 } //3 B b = new B(); b.lakukanSesuatu();
Method-local inner class (2)
Method-local inner class hanya dapat diinstansiasi
dari dalam method yang mendefinisikan method-local inner class tersebut.
Instance method-local inner class memiliki akses ke
semua member dari outer class (termasuk member outer class yang ber access modifier private).
Instance dari method-local inner class tidak dapat
mengakses local variabel (termasuk parameter) dari method dimana method-local inner class tersebut didefinisikan. Kecuali bila variabel tersebut
Anonymous Inner Class
Suatu inner class yang dideklarasikan tanpa nama kelas. Anonymous inner class dapat berupa (tidak bisa secara
bersamaan):
Subclass dari suatu class yang telah dideklarasikan Kelas implementasi dari suatu interface
Tujuan :
mengoverride satu atau lebih method dari super classnya atau
mengimplement semua method dari suatu interface.
Anonymous inner class tidak dapat mengimplement lebih dari
sebuah interface.
Bagian dari suatu statement. Bentuk dari polymorphisme
Method yang dapat dipanggil dari anonymous inner class adalah
Anonymous inner class sebagai
subclass
class A { int i = 10; void lakukanSesuatu() { i--; System.out.println("i = " + i); } }public class BelajarAnonymous1 { //1 public static void main(String[] args) { //2
A a = new A() { //3 void lakukanSesuatu() { //4 i++; System.out.println("i = " + i); } //4 }; //3 a.lakukanSesuatu(); } //2 } //1
Anonymous inner class sebagai
implementasi dari interface
interface A {
public void doA(); }
interface B extends A { public void doB(); }
public class BelajarAnonymous2 { public static void main(String[] args) {
B b = new B() { public void doA() {
System.out.println("Ini method doA()"); }
public void doB() {
System.out.println("Ini method doB()"); }
};
b.doA(); b.doB();
Static nested class
Static nested class adalah inner class dengan
modifier static.
Static nested class sebenarnya bukan inner class,
static nested class hanyalah top-level class yang di sarangkan di dalam class lain.
Karena static, maka untuk membuat instance dari
static nested class tidak diperlukan instance dari outer classnya. (tidak seperti regular inner class ataupun method-local inner class).
Static nested class tidak dapat mengakses
Contoh
class A { static class B { void lakukanSesuatu() { System.out.println("Hallo"); } } }public class StaticNestedClass {
public static void main(String[] args) {
A.B b = new A.B(); //cara instansiasi static nested class
b.lakukanSesuatu(); }
