PI2133

Pemrograman Berorientasi Objek

Chapter 4
Implementasi konsep Encapsulasi
dan Modularitas dalam bahasa
pemrograman
Model Konseptual dalam PBO
• Object Model terdiri dari 4 element utama (major):
▫ Abstraksi
▫ Enkapsulasi
 Message Passing
▫ Modularity
 Package
 Reusability
▫ Hierarchy
 Inheritance,
 Generalisasi/Specialisasi
 Polymorphisme
Enkapsulasi & Message Passing
• Menurut Grady Booch
▫ “Encapsulation is the process of hiding all of the details of an object
that do not contribute to its essential characteristics.”
• Enkapsulasi atau pembungkusan atau penyembunyian informasi
(data hiding) berarti
▫ meninggalkan aspek eksternal dari object yang dapat diakses oleh
object lain dan memfokus diri pada implementasi internal suatu
object.
Enkapsulasi
Modularity
Encapsulasi dan Modularity
• Dalam java Encapsulasi diterapkan dengan
menggunakan access-specifier (private,
protected, public)
• Modularity dapat diterapkan dengan
menggunakan keyword package => hasil dari
kompilasi harus ditempatkan dalam folder yang
sesuai dengan nama package
Modularity
• Sample Code
Encapsulasi
• Makna dari access-specifier dapat diresumekan
dalam
Modifier
tabel dibawah
Kelas yang
sama
ini
Kelas Turunan Object dlm
Package yg
Object yg
berbeda
sama package
Private V X X X

Protected V V V X

Public V V V V
Pendefinisian Kelas - JAVA
• Secara umum seluruh attribute pada kelas akan
memiliki access modifier private (menjamin
information hiding)
• Konsekuensi
▫ Disediakan method untuk mengakses
 Mutator/Setter
 Accessor/Getter
Declaring Java Classes
Class_name
Basic syntax of Java class :
<class_declaration> ::= - attribute_declaration
<modifier> class <class_name> { + constructor_declaration
<attribute_declaration>* + method_declaration
<constructor_declaration>*
<method_declaration>*
}

Example :
1. public class Student {
2. private String name; Student
3. public void setName(String s) {
- name : string
4. name = s;
5. } + setName(s:string)
6. }
Declaring Attributes
Basic syntax of Java class :
<attribute_declaration> ::=
<modifier> <type>* <name> [=<default_value>];
<type> ::= byte | short | int | long | char | float |
double | boolean | <class_name>

Example :
1. public class Foo {
2. private int x;
3. public float y = 10000.0;
4. public String name = "Alfred";
5. }
Declaring Methods
Basic syntax of Java class :
<method_declaration> ::=
<modifier> <return_type> <name> (<parameter>*) {
<statement>
}

<parameter> ::= <parameter_type> <parameter_name>

Example :
1. public class Dog {
2. private int weight;
3. public int getWeight() {
4. return weight;
5. }
6. public void setWeight(int newWeight) {
7. weight = newWeight;
8. }
9. }
Information Hiding

• The Problem :
MyDate d = new MyDate();
d.day = 32;
MyDate
//invalid day +day : int
d.month = 2; d.day = 30; +month : int
//plausible but wrong +year : int
d.day = d.day + 1;
//no check for wrap around
 14

Information Hiding

The Solution
1. public class MyDate { MyDate
2. private int day;
3. private int month; -day : int
4. private int year;
-month : int
5. public int getDay() { -year : int
6. return day;
7. } +getDay() : int
8. public int getMonth() {
9. return month; +getMonth() : int
10.
11.
}
public int getYear() {
+getYear() : int
12. return year; +setDay(in d : int)
13. }
14. public void setDay(int d) { +setMonth(in m : int)
15. day = d; +setYear(in y : int)
16. }
17. public void setMonth(int m) {
18. month = m;
19. }
20. public void setDay(int y) {
21. year = y;
22. }
23.}
Declaring Constructors
Basic syntax of a constructor :
<constructor_declaration> ::=
<modifier> <class_name> (<parameter>*) {
<statement>
}

<parameter> ::= <parameter_type> <parameter_name>

Example :
1. public class Thing {
2. private int x;
3. public Thing() {
4. x = 47;
5. }
6. public Thing(int new_x) { // overloaded constructor
7. x = new_x;
8. }
9. }
Declaring Constructors
1. public class Thing {
2. private int x;
3. public Thing() {
4. x = 47;
5. }
6. public Thing(int new_x) { // overloaded constructor
7. x = new_x;
8. }
9. public int getX() { // a 'getter'
10. return x;
11. }
12. public void setX(int new_x) { // a 'setter'
13. x = new_x;
14. }
15. }
Declaring Constructors
Example usage :
1. public class TestThing {
2. public static void main(String[] args) {
3. Thing thing1 = new Thing();
4. Thing thing2 = new Thing(42);

5. System.out.println("thing1.x is " + thing1.getX());

6. System.out.println("thing2.x is " + thing2.getX());
7. }
8. }

