Fahmi Candra Permana

Class adalah sebuah spesifikasi objek, yang memiliki

atribut/properti dan layanan/fungsional (metode/fungsi). Class
diagram menggambarkan struktur dan deskripsi kelas, package
dan objek beserta hubungan satu sama lain, seperti hal pokok:
Nama (dan stereotype), Atribut, dan Metode.
▪ Inheritance/Pewarisan
▪ Enkapsulasi
▪ Polimorfisme
▪ Abstraksi
Pewarisan merupakan proses penciptaan kelas baru dengan
mewarisi karakteristik kelas yang sudah ada (biasa disebut kelas
induk), ditambah dengan karakteristik unik kelas baru tersebut
(biasa disebut turunan). Dalam java, kelas induk ini dinamakan
superclass dan kelas turunan dinamakan subclass.
▪ Hewan adalah superclass dari karnivora dan herbivora. Kelas turunan
karnivora dan herbivora ini memiliki data dan method yang dimiliki kelas
hewan.
▪ Dalam java, format penulisan untuk membuat subclass adalah:
class A {
int a=3;
public void setA(int nilai) {
a = nilai; class DemoKelasTurunan1 {
} public static void main(String[] args) {
public int getA() { // melakukan instansiasi terhadap kelas B
return a; B obj;
}
obj = new B();
} // mengeset nilai objek dari kelas B
// membuat kelas turunan (subclass) dari kelas A
class B extends A { System.out.println("Nilai a asli : " + obj.a);
int b; obj.setA(100);
public void setB(int nilai) { obj.setB(200);
b = nilai; // mendapatkan nilai yang terdapat dalam objek dari kelas B
} System.out.println("Nilai a : " + obj.getA());
public int getB() { System.out.println("Nilai b : " + obj.getB());
return b; }
} }
}
Penggunaan Kata Kunci Super Berfungsi untuk memanggil constructor dari
kelas induk. Selain itu kata kunci super juga dapat digunakan untuk
mengakses anggota kelas (data maupun method) dari kelas induk yang telah
tertimpa oleh anggota kelas dari kelas turunan.
Penulisan :
super(daftarParameter)
Class Kotak(int p, int l, int t) { Program di samping dapat dibuat seperti di
bawah :
panjang = p;
Class Kotak(int p, int l, int t) {
lebar = l;
panjang = p;
tinggi = t;
lebar = l;
}
tinggi = t;
class KotakPejal extends Kotak{
}
private double berat;
class KotakPejal extends Kotak{
KotakPejal(int p, int l, int t, int b) {
private double berat;
panjang = p;
KotakPejal(int p, int l, int t, int b) {
lebar = l;
// memanggil constructor kelas Kotak
tinggi = t;
super(p, l, t);
berat = b;
berat = b;
}
}
}
}
▪ Proses abstraksi diatas dilakukan dengan pembungkusan (encapsulation),
proses ini dinamakan information hiding
▪ Terdapat tiga tingkat akses yang terkait dengan enkapsulasi :
▪ Private
▪ Protected
▪ Public
Mendeklarasikan data dan method dengan private,
maka data dan method tsb hanya dapat diakses oleh
kelas yang memilikinya saja.
Mendeklarasikan data dan method dengan protected,
maka data dan method tsb dapat diakses oleh kelas
yang memilikinya dan kelas-kelas yang masih memiliki
hubungan turunan.
Data dan method yang bersifat public akan dapat
diakses oleh semua bagian dalam program. Semua
bagian dalam program adalah semua kelas yang
memiliki hubungan turunan maupun yang tidak
memiliki hubungan sama sekali.
 public void showData() {
class A {
// menggunakan method getA()
private int a;// hanya dikenali oleh kelas A
System.out.println("Nilai a : " + getA());
// hanya dapat dikenali oleh kelas A dan turunan-
turunannya System.out.println("Nilai b : " + b);}}

protected void setA(int nilai) { class C {

a = nilai; private int c;

} public void setC(int nilai) {

// hanya dapat dikenali oleh kelas A dan turunan- //setA(10); // SALAH, setA() tidak dikenal di sini
turunannya c = nilai;}
protected int getA() { public int getC() {
return a; return c;}
}} public void showC() {
class B extends A { //System.out.println("Nilai a : " + getA());// SALAH

private int b; System.out.println("Nilai c : " + c);}}

// constructor kelas B class DemoProtected1 {