Output :
thing1.x is 47
thing2.x is 42
Encapsulasi
• Sample Code
▫ Tambahkan kode untuk menunjukkan perbedaan
makna pemakaian access-specifier
Studi Kasus 1
• Pengolahan bangun geometri
▫ Segitiga
▫ Lingkaran
▫ Persegi Panjang
• Note: Tidak ada hubungan khusus antar kelas,
setiap kelas dibuat pada file .java
• Pembuatan kelas driver untuk eksekusi program
Diagram kelas

Driver

Segitiga Lingkaran PersegiPanjang

Definisi Kelas Segitiga
public class Segitiga{ //2. Definisi method HitungLuas
//Definisi atribute public double HitungLuas(){
private float alas; return (this.alas * this.tinggi)/2;
}
private float tinggi;
}
//Definisi method
//1. Definisi setter dan getter
public void setAlas(int alas) {
Note: simpan dengan nama Segitiga.java
this.alas=alas;
Ingat bahwa file ini hanya
}
mendefinisikan struktur kelas
public float getAlas(){
tidak untuk dijalankan (execute)
return this.alas;
}
public void setTinggi(int tinggi) {
this.tinggi=tinggi;
}
public float getTinggi(){
return this.tinggi; Sesuai dengan
} nama kelas
Pembuatan Kelas Driver
• Kelas driver yang dibuat hanya akan digunakan untuk menguji apakah
fungsionalitas dari kelas yang dibuat telah sesuai

public class Driver{ Deklarasi main

public static void main(String args[]){ harus seperti ini
Segitiga obj=new Segitiga(); // membuat object agar
obj.setAlas(10); // mengatur atribute alas dengan setter
obj.setTinggi(5); // mengatur atribute tinggi dengan setter
//mengambil nilai atribute alas dengan getter
System.out.println("Alas:"+obj.getAlas());
//mengambil nilai atribute tinggi dengan getter
System.out.println("Tinggi:"+obj.getTinggi());
//menghitung luas dengan method HitungLuas
System.out.println("Luasnya adalah:"+obj.HitungLuas());
}
}
Kompilasi File
• File yang dihasilkan
▫ Segitiga.java
▫ Driver.java
• Kompilasi file
▫ Dari command window:
javac Segitiga.java
javac Driver.java
atau
javac *.java
Eksekusi File
• Setelah melakukan kompilasi maka kita dapat
mengeksekusi file .class
• Dalam hal ini yang dapat dieksekusi adalah kelas
yang memiliki method main yaitu Driver.class
• Perintah Eksekusi
java Driver
Hasil Eksekusi
Analisa Solusi
• Tidak ada interaksi antara pengguna dan
program √??
• Bagaimana bila kita ingin agar alas dan tinggi
diinputkan oleh user??
Membaca Inputan Keyboard
• Kita bisa memanfaatkan kelas Scanner yang
telah disediakan oleh java pada package java.util
Contoh membaca dari keyboard
import java.util.Scanner; // program uses class Scanner
public class KeyInput{
// main method begins execution of Java application
public static void main( String args[] ) {
// create Scanner to obtain input from command window
Scanner input = new Scanner( System.in );
int number1; // first number to add
int number2; // second number to add
int sum; // sum of number1 and number2
System.out.print( "Enter first integer: " );
number1 = input.nextInt(); // read first number from user
System.out.print( "Enter second integer: " ); // prompt
number2 = input.nextInt(); // read second number from user
sum = number1 + number2; // add numbers
System.out.printf( "Sum is %d\n", sum ); // display sum
} // end method main
} // end class Addition
Hasil Eksekusi
Resume [1]
• Setiap definisi kelas disimpan pada file dengan
aturan <nama_kelas>.java
• Untuk menguji kebenaran kode yang telah
dibuat kita gunakan sebuah kelas baru =>
Driver harus memiliki method
public static void main(String args[])
Resume [2]
• Cara kerja JAVA
Any Question
Tugas
• Lanjutkan kode untuk
▫ Persegi Panjang
▫ Lingkaran
▫ Segitiga
• Tambahkan mekanisme menghitung keliling
• Buatlah kode yang menggambarkan:
▫ Acces-modifier
▫ Static
▫ Polymorphism: overload dan overrid
Inheritance • Bentuk

• Segitiga • Lingkaran • PersegiPanja