B(int nilaiA, int nilaiB) { public static void main(String[] args) {

//a = nilaiA; // SALAH, karena a tidak dikenali di sini B obj = new B(40, 50); // melakukan instansiasi terhadap kelas B

setA(nilaiA); // menggunakan method setA() obj.showData();

b = nilaiB; } obj.setA(100);

System.out.println("Nilai a : " + obj.getA()); }}

▪ A memiliki turunan B Class A{
StatementA;
▪ B memiliki turunan C
}
▪ C memiliki turunan D
Class B extends A{
StatementB;
}
Class C extends B{
StatementC;
}
Class D extends C{
StatementD;
}
 class DemoConstructorPenurunan {
class A {
public static void main(String[] args) {
A() {
System.out.println("Pada saat membentuk objek dari kelas A:");
System.out.println("Constructor dari kelas A");
A obj1 = new A();
}
System.out.println("\nPada saat membentuk objek dari kelas B:");
}
B obj2 = new B();
class B extends A {
System.out.println("\nPada saat membentuk objek dari kelas C:");
B() {
C obj3 = new C();
System.out.println("Constructor dari kelas B");
}
}
}
}
class C extends B {
C() {
System.out.println("Constructor dari kelas C");
}
}
▪ Yaitumethod pada kelas turunan yang nama
metodenya dan daftar parameternya sama persis
dengan metode yang ada pada kelas induknya
▪ Method pada kelas induknya akan disembunyikan
keberadaannya
class A { class B extends A {
private int b;
private int a;
public void setB(int nilai) {
public void setA(int nilai) { b = nilai;
a = nilai; }
public int getB() {
}
return b;
public int getA() {
}
return a; // melakukan override terhadap method tampilkanNilai() yang terdapat pada kelas A

public void tampilkanNilai() {

}
System.out.println("Nilai b: " + getB());
public void tampilkanNilai() {
}
System.out.println("Nilai a: " + getA()); }
} class DemoOverride1 {
public static void main(String[] args) {
}
B obj = new B();
obj.setA(100);
obj.setB(200);
//akan memanggil method yang terdapat pada kelas B
obj.tampilkanNilai();
}
}
▪ Dalam satu kelas dapat didefinisikan lebih dari satu method dengan nama
yang sama, selama parameter pada method tersebut berbeda.
▪ Parameter pada method yang berbeda dianggap berbeda jika :
▪ Jumlahnya berbeda meskipun tipe datanya sama
▪ Tipe datanya berbeda, meskipun jumlahnya sama
▪ Jumlah dan tipe data berbeda

▪ Proses pendefinisian method dengan nama sama ini disebut dengan overload
int bagi(int a,int b){
return a/b;
}
double bagi(double a,double b){
return a/b;
}
Kode diatas legal
int bagi(int a,int b){
return a/b;
}
double bagi(int a,int b){
return a/b;
}
Kode diatas salah
class Pembagian {
// Mendefinisikan method dengan dua parameter bertipe int
int bagi(int a, int b) {
return a/b;
}
// Mendefinisikan method dengan dua parameter bertipe double
double bagi(double a, double b) {
return a/b;
}
}
class DemoOverload1 {
public static void main(String[] args) {
int x;
double y;
Pembagian b = new Pembagian();
x = b.bagi(10, 4);
y = b.bagi(10.0, 4.0);
System.out.println("Hasil bagi tipe int = " + x);
System.out.println("Hasil bagi tipe double = " + y);
}
}
class myclass {
// Mendefinisikan method dengan parameter int dan String
void tulis(int a, String s) {
System.out.println("int: " + a + ", String: \"" + s + "\"");
}
// Mendefinisikan method dengan parameter String dan int
void tulis(String s, int a) {
System.out.println("int: " + a + ", String: \"" + s + "\"");
}
}

class DemoOverload3 {
public static void main(String[] args) {
myclass c = new myclass();
c.tulis(4, "Contoh method pertama");
c.tulis("Contoh method kedua", 8);
}
}
▪ Override
▪ Nama method pada suatu kelas sama dengan nama method
pada kelas induknya dengan jumlah/daftar/tipe parameter
yang sama persis
▪ Overload
▪ Nama method pada suatu kelas sama dengan nama method
pada kelas tersebut dengan jumlah/daftar/tipe parameter
yang berbeda
▪ Nama method pada suatu kelas sama dengan nama method
pada kelas turunannya dengan jumlah/daftar/tipe parameter
yang berbeda