Modul Pemrograman (Draft)

Draft
DASAR-DASAR PEMROGRAMAN
Penyusunan Bahan Ajar Kurikulum Berbasis Kompetensi (Kurikulum 2007)
Pengajar:
Teguh sasono
PROGRAM STUDI TEKNIK KONVERSI ENERGI

JURUSAN TEKNIK KONVERSI ENERGI
POLITEKNIK NEGERI BANDUNG
2010
HALAMAN PENGESAHAN
1. Identitas Bahan Ajar
a. Judul Bahan Ajar : Teknik Pengukuran
b. Mata Kuliah/Semester : Teknik Pengukuran/1
c. SKS (T-P)/Jam (T-P) : (0 2)/(0 4)
d. Jurusan : Teknik Konversi Energi
e. Program Studi : Teknik Konversi Energi
f. Kode Mata Kuliah : KKEN 1012
2. Penulis Pertama
a. Nama : Ir Teguh Sasono, MT
b. NIP : 19640607 199512 1 001
c. Pangkat/Golongan : Penata Muda/IIIa
d. Jabatan Fungsional : Asisten Ahli
e. Program Studi : Teknik Konversi Energi
f. Jurusan : Teknik Konversi Energi
Bandung, 27 Agustus 2010
Mengetahui, Penulis,
Ketua KBK
Sri Paryanto Mursid, MSc. Ir Teguh sasono, MT

NIP:19630707 199103 1 001 NIP: 19640607 199512 1 001
Menyetujui,
Ketua Program Studi
Sri Wuryanti, MSc.

NIP. 19650326 199103 1 001
KATA PENGANTAR
Puji dan syukur kami panjatkan kepada Allah yang maha mempunyai ilmu, atas
terselesaikannya bahan ajar kuliah Dasar-Dasar Pemrograman ini, seperti yang telah
direncanakan. Buku ini merujuk, mengutip dan disarikan dari referensi yang daftarnya ada
pada bagian akhir buku ajar ini.
Pada dasarnya, bahan ajar ini berisi tentang algoritma dan pemrograman. Diharapkan siswa
mampu memecahkan persoalan secara terstruktur dengan notasi algoritma dan
mentranslasikannya kedalam bahasa pemrograman.
Kritik, saran dan koreksi sangat diharapkan untuk perbaikan bahan ajar ini
Terima kasih
Dasar-Dasar Pemrograman-TE Polban Hlmn. iii

RENCANA PEMBELAJARAN
A. TUJUAN ISI BUKU
Mahasiswa dapat menuangkan solusi permasalahan dalam algoritma, memahami notasi
algoritmik dan mentranlasikannya ke dalam bahasa pemrograman.
B. TUJUAN INSTRUKSIONAL UMUM

Mahasiswa diharapkan mampu untuk :
1. Memecahkan masalah dengan paradigma prosedural dan menuliskan spesifikasi dan
algoritmanya tanpa tergantung pada bahasa pemrograman apapun.
2. Memecahkan masalah sederhana dengan paradigma pemrograman berorientasi objek
dengan langsung menerapkannya ke bahasa pemrograman yang dipilih
3. Menulis algoritma dari suatu masalah dengan menggunakan metodologi dan skema
standard yang diajarkan secara terstruktur.
Menulis teks program yang "baik" sesuai dengan bahasa pemrograman yang diajarkan,
dengan sedapat mungkin dapat menggunakan aturan translasi yang diberikan.
C. SILABUS SINGKAT
Tujuan utama dari matakuliah ini adalah membekali mahasiswa cara berpikir dan
pemecahan persoalan dalam paradigma pemrograman prosedural, serta membekali
mahasiswa dengan modul dasar dari algoritma yang sering dipakai dalam pemrograman.
Mahasiswa harus mampu membuat penyelesaian masalah pemrograman tanpa tergantung
pada bahasa pemrograman apapun, dan kemudian ia mampu untuk mengeksekusi
programnya dengan salah satu bahasa pemrograman prosedural yang sederhana. Mahasiswa
akan memakai bahasa pemrograman tersebut sebagai alat untuk mengeksekusi program
dengan mesin yang tersedia.
D. RENCANA KEGIATAN
Kuliah ini adalah merupakan kuliah pratek dengan dibagi dalam tiga sesi perkuliahan yakni
1. Pertama didahului dengan response praktikum yang berisi dasar algoritma. Serta
penjelasan praktis tentang pemahaman notasi algoritma tahap per tahap.
2. Kedua adalah melakukan tranlasi notasi algoritmik kedalam bahasa pemrograman yang
dipilih.
3. Ketiga adalah melakukan praktikum dengan menggunakan perangkat lunak aplikasi
Delphi untuk menuliskan teks program ke komputer.
Dasar-Dasar Pemrograman-TE Polban Hlmn. iv

DAFTAR ISI
Halaman Pengesahan ......................................................................................................................... 2
Kata Pengantar ................................................................................................................................... iii
Rencana Pembelajaran ...................................................................................................................... iv
Daftar Isi .............................................................................................................................................. v
Daftar Tabel........................................................................................................................................ ix
Daftar Gambar .................................................................................................................................... x
1 Notasi Algoritmik........................................................................................................................ 1
1.1 Nama (Identifier) ................................................................................................................ 2
1.2 Judul (Header) .................................................................................................................... 2
1.3 Kamus ................................................................................................................................. 2
1.4 Algoritma ............................................................................................................................ 4
2 Type ............................................................................................................................................ 5
2.1 Type Dasar.......................................................................................................................... 5
2.1.1 Boolean/ Bilangan Logika ........................................................................................... 5
2.1.2 Integer / Bilangan Bulat ............................................................................................. 6
2.1.3 Real/ Bilangan Riil....................................................................................................... 7
2.1.4 Character .................................................................................................................... 8
2.1.5 string .......................................................................................................................... 8
2.1.6 Enumerasi................................................................................................................... 9
2.2 Type Bentukan ................................................................................................................... 9
2.2.1 Type Dasar yang Diberi Nama Baru.......................................................................... 10
2.2.2 Type Dasar Struktur.................................................................................................. 10
2.3 Nilai, Ekspresi, Input, dan Output .................................................................................... 11
2.3.1 Nilai (harga) .............................................................................................................. 11
2.3.2 Assignment ............................................................................................................... 12
3 Aksi Sekuensial ......................................................................................................................... 13
4 Analisis kasus............................................................................................................................ 15
5 Fungsi ....................................................................................................................................... 17
5.1 Notasi Algoritmik untuk Fungsi ........................................................................................ 18
5.1.1 Pendefinisian/Spesifikasi Fungsi .............................................................................. 18
Dasar-Dasar Pemrograman-TE Polban Hlmn. v
5.1.2 Pemanggilan Fungsi.................................................................................................. 18
6 Prosedur ................................................................................................................................... 20
6.1 Parameter Prosedur ......................................................................................................... 20
6.2 Notasi Algoritmik untuk Prosedur.................................................................................... 21
6.2.1 Pendefinisian/Spesifikasi Prosedur .......................................................................... 21
6.2.2 Pemanggilan Prosedur ............................................................................................. 21
7 Pengulangan ............................................................................................................................. 23
7.1 Pengulangan Berdasarkan Banyaknya Pengulangan ....................................................... 23
7.2 Pengulangan Berdasarkan Kondisi Berhenti .................................................................... 23
7.3 Pengulangan Berdasarkan Kondisi Ulang ......................................................................... 24
7.4 Pengulangan Berdasarkan Dua Aksi ................................................................................. 24
7.5 Pengulangan Berdasarkan Pencacah ............................................................................... 25
8 Pengenalan Lingkungan Pemrograman Delphi ........................................................................ 26
8.1 Tujuan............................................................................................................................... 26
8.2 Selintas Tentang Delphi.................................................................................................... 26
8.3 Alat Bantu (Help) .............................................................................................................. 26
8.4 IDE .................................................................................................................................... 27
8.4.1 Menu dan Toolbar .................................................................................................... 27
8.4.2 Palet komponen, Form Designer, Object Inspector dan Object TreeView .............. 28
8.4.3 The Object Repository .............................................................................................. 29
8.4.4 Code Editor............................................................................................................... 30
8.4.5 Menjelajah Teks Program ........................................................................................ 31
8.4.6 Halaman Diagram ..................................................................................................... 32
8.4.7 Tampilan Teks Program Formulir ............................................................................. 33
8.4.8 Code Explorer ........................................................................................................... 33
8.4.9 Manajer Projek dan Browser ................................................................................... 34
9 Cara Memrogram dengan Delphi............................................................................................. 35
9.1 Tujuan............................................................................................................................... 35
9.2 Menciptakan projek ......................................................................................................... 35
9.2.1 Adding data modules ............................................................................................... 35
9.3 Membangun Antar Muka Aplikasi ................................................................................... 35
9.3.1 Menempatkan Komponen di dalam Formulir.......................................................... 35
9.3.2 Pengesetan Properti Komponen .............................................................................. 36
9.4 Penulisan Teks Program ................................................................................................... 37
Dasar-Dasar Pemrograman-TE Polban Hlmn. vi
9.4.1 Penulisan Event Handlers......................................................................................... 37
9.4.2 Using the component library ................................................................................... 38
9.5 Kompilasi dan pendebugan Projek................................................................................... 38
10 Data Type, Variabel, dan Konstanta Delphi ......................................................................... 40
10.1 Type Sederhana................................................................................................................ 41
10.1.1 Type Ordinal ............................................................................................................. 41
10.1.1.1 Type Integer ..................................................................................................... 41
10.1.2 Type Real .................................................................................................................. 42
11 Menulis Program Hello......................................................................................................... 43
11.1 Langkah demi Langkah Program Hello -1......................................................................... 43
12 20 Kaidah untuk OOP di Delphi ......................................................................................... 45
12.1 Bagian 1: Formulir Adalah Kelas....................................................................................... 45
12.1.1 Aturan 1: Satu Kelas, Satu Unit ................................................................................ 46
12.1.2 Aturan 2: Komponen Nama ..................................................................................... 46
12.1.3 Peraturan 3: Nama Acara ......................................................................................... 46
12.1.4 Aturan 4: Gunakan Metode Formulir ....................................................................... 47
12.1.5 Aturan 5: Tambahkan Konstruktor Formulir ............................................................ 47
12.1.6 Aturan 6: Hindari Global Variabel ............................................................................ 47
12.1.7 Aturan 7: Jangan Gunakan Form1 Dalam TForm1 ................................................... 48
12.1.8 Aturan 8: Jarang Gunakan Form1 Dalam Formulir Lain ........................................... 48
12.1.9 Peraturan 9: Hapus Form1 ....................................................................................... 48
12.1.10 Peraturan 10: Tambahkan Properties Formulir ................................................... 49
12.1.11 Peraturan 11: Paparkan Properties Komponen ................................................... 49
12.1.12 Peraturan 12: Properties Array ............................................................................ 50
12.1.13 Peraturan 13: Gunakan Side-Effects Dalam Properties ....................................... 50
12.1.14 Peraturan 14: Sembunyikan Komponen .............................................................. 50
12.1.15 Peraturan 15: Formulir OOP Wizard .................................................................... 52
12.2 Bagian 2: Warisan............................................................................................................. 52
12.2.1 Peraturan 16: Formulir Visual Warisan .................................................................... 52
12.2.2 Peraturan 17: Batas Dilindungi Data ........................................................................ 53
12.2.3 Peraturan 18: Metode akses yang dilindungi .......................................................... 53
12.2.4 Peraturan 19: Protected Virtual Method ................................................................. 53
12.2.5 Peraturan 20: Virtual Metode Untuk Properties ..................................................... 54
12.3 Teks Program (Code) ........................................................................................................ 54
Dasar-Dasar Pemrograman-TE Polban Hlmn. vii
12.4 Kesimpulan ....................................................................................................................... 55
Daftar Referensi ............................................................................................................................... 56
Dasar-Dasar Pemrograman-TE Polban Hlmn. viii

DAFTAR TABEL
Tabel 2.1 Tabel kebenaran operator logika ....................................................................................... 6
Tabel 2.2 Operator integer................................................................................................................. 6
Tabel 2.3 Operator integer................................................................................................................. 7
Tabel 2.4 Operator character ............................................................................................................. 8
Tabel 2.5 Operator string ................................................................................................................... 9
Tabel 11.1 Cara kerja kelengkapan editor teks program ................................................................. 30
Dasar-Dasar Pemrograman-TE Polban Hlmn. ix

DAFTAR GAMBAR
Gambar 11.1 Alat bantu yang sensitif terhadap konteks ................................................................ 26
Gambar 11.2 Alat bantu pada konteks menu .................................................................................. 27
Gambar 11.3 Lingkungan pengembangan yang terintegrasi ........................................................... 27
Gambar 11.4 Jendela utama, pada susunan default ....................................................................... 28
Gambar 11.5 Fungsi Toolbar dalam jendela utama ......................................................................... 28
Gambar 11.6 Palet komponen ......................................................................................................... 28
Gambar 11.7 Objek inspector dan komponen ................................................................................. 29
Gambar 11.8 Objek TreeView, Objek Inspector, dan Form Designer .............................................. 29
Gambar 11.9 Object Repository ....................................................................................................... 30
Gambar 11.10 Kotak dialog untuk pengesetan Object Repository .................................................. 30
Gambar 11.11 Editor teks program ................................................................................................. 30
Gambar 11.12 Contoh dan pilihan dalam alat bantu code completion........................................... 31
Gambar 11.13 Menjelajah teks program dalam editor ................................................................... 32
Gambar 11.14 Penggunaan halaman Diagram ................................................................................ 33
Gambar 11.15 Penggunaan View As Text untuk menampilkan keterangan teks formulir ke editor33
Gambar 11.16 Cara kerja Code Explorer .......................................................................................... 34
Gambar 11.17 Dialog manajer projek .............................................................................................. 34
Gambar 11.18 Dialog Project Browser ............................................................................................. 34
Gambar 12.1 Contoh Data Module yang berisi komponen nonvisual ............................................. 35
Gambar 12.2 Cara menempatkan komponen di atas formulir ........................................................ 36
Gambar 12.3 Referensi komponen dalam objek Inspektor ............................................................. 37
Gambar 12.4 Hirarki klas dalam Delphi............................................................................................ 38
Gambar 12.5 Akses ke perintah debug program ............................................................................. 39
Gambar 12.6 Penggabungan debugging dapat dilakukan dengan mudah ...................................... 39
Gambar 14.1 Menambahkan konstuktor formulir........................................................................... 47
Gambar 14.2 Dapat ditambahkan satu properti ke formulir untuk menyatakan properti/sifat
komponen ........................................................................................................................................ 49
Gambar 14.3 Definisi satu array property yang default di dalam formulir...................................... 50
Gambar 14.4 Teks program VCL biasa untuk menyangkutkan suatu komponen kepada acuannya di
dalam fromulir pemilik ..................................................................................................................... 51
Gambar 14.5 Fromulir dengan properties yang diimplementasikan dengan virtual methods ....... 54
Dasar-Dasar Pemrograman-TE Polban Hlmn. x

1 NOTASI ALGORITMIK
Untuk menuliskan teks algoritma yang standar akan digunakan sebuah notasi. Notasi yang
dipilih akan disesuaikan dengan kedekatan bahasa pemrograman yang dipilih untuk
memudahkan proses translasi dari notasi algoritmik ke program. Notasi yang digunakan
sebagian besar diadaptasi dari buku “Diktat Kuliah Dasar Pemrograman [Inggriani Liem]”.
Suatu algoritma berisi urutan langkah-langkah logic yang detail untuk menyelesaikan
masalah yang dituliskan dalam notasi algoritmik, sedangkan program merupakan teks
program computer yang dituliskan dalam suatu bahasa pemrograman yang tersedia.
Program ini memiliki mesin pemroses sehingga dapat dieksekusi mesin, sedangkan notasi
yang akan digunakan dalam perkuliahan ini tidak memiliki mesin pengeksekusi. Notasi ini
diperlukan untuk menjembatani keragaman dan kompleksitas bahasa pemrograman dan
menyederhanakan penulisannya, sehingga siswa mampu melakukan proses abstraksi suatu
permasalahan dan memodelkannya dari suatu yang abstrak hingga sampai ke solusi yang
logic. Notasi lebih menekankan pada detail kerangka urutan logic solusi suatu permasalahan
dibandingkan proses coding ke suatu bahasa pemrograman.
Teks algoritma selalu terdiri dari tiga bagian, yaitu :
 Judul (Header)
 Kamus
 Algoritma
Pada setiap bagian tersebut, akan didefinisikan dan dipakai nama, atau dituliskan komentar
dalam bahasa Indonesia. Komentar dalam bahasa Indonesia dituliskan di antara tanda
kurung kurawal. Teks yang tidak dituliskan di antara kurung kurawal buka dan tutup adalah
teks dalam notasi algoritmik.
Contoh teks algoritmik:
JUDUL
{Ini adalah teks dalam bahasa Indonesia untuk memudahkan pembacaan teks
algoritma}
{Spesifikasi teks algoritmik secara umum}
KAMUS
{Pada bagian ini, dilakukan pendefinisian nama konstanta, nama variabel,

spesifikasi prosedur, spesifikasi fungsi}
ALGORITMA
{Pada bagian ini, semua teks yang tidak dituliskan di antara tanda kurung kurawal
buka dan kurung kurawal tutup harus dianggap sebagai notasi algoritmik}
Dasar-Dasar Pemrograman-TE Polban Hlmn. 1

1.1 Nama (Identifier)
Nama digunakan untuk mengidetifikasi modul program/unit, tipe, konstanta, variabel, fungsi,
prosedur, properti, kamus, atau paket. Dengan nama ini dapat dibedakan satu identitas
dengan identitas lainnya, sehingga dalam suatu program nama harus unik. Demikian juga,
dalam suatu teks algoritma, nama yang digunakan harus sudah didefinisikan sebelumnya dan
cukup didefinisikan sekali saja.
Tata cara penulisan nama sedapat mungkin dibakukan agar proses pembacaan, interpretasi,
dan representasi namanya mudah dipahami. Pemilihan nama harus interpretatif, tidak
menimbulkan kerancuan dan jika singkat harus disertai dengan penjelasannya. Pembakuan
ini sering diperlukan manakala proses translasi dari notasi algoritmik ke bahasa
pemrograman dilakukan, sehingga dalam buku ini agak disesuaikan dengan bahasa
pemrograman yang dipilih. Dalam bahasa pemrograman, setiap nama mempunyai aturan
penulisan (sintaks) tertentu, misalnya yang menyangkut karakter yang diperbolehkan,
jumlah maksimum karakter, sifat sensitive jenis hurufnya, dsb. Selain pemilihan nama harus
interpretative, pada teks algoritma di sini digunakan aturan sebagai berikut:
 Karakter yang digunakan merupakan rangkaian huruf ([a..z, A..Z]), angka ([0..9]), _
(underscored)
 Penulisan nama dimulai dengan huruf besar dan diikuti dengan huruf kecil dan/atau
alphanumeric dan atau _ (underscored); jika terdiri dari dua kata atau lebih, kata
berikutnya diawali dengan huruf besar; Jika suatu nama disingkat, maka huruf pertama
adalah capital.
 Penulisan nama tidak membedakan huruf kapital dan kecil.
Pembakuan ini diperlukan agar siswa terbiasa dengan penulisan nama dalam bahasa
pemrograman yang akan digunakan, terbiasa dengan aturan yang case sensitive atau
membedakan huruf besar dan huruf kecil dalam penamaan disamping melatih konsistensi
penulisannya.
1.2 Judul (Header)

Judul adalah bagian teks algoritma tempat mendefinisikan apakah teks tersebut adalah
program, prosedur, fungsi, modul atau sebuah skema program. Setelah judul disarankan
untuk menuliskan spesifikasi singkat dari teks algoritma tersebut. Pada bagian judul dan
spesifikasi, pembaca dapat mengetahui isi dari teks tanpa membaca secara detil Bagian judul
berisi judul teks algoritmik secara keseluruhan dan intisari sebuah teks algoritmik tersebut.
Bagian judul ini identik dengan judul buku dan intisari pada sebuah teks ilmiah dalam suatu
makalah berbahasa Indonesia.
1.3 Kamus
Kamus adalah bagian teks algoritma tempat mendefinisikan:
 nama type,
 nama konstanta,
 nama informasi (variabel),
 nama fungsi, sekaligus spesifikasinya
 nama prosedur, sekaligus spesifikasinya

Semua nama tersebut baru dapat dipakai jika didefinisikan dalam kamus. Penulisan
sekumpulan nama dalam kamus sebaiknya dikelompokkan menurut jenis nama tersebut.
Nama variabel belum terdefinisi harganya ketika didefinisikan. Pendefinisian nama konstanta
sekaligus memberikan harganya. Pendefinisian nama fungsi dilakukan sekaligus dengan
domain dan range serta spesifikasinya. Pendefinisian nama prosedur sekaligus dengan
pendefinisian parameter (jika ada) dan spesifikasi prosedur (Initial state, final state dan
proses yang dilakukan)
Dalam bahasa pemrograman, setiap nama mempunyai aturan penulisan (sintaks) tertentu,
misalnya yang menyangkut karakter yang diperbolehkan, jumlah maksimum karrakter, dsb.
Pada teks algoritma, tidak ada aturan ketat mengenai nama. Yang penting adalah bahwa
pemilihan nama harus interpretatif, tidak menimbulkan kerancuan dan jika singkat harus
disertai dengan penjelasannya. Nama karena merupakan satu kesatuan leksikal, maka sebuah
nama harus dituliskan secara utuh (tidak boleh dipisahkan dengan blank) supaya satu nama
dapat dibedakan dari nama yang lain atau satuan leksikal lain. Nama informasi sebaiknya
menunjukkan type. Contoh nama yang menimbulkan kerancuan : X-Y akan membingungkan
sebab mungkin berarti X “minus” Y.
Kamus global atau umum dikenal untuk seluruh program. Kamus lokal hanya dikenal pada
teks algoritma dimana kamus tersebut ditulis.
Contoh pendefinisian kamus [dikutip dari Liem, 29]
KAMUS
{Nama Type, hanya untuk type yang bukan type dasar}
type Point : <X:real,Y:real>{koordinat pada sumbu kartesian}
{Nama Konstanta, harus menyebutkan type dan nilai}
constant PI: real = 3.14159
constant Ka: character = 'K'
constant Faktor: integer = 3
constant Benar: boolean = true
{Nama Informasi, menyebutkan type}

NMax: integer {jumlah maksimum elemen tabel}
Found: boolean {Hasil pencarian, true jika ketemu}
P : Point {Posisi pena pada bidang kartesian}
CC: character {Current character}
{Spesifikasi Fungsi, menyebutkan nama fungsi, domain dan range}
function RealToInt (i:real)-> integer
{Mengkonversi harga i yang bertype real menjadi harga ekivalen yang bertype
integer}
{Spesifikasi Prosedur, menyebutkan Nama, parameter, Initial State (I.S.) , Final

State (F.S.) dan Proses}
procedure INISIALISASI
{I.S. Sembarang
F.S. Semua nama global dalam kamus terdefinisi nilainya
Proses: Menginisialisasi semua nama informasi global}
procedure Tulis (Input Pesan: string)
{I.S. sembarang
F.S. Pesan tertulis di layar
Proses : Menulis isi Pesan ke layar}
1.4 Algoritma
Algoritma adalah bagian teks algoritmik yang berisi instruksi atau pemanggilan aksi yang telah
didefinisikan. Komponen teks algoritmik dalam pemrograman prosedural dapat berupa:
 instruksi dasar seperti input/output, assignmnet

 sequential statement
 analisis kasus
 pengulangan

2 TYPE
Ketika bekerja dengan data, biasanya kita tidak melibatkan lokasi segmen memori yang digunakan
untuk menyimpan data tersebut. Kecuali, kalau segmen memorinya telah didefinisikan
sebelumnya secara pasti. Suatu type data dapat digunakan sebagai nama untuk type data
tertentu — a string, character, integer, dll. Ketika suatu data type mendefinisikan namanya
sebenarnya juga menentukan ukuran memori yang digunakan, domain / jangkauan nilainya, dan
operasi yang dapat diterapkan pada data tersebut. Type data merepresentasikan pola/struktur
datanya.
Dalam program terdapat banyak type, secara umum dapat digolongkan menjadi dua: type dasar
merupakan type yang tersedia langsung dan siap pakai dalam program dan type bentukan yang
dapat diturunkan dari type dasar atau type bentukan lainnya. Kategori type dasar dalam bahasa
aras tinggi umumnya terdiri dari integer, real, character, dan Boolean, terkadang string.
2.1 Type Dasar

Type dasar adalah type yang sudah tersedia dan telah didefinisikan oleh pemroses bahasa.
Program dapat memanfaatkan secara langsung dengan mengikuti aturan pendefinisian type dasar
tersebut. Type-type dasar yang akan digunakan dalam notasi algoritmik tersebut disesuaikan
dengan bahasa yang akan digunakan. Type dasar notasi algoritmik tersebut adalah:
 boolean (bilangan logika)

 integer (bilangan bulat)
 real (bilangan riil)
 character (karakter)
 string (kata)
Implementasi type tersebut dalam berbagai bahasa dapat sedikit berbeda. Akan dipelajari ketika
dijelaskan pada bahasa yang bersangkutan.
2.1.1 Boolean/ Bilangan Logika

Nama : Boolean
Domain : [true, false]
Konstanta : true, false
Operator : not, or, and, xor
Hasil operasinya dapat dilihat pada table kebenaran berikut

Tabel 2.1 Tabel kebenaran operator logika
Operant Hasil operasi Operator
1 2 or and xor
true true true true false
true false true false true
false true true false true
False false false false false
not true False not false true
2.1.2 Integer / Bilangan Bulat

Nama : integer
Domain : Z
Konstanta : 0 4 -23 1000
Bilangan integer ini memiliki keterurutan berikut
 suksesor x adalah x + 1
 predesesor x adalah x – 1
Contoh: suksesor 5 adalah 6; predesesor 5 adalah 4; predesesor -5 adalah -6
Operator : Operator aritmatika dan relasional
Tabel 2.2 Operator integer
Kategori operator Operator Arti Hasil
Aritmatika + Tambah integer
- Kurang integer
* Kali integer
div Bagi integer
/ Bagi real
mod Sisa pembagian bulat integer
^ pangkat integer
abs Nilai absolute Integer>0
Relasional/ = Sama dengan boolean

perbandingan ≠ Tidak sama dengan boolean
< Lebih kecil dari boolean
> Lebih besar dari boolean
≤ Lebih kecil dari atau sama dengan boolean
≥ Lebih besar dari atau sama dengan boolean
2.1.3 Real/ Bilangan Riil

Nama : real
Domain : R
Konstanta : Angka mengandung titik (.) dan dapat dituliskan dengan E yang berarti
bilangan pangkat basis 10.
Contoh: 1.34 4.3 -23. .1000 2.1E1
Operator : Operator aritmatika dan relasional
Tabel 2.3 Operator integer
Aritmatika + Tambah real
- Kurang real
* Kali real
/ Bagi real
^ pangkat real
Relasional/ ≠ Tidak sama dengan boolean

perbandingan
Catatan :

1. Bilangan riil yang mengandung E berati pangkat basis 10. Contoh: 1.5E2 berarti 1.5 * 102
2. Dalam notasi algoritmik, operator relasional kesamaan tidak berlaku untuk bilangan riil,
untuk harga riil harus didefinisikan suatu bilangan kecil ε (epsilon) yang menyatakan
ketelitian perhitungan, termasuk yang disebut dengan "kesamaan".
3. Pada bahasa pemrograman yang nyata, operator kesamaan bilangan riil mungkin dapat
dipakai dengan “baik”, namun harus hati-hati dan sangat spesifik untuk implementasi
bahasa tertentu. Dengan alasan ini, pada notasi algoritmik operator kesamaan bilangan
riil dianggap tidak ada.
2.1.4 Character
Nama : Character
Domain : Himpunan yang terdefinisi oleh suatu enumerasi, misalnya :

['0'..'9','a'..'z','A'..'Z', RETURN, SPACE, EOL]
Karakter yang tidak kelihatan dituliskan namanya, misalkan RETURN
Ada keterurutan (suksesor dan predesesor), yang ditentukan oleh

representasi di dalam komputer, misalnya pengkodean ASCII. Dalam notasi
algoritmik di sini digunakan keterurutan berdasarkan ASCII atau extended
ASCII, sehingga memiliki operator relasional yang lebih lengkap.
Konstanta : dituliskan di antara tanda petik atau suatu nama
‘0’, ‘t’, ‘E’, SPACE
Operator : Operator relasional
Tabel 2.4 Operator character
Relasional/ = sama dengan boolean

perbandingan
≠ Tidak sama dengan boolean
2.1.5 string
Nama : String
Domain : Untaian karakter yang didefinisikan dalam domain character
Konstanta : Untuk membedakan dengan karakter digunakan tanda pembatas “ “

“kutipan”, “t”, “Eksport”, “”
Operator : Operator relasional
Tabel 2.5 Operator string
Relasional/ = sama dengan boolean

perbandingan
≠ Tidak sama dengan boolean
konstruksi • Tambah satu karakter di akhir string string
⁰ Tambah satu karakter di awal string string
& konkatenasi string
2.1.6 Enumerasi
Type enumerasi adalah type yang definisi domainnya tidak menurut suatu aturan akan tetapi
dilakukandengan cara enumerasi, menyebutkan anggotanya satu per satu. Tipe ini sangat
diperlukan untuk menyebutkan himpunan nilai yang pasti. Karena disebutkan satu per satu cara
mengakses anggotanya dapat digunakan kata kunci:
 First, yaitu nilai anggota yang pertama

 Last, yaitu nilai anggota yang terakhir
 Predecesor(elemen), yaitu nilai anggota sebelumnya dari elemen
 Successor(elemen), yaitu nilai anggota yang berikutnya dari elemen
Contoh:
type hari: (senin, selasa, rabu, kamis, jumat, sabtu, minggu)

type warna: (merah, jingga, kuning, hijau, biru, nila, ungu)
2.2 Type Bentukan

Type bentukan adalah type yang dibentu/dikonstruksi dari type dasar atau/dan type bentukan
lainnya yang telah didefinisikan sebelumnya (dikenal). Biasanya type bentukan merupakan
komposisi beberapa type yang sudah dikenal, atau dapat juga hanya mewakili hanya satu tipe
dasar saja, sehingga type bentukan terdiri dari dua macam:
1. Type dasar yang diberi nama lain

2. Komposisi/struktur atau rekaman

2.2.1 Type Dasar yang Diberi Nama Baru
Pemberian nama baru kadang diperlukan dalam suatu program, tujuannya untuk
menyederhanakan penulisannya, untuk menjaga konsistensi penulisan teks program, atau
untuk memberikan penamaan baru agar mudah diingat.
Dalam notasi algoritmik dituliskan dengan skema berikut:
type NamaType: type
Contoh:
type bulat: integer

type TanggalMasehi: integer[1..31]
type TanggalKomariah: integer[1..30]
2.2.2 Type Dasar Struktur

Dalam notasi algoritmik, untuk type bentukan dengan komposisi, dituliskan dengan skema
sebagai berikut:
type NamaType <elemen1:type1,

elemen2: type2,
elemen3: type2,
…>
Contoh-1:
{Type TPoint menyatakan koordinat titik (absis ada ordinat ) dalam sumbu kartesian}
type TPoint <x, y: real>
Jika P didefinisikan sebagai nama variabel bertype TPoint berikut:
P: TPoint
Maka cara mengacu ke elemen-elemennya adalah dengan menggunakan tanda titik (.) berikut:
P.x {ini adalah nilai absis TPoint P bernilai real}

P.y {ini adalah nilai ordinat TPoint P bernilai real}
Nama : TPoint
Domain : [real, real]
Konstanta : <2.1, -3.2>
Operator :  Operator terhadap TPoint harus dibuat

 Operasi real pada P.x dan P.y, jika P: TPoint
Contoh-2:
{Type TJam menyatakan waktu jam dengan jam (hh), menit (mm), detik (dd)}
type TJam <hh: integer[0..23],
mm: integer[0..59],
ss: integer[0..59]>
Nama : TJam

Domain : <integer[0..23], integer[0..59], integer[0..59]>
Konstanta : <0, 5, 7>, <23, 49, 59>
<24, 0, 0> ini konstanta yang salah, karena .hh>23
Operator :  Operator terhadap TJam harus dibuat

 Operasi integer pada J.hh, J.mm dan J.ss, jika J: TJam
Contoh-3:
type
{Type THari menyatakan enumerasi hari: siang (am) atau malam (pm)}
THari: (am, pm)
{Type TJam2 menyatakan waktu jam: jam (hh), menit (mm), detik (dd), hari (hari)}
TJam2 <hh: integer[0..11],
mm: integer[0..59],
ss: integer[0..59],
hari: THari>
Nama : TJam2
Domain : <integer[0..11], integer[0..59], integer[0..59], (am, pm)>
Konstanta : <0, 5, 7, am>, <3, 49, 59, pm>
<12, 0, 0, pm> ini konstanta yang salah, karena .hh>11
Operator :  Operator terhadap TJam2 harus dibuat

 Operasi integer pada J.hh, J.mm dan J.ss, jika J: TJam2
2.3 Nilai, Ekspresi, Input, dan Output

Prosesor di dalam computer mampu melakukan pemrosesan data. Pemrosesan yang sederhana
dapat berupa operasi-operasi dasar logika dan aritmatika. Sebelum operasi dilakukan, lokasi data
yang akan diolah harus diketahui dan kemana hasil olahan data akan disimpan atau digunakan
kembali. Dalam suatu teks program, tidak tergantung dalam implementasi di computer, nilai
dapat disimpan dalam suatu variabel atau konstanta bernama. Nilai variabel ini bisa didapatkan
dari pembacaan piranti masukan atau berasal dari aksi program lainnya.
2.3.1 Nilai (harga)

Nilai (harga) adalah instansiasi suatu type yang sudah didefenisikan (dikenal).
Harga dalam suatu algoritma dapat diperoleh dari :
 isi suatu nama, yaitu nama informasi/variabel atau nama konstanta

 hasil perhitungan suatu ekspresi
 hasil yang dikirim suatu FUNGSI
Harga suatu variabel bertype dapat dimanipulasi (diubah) dengan cara instruksi assignment atau
dibaca melalui piranti masukkan. Sedangkan harga suatu konstanta tidak dapat dimanipulasi dan
hanya memiliki harga yang tetap seperti yang didefenisikan dalam kamus.

2.3.2 Assignment
Assignment adalah instruksi primitif algoritmik untuk menyimpan harga kedalam suatu nama
informasi yang isinya boleh bervariasi (“variabel”), singkatnya memberikan harga pada suatu
nama variabel. Dalam notasi algoritmik assignment ini disimbolkan dengan tanda panah ke arah
kiri (←), yang berarti masukkan harga bertype tertentu dari sisi kanan symbol ke sisi kiri symbol.
Sehingga type sisi kiri harus sama dengan type sisi kanan, karena notasi algoritmik memiliki
kekakuan dalam type.
Kamus
constant PI: integer=3.1415
type TPoint <x, y: real>
VarPI, KelilingLingkaran, Keliling: real
P1, P2: TPoint
Algoritma
VarPI← PI {harga konstanta PI diisikan ke VarPI}
KelilingLingkaran←PI*24. {harga ekspresi PI*24. diisikan ke KelilingLingkaran}
P1.x← KelilingLingkaran {harga KelilingLingkaran diisikan ke P1.x}
P1.y←5. {harga 5. Diisikan ke P1.y}

3 AKSI SEKUENSIAL
Aksi sekuensial (Sequential statement) adalah struktur kontrol algoritmik yang paling sederhana.
Aksi sequensial ini merupakan eksekusi dari sederetan instruksi/aksi secara berurutan. Pada
setiap urutan menunjukkan adanya suatu kondisi sebelum dan setelah suatu instruksi/aksi
dijalankan, sehingga urutan aksi ini akan sangat mempengaruhi hasil akhir eksekusi dari
sekumpulan instruksi yang berurutan.
Dalam notasi algoritmik, tatacara penulisan aksi sekuensial ini dituliskan baris per baris. Pada
suatu algoritma, terkadang ada beberapa bagian aksi sekuensial yang tidak mempengaruhi hasil
akhir suatu algoritma. Kondisi ini dapat dituliskan dalam satu baris dengan tanda pemisah tiap
instruksi berupa semicolon (;)
Program AksiSekuen
{Contoh program aksi sekuensial}
Kamus:
P, L, T, Luas, Isi: real
LebihBesar: Boolean
Algoritma:
P←8.
L←4.5
Luas←P*L
input(T)
Isi←Luas*T
LebihBesar←Isi>Luas
output(Luas, Isi, LebihBesar)
Catatan: Aksi P←8 dan L←4.5 pada bagian Algoritma dapat dituliskan satu baris dengan tanda
pemisah titik-koma(;) berikut P←8; L←4.5
Untuk lebih mempermudahakan diberikan beberapa contoh aksi sekuensial berikut ini.
Contoh-1:
Permasalahan menuliskan “Hello world” ke piranti keluaran. Di sini diberikan dua solusi dan
pertimbangkan mana yang lebih baik menurut anda.
Program HelloWorld1
{Menuliskan “Hello world” ke piranti keluaran}
Kamus:
Algoritma:
output(“Hello world”)
Program HelloWorld2
{Menuliskan “Hello world” ke piranti keluaran}
Kamus:
Salam: string
Algoritma:
Salam←“Hello world”
output(Salam)

Contoh-2:
Menuliskan “Hello” diikuti dengan nama seseorang yang dimasukkan lewat piranti masukan.
Misalkan Nama seorang yang dimasukkan “Budi” maka keluarannya adalah: “Hello, Budi”. Di sini
juga diberikan dua solusi dan pertimbangkan mana yang lebih baik.
Program HelloSomeone1
{Menuliskan “Hello” dan diikuti nama seseorang yang berasal dari piranti masukan ke piranti
keluaran}
Kamus:
Someone: string
Algoritma:
Input(Someone)
output(“Hello, “, Someone)
Program HelloSomeone2
{Menuliskan “Hello” dan diikuti nama seseorang yang berasal dari piranti masukan ke piranti
keluaran}
Kamus:
Someone: string
Algoritma:
Input(Someone)
Someone←“Hello, “ & Someone
output(Someone)

4 ANALISIS KASUS
Dalam mengembangkan aplikasi, kadang kita harus memastikan tentang harga suatu informasi
yang dimasukkan lewat piranti masukan, kemudian menyeleksi satu pilihan yang sesuai dari
beberapa kasus yang tersedia untuk menjalankan suatu kumpulan aksi berikutnya. Analisis kasus
ini sangat luas penggunaannya, kemampuannya dapat menjalankan berbagai bagian aksi sesuai
dengan keadaan kondisi yang dimilikinya. Singkatnya, analisis kasus ini melahirkan instruksi
kondisional, sehingga memungkinkan suatu teks program yang sama menghasilkan eksekusi yang
berbeda; tergantung keadaan kondisionalnya.
Mendefinisikan analisis kasus berarti mendefinisikan:
 Kondisi, yang berupa ekspresi yang mengasilkan nilai bitwise true atau false
 Aksi yang akan dilaksanakan sesuai dengan keadaan kondisional yang dipenuhinya.
Untuk mengkonstruksi analisis kasus ini perlu dipahami semua domain kondisi yang
mungkin yang terkait dengan variasi aksinya. Ini perlu dilakukan agar tidak terjadi kesalahan
aksi yang tidak dikehendaki masuk dalam domain kondisi lainnya. Kadang domain kondisi
yang kompleks yaitu yang terkait dengan beberapa parameter keadaan kondisional, sering
dilakukan analisis dengan cara proses tabulasi antara kondisi dan aksi untuk
penyederhanaannya. Meskipun begitu tidak ada rumus baku yang menjadi pedoman untuk
menyelesaikan analisis kasus ini.
Notasi algoritmik secara umum untuk analisis kasus yang umum (banyak kasus):
depend on (NamaNama)
<kondisi-1> : <aksi-1>
<kondisi-2 > :<aksi-2>
<kondisi-3> : <aksi-3>
…
<kondisi-N> : <aksi-N>
dengan syarat :
 kondisi-1,kondisi-2,kondisi-3, …, kondisi-N domain harganya [true, false]
 kondisi-1,kondisi-2,kondisi-3, …, kondisi-N adalah ekspresi lojik/boolean yang
mengandung NamaNama sebagai operan.
 kondisi-1 ∩ kondisi-2 ∩ kondisi-3 ∩ …, ∩ kondisi-N = Ø. Berarti semua kondisi disjoint,
tidak ada kasus yang sama tercakup pada dua buah kondisi.
 kondisi-1 ∪ kondisi-2 ∪ kondisi-3 ∪ … ∪ kondisi-N berarti kondisi mencakup semua
kemungkinan
Jika hanya ada satu kasus yang mengakibatkan aksi, atau dua kasus komplementer, dapat
dipakai notasi sebagai berikut :
SATU KASUS:
if (kondisi) then
aksi
Jika kondisi benar aksi dilakukan dan jika kondisi salah tidak menjalankan apa-apa (kosong)

DUA KASUS:
if (kondisi) then
aksi-1
else
aksi-2

5 FUNGSI
Definisi :
Fungsi adalah pemetaan suatu domain ke range berdomain tertentu.
Fungsi dapat diibaratkan sebuah mesin yang mentransformasi/memetaan suatu nilai (dari
“domain”) ke nilai lain (dalam “range”). Secara algoritmik, sebuah fungsi akan menerima suatu
harga yang diberikan lewat parameter formal bertype tertentu (jika ada) dan menghasilkan satu
nilai sesuai dengan domain yang didefinisikan dalam spesifikasi fungsi. Perbedaan utama antara
prosedur dan fungsi adalah bahwa fungsi akan mengirimkan satu nilai sesuai dengan typenya. Jika
prosedur dipanggil dalam suatu aplikasi, ia hanya menjalankan teks programnya sendiri. Namun
jika suatu fungsi dipanggil suatu program, ia akan menjalankan fungsi tersebut dan mengirimkan
satu nilai ke program yang memanggilnya.
Dalam penulisannya, fungsi diberi nama, dan parameter formal yaitu harga masukan yang juga
diberi nama dan dijelaskan typenya. Fungsi harus didefinisikan dalam kamus.
Fungsi yang didefinisikan dapat “dipanggil” untuk dieksekusi lewat namanya, dan dengan
diberikan nilai parameter aktualnya.
Contoh Fungsi:
Fungsi f() adalah fungsi nilai keluaran random dari lemparan dadu, fungsi ini tanpa parameter dan
dapat didefinisikan sebagai:
f()= y, dimana y∈(1, 2, 3, 4, 5, 6)
Fungsi f(x) merupakan fungsi kuadrat dengan satu parameter x∈R, dalam matematika dapat
didefinisikan sebagai :
f(x) = 2x2 – 4, dimana x∈R
jika x = 1 maka f(x) akan menghasilkan -2
jika x = 2 maka f(x) akan menghasilkan 4
f(p, l, t) = p*l*t adalah fungsi isi balok dengan tiga parameter p, l, dan t > 0. Jika diberi harga p = 4,
l= 2, dan t=1 maka f(p, l, t) akan menghasilkan 8. Jika diberi harga p = 4, l= 3, dan t=2 maka f(p, l, t)
akan menghasilkan 24.

5.1 Notasi Algoritmik untuk Fungsi
5.1.1 Pendefinisian/Spesifikasi Fungsi
function NamaFungsi (<list-parameter input>)→ <type hasil>

{Spesifikasi fungsi: diberikan ..... menghasilkan .....}
Kamus lokal:
{semua NAMA yang dipakai dalam algoritma/realisasi fungsi}
Algoritma:
{deretan instruksi algoritmik:
pemberian harga, input, output, analisis kasus, pengulangan}
{Pengiriman harga di akhir fungsi, harus sesuai dengan type hasil}
→ hasil
Dengan syarat:
 list parameter input boleh tidak ada (kosong), dalam hal ini di fungsi tidak membutuhkan
apa-apa dari pemakainya untuk menghasilkan harga.
 jika list parameter input (parameter formal) tidak kosong, minimal mengandung satu
nama, maka nama tersebut harus berupa nama informasi beserta typenya.
 instruksi “terakhir” yang harus ada pada fungsi harus merupakan pengiriman harga yang
dihasilkan oleh fungsi (dituliskan seperti pada notasi di atas, dengan type hasil boleh type
dasar atau type bentukan). Type hasil boleh dinyatakan oleh suatu nama type. Dengan
catatan, bahwa instruksi “terakhir” belum tentu dituliskan pada baris terakhir, misalnya
jika hasil merupakan sebuah nilai yang dikirimkan berdasarkan analisis kasus.
5.1.2 Pemanggilan Fungsi

Program POKOKPERSOALAN
{Spesifikasi : Input, Proses, Output}
Kamus:
{semua NAMA yang dipakai dalam algoritma}
function NamaFungsi (<list nama parameter formal/input>)→ <type hasil>
{Spesifikasi fungsi}
Algoritma:
{deretan instruksi pemberian harga, input, output, analisis kasus, pengulangan yg memakai
fungsi}
{Harga yang dihasilkan fungsi juga dapat dipakai dalam ekspresi}
nama ← NamaFungsi(<list parameter aktual>)
output(NamaFungsi(<list parameter aktual>)
Catatan:
 1. Pada waktu pemanggilan terjadilah asosiasi antara parameter formal/input dengan

parameter aktual sesuai dengan urutan penulisan dalam list-nama parameter input.
 2. List parameter input dapat berupa nama informasi atau nama konstanta yang telah
terdefinisi dalam kamus atau konstanta; dapat juga berupa harga konstanta, atau harga
yang dihasilkan oleh suatu ekspresi atau fungsi.
 3. List parameter aktual harus sama jumlah, urutan dan typenya dengan list parameter
formal pada pendefinisian fungsinya.
 4. Harga yang dihasilkan oleh fungsi dapat didefinisikan domainnya dengan lebih rinci.
 5. Pada akhir dari eksekusi fungsi, harga yang dihasilkan oleh fungsi dikirimkan ke
pemakainya.
 6. Fungsi boleh dipakai oleh program utama, prosedur atau fungsi lain.

6 PROSEDUR
Pemanfaatan notasi algoritmik prosedur output merupakan contoh prosedur sederhana yang
memang terdaftar dalam algoritmik. Prosedur output ini memberikan aksi menampilkan ke piranti
keluaran semua parameter formal yang diberikan kepadanya.
Prosedur adalah sederetan instruksi algoritmik yang diberi nama, dan akan menghasilkan efek
neto yang terdefinisi, jika diperlukan efek neto ini dapat berupa aksi kosong.
Mendefinisikan (membuat spesifikasi) prosedur berarti menentukan nama prosedur serta

parameternya (jika ada), dan mendefinisikan keadaan awal (Initial State, I.S.) dan keadaan akhir
(Final State, F.S.) dari prosedur tersebut. Prosedur didefinisikan (dituliskan spesifikasinya) dalam
kamus. Cara penulisan spesifikasi : prosedur diberi nama, dan parameter formal (jika ada) yang
juga diberi nama dan dijelaskan typenya.
6.1 Parameter Prosedur

Prosedur tanpa parameter, dalam memberikan efek netonya, melakukan sederetan instruksi yang
memanfaatkan nilai dari nama-nama yang terdefinisi pada kamus global. Pemakaiannya biasanya
harus “hati-hati”, apalagi jika teks program sudah sangat besar dan implementasinya menjadi
banyak file.
Prosedur berparameter dirancang, agar sepotong kode yang sama ketika eksekusi dilakukan,
dapat dipakai untuk nama parameter yang bebeda-beda.
Nama parameter yang dituliskan pada definisi/spesifikasi prosedur disebut sebagai parameter
formal. Sedangkan parameter yang dituliskan pada pemanggilan prosedur disebut sebagai
parameter aktual.
Parameter formal adalah nama-nama variabel (list nama) yang dipakai dalam mendefinisikan
prosedur, dan membuat prosedur tersebut dapat dieksekusi dengan nama-nama yang berbeda
ketika dipanggil. Parameter formal adalah list nama yang akan dipakai pada prosedur, yang
nantinya akan diasosiasikan terhadap nama variabel lain pada saat pemanggilan. Sesuai dengan
ketentuan nilainya, ada tiga type parameter formal:
 parameter Input, yaitu parameter yang diperlukan prosedur sebagai masukan untuk
melakukan aksi yang efektif.
 parameter Output, yaitu parameter yang nilainya akan dihasilkan oleh prosedur. Hasil
nilai akan disimpan pada nama parameter Output ini.
 parameter Input/Output, yaitu parameter yang nilainya diperlukan prosedur sebagai
masukan untuk melakukan aksi, dan pada akhir prosedur akan dihasilkan nilai yang baru.

6.2 Notasi Algoritmik untuk Prosedur
6.2.1 Pendefinisian/Spesifikasi Prosedur
procedure NamaProsedur([list nama parameter formal: type])

{Spesifikasi, Initial State, Final State}
Kamus lokal:
{semua NAMA yang dipakai dalam BADAN PROSEDUR}
Algoritma:
{ BADAN PROSEDUR }
{deretan instruksi pemberian harga, input, output, analisis kasus, pengulangan atau
prosedur}
dengan syarat :
 nama prosedur dan prameternya harus disebutkan dalam kamus pemanggil.

 list parameter formal boleh tidak ada (kosong), dalam hal ini di dalam prosedur akan
dipakai nama lokal dan nama-nama yang telah terdefinisi dalam kamus "pemakai"nya.
 jika list parameter formal ada (tidak kosong, minimal satu nama), maka harus berupa
satu atau beberapa nama INFORMASI beserta typenya.
6.2.2 Pemanggilan Prosedur

Program POKOKPERSOALAN
{Spesifikasi , Input, Proses, Output}
Kamus:
{ semua NAMA yang dipakai dalam algoritma }
procedure NAMAPROSEDUR (Input/Output : <list-nama parameter formal>) {Spesifikasi : Initial
State, Final State}
Algoritma:
{Deretan instruksi assignment/pemberian harga, input, output, analisis kasus, pengulangan )
NAMAPROSEDUR (<list parameter aktual>)
dengan syarat :
 pada waktu pemanggilan terjadilah asosiasi antara parameter formal dengan parameter
aktual sesuai dengan urutan penulisan dalam list-nama parameter formal.
 list parameter aktual harus sama jumlah, urutan dan typenya dengan list parameter
formal.
 list parameter aktual yang berupa Input dapat berupa nama informasi atau nama
konstanta/ekspresi yang telah terdefinisi dalam kamus atau konstanta; dapat juga berupa
harga konstanta, atau harga yang dihasilkan oleh suatu ekspresi atau fungsi.
 list parameter aktual yang berupa Input/Output atau Output harus berupa nama
informasi. Jika didefinisikan sebagai Input, walaupun pernah diubah dalam badan
prosedur, isi dari nama yang dipakai pada parameter aktual tidak pernah berubah. Jika
didefinisikan sebagai parameter Output dan parameter aktual yang diasosiasikan
terhadapnya pernah diubah harganya dalam badan prosedur, isinya akan berubah.

Contoh-1
Prosedur tukar digunakan untuk menukar dua harga
Program TUKAR
{Program yang membaca dua buah harga x dan y, menuliskan, kemudian menukarnya, dan
menuliskan kembali nilai setelah pertukaran}
Kamus:
x,y: integer
procedure Tukar(Input/Output a,b: integer)
{Prosedur untuk menukar dua buah harga yang tersimpan dalam dua nama integer}
{I.S.: diberikan a=A dan b=B}
{F.S.: a=B dan b=A}
Algoritma:
input(x , y)
output(x, y)
Tukar(x, y)
output(x, y)
procedure Tukar (Input/Output a,b: integer)

{I.S.: diberikan a=A dan b=B}
{F.S.: a=B dan b=A}
Kamus lokal: temp: integer
Algoritma:
Temp← a {Temp = a; a = a; b = b}
a← b {Temp = a; a = b; b = b}
b← Temp {Temp = a; a =b; b = a}

7 PENGULANGAN
Salah satu kemampuan komputer dibandingkan dengan manusia adalah kemampuannya dalam
menjalankan suatu instruksi secara berulang -ulang secara konsisten dan dengan peformansi yang
sama. Komputer akan terus malakukan pengulangan sesuai dengan perintah yang diberikan,
hingga suatu kondisi tertentu yang menyatakan berhenti atau kondisi persyaratan pengulangan
sudah tidak dipenuhi lagi.
Pengulangan terdiri dari dua bagian :
1. kondisi yang mengakibatkan pengulangan suatu saat berhenti, yang dinyatakan oleh
sebuah ekspresi logik baik secara eksplisit maupun implisit
2. badan pengulangan, yaitu aksi yang harus diulang selama kondisi yang ditentukan untuk
pengulangan masih dipenuhi
Pengulangan harus berhenti, ini yang harus dijamin oleh pemrogram. Pengulangan yang terus
menerus harus dapat dideteksi pemrogram bahkan sebelum program dieksekusi oleh mesin,
berdasarkan invariansi dari badan pengulangan tersebut.
Notasi pengulangan adalah salah satu notasi dasar dalam penulisan algoritma selain analisis
kasus. Namun notasi tersebut hanya akan ada artinya jika dikenakan terhadap skema tertentu.
Notasi pengulangan yang berdiri sendiri tidak ada artinya, bahkan menyesatkan karena pada
hakekatnya notasi pengulangan hanyalah merupakan sebagian dari skema pengulangan yang akan
dibahas pada bab-bab berikutnya.
Ada lima macam notasi pengulangan, yaitu pengulangan berdasarkan:
1. banyaknya pengulangan,
2. kondisi berhenti
3. kondisi ulang
4. dua aksi
5. pencacah
7.1 Pengulangan Berdasarkan Banyaknya Pengulangan

repeat n times
Aksi
{n adalah nama informasi yang terdefinisi nilainya, dan n bilangan bulat}
Aksi akan diulang sebanyak n kali, dan bukan urusan pemrogram untuk mengelola pengulangan
tersebut. Dengan hanya menyebutkan pengulangan tersebut, pengulangan pasti akan berhenti
suatu saat.
7.2 Pengulangan Berdasarkan Kondisi Berhenti

repeat
Aksi
until kondisi-berhenti
Aksi akan dihentikan jika kondisi-berhenti dipenuhi (bernilai true), akan diulang jika
kondisi-berhenti belum tercapai. Badan pengulangan pada notasi ini (Aksi) minimal akan
dilakukan satu kali karena pada waktu eksekusi pengulangan yang pertama tidak ada
dilakukan test terhadap kondisi-berhenti. Test terhadap kondisi berhenti dilakukan setelah
Aksi dilaksanakan. Pengulangan ini berpotensi untuk menimbulkan "kebocoran" (ada Aksi
yang dileksekusi tanpa pernah diperiksa kondisi pelaksanaannya), jika ada kemungkinan
bahwa seharusnya Aksi tidak pernah boleh dilakukan untuk kasus yang tertentu.
Aksi sekuensial yang dilakukan adalah : Aksi, test kondisi-berhenti, [Aksi, test kondisi-
berhenti,. dst] diakhiri test- kondisi-berhenti yang bernilai true, yang menyebabkan
pengulangan berhenti.
7.3 Pengulangan Berdasarkan Kondisi Ulang

Whilekondisi-pengulangan do
Aksi
{ Kondisi berhenti dicapai di titik program ini
Aksi akan dilakukan selama kondisi -pengulangan masih dipenuhi (bernilai true). Badan
pengulangan (Aksi) pada notasi ini mungkin tidak akan pernah dilakukan, karena sebelum
aksi yang pertama dieksekusi dilakukan test terhadap kondisi berhenti. Test terhadap
kondisi -pengulangan dilakukan setiap kali sebelum Aksi dilaksanakan. Pengulangan ini
berpotensi untuk menimbulkan aksi "kosong" (tidak pernah melakukan apa-apa karena pada
test yang pertama, kondisi -pengulangan tidak dipenuhi (bernilai false).
7.4 Pengulangan Berdasarkan Dua Aksi

iterate
Aksi-1
stop kondisi-berhenti
Aksi-2
{Kondisi berhenti dicapai di titik program ini}
Pengulangan ini seolah-olah adalah "gabungan" antara bentuk pengulangan kedua dan ketiga.
Mekanisme yang dilakukan oleh pengulangan ini adalah dengan melakukan secara otomatis
Aksi-1 pada eksekusi yang pertama kemudian dilakukan test terhadap kondisi berhenti.
Tergantung kepada kondisi berhenti yang ditest:
 Aksi-2 akan diaktifkan dan kemudian Aksi-1 yang berikutnya diulang, atau
 pengulangan dihentikan karena efek neto dari Aksi-1 menghasilkan kondisi
berhenti.
Pengulangan ini berguna untuk kasus-kasus di mana Aksi-2 merupakan hal yang harus
dilakukan tergantung dari hasil Aksi-1.

7.5 Pengulangan Berdasarkan Pencacah
nama-pencacah traversal [range-harga]
Aksi
{Catatan: nama-pencacah harus suatu type yang terdefinisi suksesor dan predesesornya,
setelah pelaksanaan pengulangan selesai, harga yang tersimpan pada nama-pencacah tidak
terdefinisi: jika hendak dipakai, harus didefinisikan kembali}
nama- -pencacah harus suatu type yang terdefinisi suksesor dan predesesornya, setelah
pelaksanaan pengulangan selesai, harga yang tersimpan pada nama -pencacah tidak
terdefinisi : jika hendak dipakai, harus didefinisikan kembali
Aksi akan dilakukan dengan memperhitungkan harga-harga dari nama -pencacah yang
di"jelajahi", dipakai satu per satu secara berturutan. Dengan memakai pengulangan ini,
pemrogram tidak perlu melakukan operasi terhadap suksesor/predesesor karena setiap kali
selesai melakukan Aksi, otomatis mesin akan melakukan operasi untuk mendapatkan
suksesor dari harga yang sedang berlaku saat itu untuk nama.
Pengulangan otomatis berhenti setelah penjelajahan terhadap nama -pencacah sudah
mencakup semua harga yang terdefinisi dalam range harga. Harga yang tersimpan pada nama
-pencacah setelah pengulangan selesai dilaksanakan tidak terdefinisi, jika ingin dipakai harus
didefinisikan kembali.
Pengulangan ini biasanya dipakai jika harga yang tersimpan dalam nama -pencacah ingin
dimanfaatkan dalam Aksi, namum tidak boleh diubah karena akan mengacaukan urutan
eksekusi yang dilakukan.
Pada bahasa pemrograman yang dapat dieksekusi mesin, nilai dan perubahan nama-
pencacah dikontrol oleh pemroses bahasa. Harga yang tersimpan pada nama-pencacah
setelah pengulangan selesai dilaksanakan tidak terdefinisi, jika ingin dipakai harus
didefinisikan kembali.

8 PENGENALAN LINGKUNGAN PEMROGRAMAN DELPHI
8.1 Tujuan
6. Memberikan pemahaman tentang lingkungan pengembangan Delphi.
7. Menelusuri secara detail tentang tools dan kelengkapan (feature) yang tersedia dalam Delphi.
8.2 Selintas Tentang Delphi

Delphi adalah aplikasi pemrograman berorientasi objek dengan lingkungan pemrograman visual
untuk pengembangan aplikasi secara cepat (rapid application development/ RAD).
Kelengkapannya meliputi peralatan (tools) untuk pengembangan, pengetesan, pembangunan
aplikasi, termasuk kamus komponen yang dapat dimanfaatkan, tool disain, aplikasi dan templet
formulir, dan wizard pemrograman.
8.3 Alat Bantu (Help)

Dalam IDE, Informasi tentang Delphi dapat diperoleh dengan Online Help. Sistem Online Help yang
dikemas memberikan detail informasi tentang kelengkapan antar muka, implementasi bahasa,
tugas pemrograman, dan komponen. Untuk menampilkan daftarnya gunakan menu Help: Help |
Delphi Help dan Help | Delphi Tools, dan klik tabulasi Contents. Untuk melihat komponen atau topic
lainnya, klik Index atau tabulasi Find dan ketikkan kata yang diinginkan.
Alat bantu yang sensitive terhadap konteks (context-sensitive Help) dapat diterapkan pada semua
bagian lingkungan pengembangan, meliputi menu, kotak dialog, toolbars, dan komponen dengan
cara memilihnya dan kemudian menekan tombol F1.
T e k a n F1 p a d a
komponen dalam
f o r m u l i r ( form).
Dengan menekan tombol help dalam kotak

dialog juga akan menampilkan dokumentasi
online dalam konteks yang sensitif
Gambar 8.1 Alat bantu yang sensitif terhadap konteks
Pesan kesalahan (Error) dari compiler dan linker ditampilkan dalam jendela khusus di bawah
editor teks program. Untuk mendapatkan Help dari kesalahan kompilasi dilakukan dengan
menyeleksinya dari daftar, kemudian menekan tombol F1.

Tekan F1 pada
perintah menu,
dialog box, atau
jendela untuk
menampilkan Help
pada item tersebut.
Gambar 8.2 Alat bantu pada konteks menu
8.4 IDE
Setelah Delphi dijalankan akan terdapat beberapa tool utama dalam IDE (Integrated Development
Environtment), yang meliputi menu, toolbar, palet komponen, Object Inspector, Object TreeView,
Code editor, Code Explorer, Project Manager, dan tool lainnya. Banyaknya kelengkapan dan
komponen tergantung dari edisi Delphi yang diinstal.
Object TreeView menampilkan
komponen yang digunakan secara Menu dan toolbar dapat mengakses host
bertingkat kelengkapan dan tool untuk membantu penulisan
aplikasi program.
hierarchical view of your components
'
parent-child relationships. Component palette berisi

komponen siap pakai yang
dapat ditambahkan ke suatu
projek.
Code editor menampilkan

teks program untuk
melakukan peeditan.
Form Designer berisi

formulir kosong untuk
memulai pendisainan antar
muka suatu aplikasi.
Satu aplikasi dapat terdiri

dari beberapa formulir.
Object Inspector digunakan

untuk mengubah properties Code Explorer menampilkan classes, variables, dan routines
objects dan menseleksi event
' dalam unit program dan digunakan untuk navigasi cepat.
handlers.
Gambar 8.3 Lingkungan pengembangan yang terintegrasi
8.4.1 Menu dan Toolbar

Jendela utama, yang berada layar paling atas, berisi menu utama, toolbar, dan palet komponen.

Gambar 8.4 Jendela utama, pada susunan default
Toolbar ini merupakan akses cepat untuk perintah/operasi yang sering digunakan dan hampir semua
perintah di toolbar terdapat dalam menu. Beberapa operasi memiliki shortcut tombol kunci.
Remove
Open file from View Toggle Name of saved Save current
New Save project project unit form/unit desktop layout desktop
Open Save all Add file View New Set debug

form form desktop
to project
Untuk mengetahui perintah
tombol, fokuskan kursor tetikus
List of projects Trace New WebSnap New WebSnap padanya hingga tooltip muncul.
you can run into Application Data Module
Debug toolbar Internet toolbar menu klik kanan dapat
digunakan untuk
menyembunyikan/menampilk
an toolbar, pilih View|Toolbars
Run Pause Step over New WebSnap External dan cek salah satu yang
Page Module Editor diinginkan.
Gambar 8.5 Fungsi Toolbar dalam jendela utama
8.4.2 Palet komponen, Form Designer, Object Inspector dan Object TreeView
Palet komponen, Form Designer, Object Inspector dan Object TreeView bekerjasama untuk
membangun antar muka suatu aplikasi. Palet komponen memiliki beberapa halaman tabulasi yang
didasarkan atas fungsi kelompoknya, misalkan halaman Standard, Additional, dan Win32 berisi
kendali jendela seperti kotak edit dan tombol up/ down; halaman Dialogs berisi kotak dialog yang
umum digunakan untuk operasi file seperti membuka atau menyimpan file.
Halaman palet komponen, dikelompokkan berdasarkan fungsinya Klik untuk halaman selanjutnya
Komponen-komponen
Gambar 8.6 Palet komponen
Setiap komponen memiliki atribut yang spesifik—properties (sifat), events (reaksi), dan methods—
yang dapat digunakan untuk mengendalikan aplikasi.
Setelah menempatkan komponen dalam formulir, (atau Form Designer), komponen dapat disusun
kembali disesuaikan dengan kebutuhannya. Dengan memanfaatkan Object Inspector, komponen
tersebut juga dapat diset property design-timenya, menciptakan event handler, dan memfilter
property dan event yang Nampak, menjadikan koneksi antara aplikasi yang tampak secara visual
dengan teks program yang akan dijalankan.

Setelah komponen ditempatkan dalam formulir, Object Inspector akan
berubah secara dinamis dalam menampilkan sekumpulan propertinya,
didasarkan pada komponen yang dipilih.
Gambar 8.7 Objek inspector dan komponen
Object TreeView menampilkan hirarki komponen atau diagram pohon. Diagram pohon
disinkronkan dengan Object Inspector dan Form Designer, sehingga ketika terjadi perubahan fokus
dalam Object TreeView, maka keduanya, Object Inspector dan formulir, juga berubah fokus. Object
TreeView dapat digunakan untuk mengubah kaitan relationship komponen dengan lainnya.
Contohnya, jika dalam suatu formulir ditambahkan komponen panel dan check box, keduanya akan
setingkat. Jika dalam Object TreeView dilakukan proses drag check box ke atas icon panel, maka
check box akan menjadi anak (child) panel.
Halaman tabulasi Repository berisi objek-

objek forms, frames, units, dan wizards
untuk menciptakan item tertentu.
Object TreeView, Object Inspector,

dan Form Designer bekerja bersama.
Ketika diklik suatu objek dalam
formulir, akan secara otomatis
merubah fokus baik di Object
TreeView maupun Object Inspector
dan sebaliknya.
Tekan Alt-Shift-F11 untuk fokus ke

Object TreeView
Gambar 8.8 Objek TreeView, Objek Inspector, dan Form Designer
8.4.3 The Object Repository

Object Repository berisi formulir, kotak dialog, modul data, wizards, DLL, sample applications, dan
item-item lain yang dapat menyederhanakan proses pengembangan. Pilih menu File | New | Other
untuk menampilkan item yang baru pada saat projek dimulai.
Halaman tabulasi Repository berisi objek-
objek forms, frames, units, dan wizards
untuk menciptakan item tertentu.
Ketika menciptakan item yang berasal
dari Object Repository, item tersebut
dapat disalin, diturunkan (inherit)
atau dimanfaatkan:
Copy (default) menciptakan salinan

item dalam suatu projek. Inherit berarti
merubah menjadi objek dalam
Repository yang diturunkan dari salah
satu item dalam suatu projek. Use
berarti mengubah objek di dalam
projekyang diturunkan dari objek
dalam Repository.

Gambar 8.9 Object Repository
Untuk mengedit dan membuang objek dari Object Repository, pilih Tools | Repository atau klik
kanan dalam kotak dialog item yang baru dan pilih Properties.
Halaman tabulasi Repository dapat

ditambahkan, dihapus, atau diberi nama baru.
Klik panah untuk merubah urutan halaman

tabulasi yang Nampak dalam kotak dialog.
Gambar 8.10 Kotak dialog untuk pengesetan Object Repository
8.4.4 Code Editor

Ketika disain antar muka dilakukan dalam suatu aplikasi, Delphi membangkitkan teks programnya.
Pada saat property formulir atau objek dipilih dan diubah, teks program asli secara otomatis
berubah merefleksikan perubahan tadi. Teks program dapat ditambahkan secara langsung dalam
Code editor, yang sepenuhnya berupa editor ASCII. Delphi memberikan alat bantu untuk membantu
penulisan program, meliputi Code Insight tools, class completion, dan code browsing.
Komponen yang
ditambahkan ke formulir
direfleksikan dalam teks
Teks program yang program
dibangkitkan.
Gambar 8.11 Editor teks program
Tabel 8.1 Cara kerja kelengkapan editor teks program
Tool Cara Kerja
Code completion Ketik nama klas dengan diikuti titik (.) untuk menampilkan
daftar properties, methods, dan events yang sesuai dengan
kals tersebut, pilih salah satut, dan tekan tombol Enter.

Tool Cara Kerja
Dalam bagian interface dari suatu teks program dapat

dipilih lebih dari satu item. Ketik suatu pernyataan awal
assignment dan tekan Ctrl+space untuk menampilkan daftar
nilai yang valid untuk suatu variable. Ketik suatu nama
prosedur, fungsi, atau metode untuk menampilkan ke
permukaan daftar arguments
Code parameters Ketik nama metode dan buka parenthesis untuk
menampilkan syntax dari argument metode.
Tooltip expression evaluation Selagi suatu program menunggu selama proses debugging,
tandai pada beberapa variabel untuk menampilkan nilai saat
itu.
Tooltip symbol insight Ketika pengeditan teks program, tandai beberapa identifier
untuk menampilkan dekalrasinya.
Code templates Tekan tombol Ctrl+J untuk melihat pernyataan pemrograman
yang sering digunakan yang dapat disisipkan dalam teks
program saat itu. Templet ini dapat dibuat dan ditambahkan
ke Delphi.
Dengan code completion, ketika diketikkan titik (.)
Di Button1 Delphi menampilkan daftar properties, methods, dan events dari

.
klas. Daftar tersebut akan secara otomatis memfilter dirinya sesuai dengan
huruf yang diketikkan,. Pilih item dalam daftar dan tekan tombol Enter
untukmenanmbahkannya dalam teks program.
Procedures dan properties berwarna teal dan fungsi berwarna biru.
Daftar tersebut dapat diurutkan dengan klik kanan dan klik Sort by
Name.
Simbol tooltip yang terlihat menunjukkan informasi deklarasi untuk beberapa identifier
dan muncul pada saat pointer tetikus melewatinya.
Gambar 8.12 Contoh dan pilihan dalam alat bantu code

completion
8.4.5 Menjelajah Teks Program

Dengan menekan tetikus di atas nama klas, variabel, property, method, atau identifier lainnya, menu pop-
up memanggil symbol Tooltip dan menampilkan letak ditampilkannya suatu identifier. Dengan menekan Ctrl
dan cursor terfokus pada suatu identifier, teks identifier tersebut berubah menjadi biru dengan garis
bawah, dan jika di klik akan loncat menuju definisi identifier tersebut.

Editor teks program memiliki tombol ke depan dan belakang seperti yang dimiliki browser Web. Pada
saat loncat menuju definisi, teks editor tetap menjaga trek sesuai dengan identifier yang dikehendaki.
Kita dapat mengklik tombol ini untuk menuju ke depan dank e belakang dari sejarah referensi yang
tersedia.
Tekan tombol Ctrl dan klik atau klik kanan dan klik
Find Declaration untuk loncat menuju definisi suatu
identifier.
Editor teks program akan memelihara daftar definisi

yang dituju tadi.
Klik panah balik untuk masuk

kembali ke tempat terakhir ketika
teks program sebelum di klik. Dan
klik kedepan untuk bergerak
kedepan lagi.
Gambar 8.13 Menjelajah teks program dalam editor
8.4.6 Halaman Diagram

Pada bagian bawah editor teks program berisi satu atau beberapa tabulasi, tergantung pada edisi
Delphi yang diinstal. Halam teks program, tempat teks program dituliskan, tampil di bagian depan
sebagai status default. Halaman Diagram menampilkan icon dan garis hubung yang
merepresentasikan keterkaitan antara komponen-komponen yang ditempatkan dalam formulir
atau data module. Keterkaitan ini meliputi persaudaraan (siblings), bapak-anak, atau komponen
terhadap properties.
Untuk membuat diagram, klik halaman Diagram. Dari Object TreeView, drag satu atau beberapa
icon ke dalam halaman Diagram agar tersusun secara vertical. Untuk penyusunan secara horizontal,
tekan Shift sambil melakukan dragging. Pada saat didrag suatu icon dengan keterkaitan bapak-
anak atau komponen-property, maka secara otomatis garis atau garis penghubung tergambarkan
dan merefleksikan hubungan keterkaitannya. Contohnya, jika ditambahkan sekumpulan
komponen ke dalam data module dan men-drag icon dataset beserta icon propertynya ke dalam
halaman Diagram, konektor yang menghubungkan antara icon property dan icons dataset
terbentuk secara otomatis.
Untuk sejumlah komponen yang tidak memiliki ketergantungan keterkaitan tetapi tetap ingin
ditampilkan, dapat digunakan tombol toolbar yang terletak di atas halaman Diagram untuk
menambahkan empat jenis konektor yang meliputi allude, property, master/detail, dan lookup.
Kotak komentar juga dapat ditambahkan untuk menghubungkan icon satu dengan lainnya yang
relevan.
Diagram tersebut dapat diberi nama dan keterangan, disimpan, kemudian dicetak.

Dari Object TreeView, drag Untuk menampilkan diagram lainnya dalam
icons komponen-komponen ke projek ini, klik drop-down list box.
dalam halaman Diagram.
Ketikkan nama dan keterangan untuk
diagram yang dibuat Penggunaan halaman Diagram
Tombol toolbar—Property,
Master/Detail and Lookup—
untuk mendisain keterkaitan
antara komponen
properties. Tampilan garis

hubung beragam tergantung
jenis keterkaitannya.
Klik kotak komentar untuk

menambahkan keterangan,
dan tombol konektor Allude
untuk menarik garis
konektor antara komentar
dan icon.
Gambar 8.14 Penggunaan halaman Diagram
8.4.7 Tampilan Teks Program Formulir

Formulir merupakan bagian yang tampak di sebagian besar projek Delphi, tempat perancangan
antar muka suatu aplikasi. Biasanya, kita merancang formulir dengan memanfaatkan alat bantu
visual Delphi, dan Delphi menyimpan formulir tersebut dalam file formulir. File formulir (.dfm, atau
.xfm untuk aplikasi CLX) menggambarkan semua komponen dalam formulir, meliputi nilai semua
wujud (persistent) propertinya. Untuk menampilkan dan mengedit file formulir dalam editor teks
program, klik-kanan formulir dan pilih View as Text. Untuk kembali ke tampilan grafis, klik-kanan
dan pilih View as Form.
Gambar 8.15 Penggunaan View As Text untuk menampilkan keterangan teks formulir ke editor
8.4.8 Code Explorer

Ketika Delphi dijalankan, Code Explorer ditempatkan di sisi kiri jendela editor teks program. Code
Explorer menampilkan daftar isi source teks program yang ada di dalam editor, daftar tipe, klas,
properti, methods, variabel global, dan routines yang didefinisikan dalam unit. Juga ditampilkan
daftar unit-unit lain yang disebutkan dalam ketentuan uses.
Code Explorer dapat digunakan untuk navigasi editor teks program. Misalkan, jika dilakukan
double-klik pada method dalam Code Explorer, kursor melompat ke definisi dalam deklarasi
klasnya di dalam bagian antar muka unit di editor.

Double-klik item dalam Code
Explorer, maka kursor bergerak
menuju implementasi item' di
dalam Code editor. Tekan
Ctrl+Shift+E untuk mengembalikan
kursornya di posisi Code Explorer
sebelumnya.
Gambar 8.16 Cara kerja Code Explorer
8.4.9 Manajer Projek dan Browser

Ketika Delphi dijalankan, akan secara otomatis membangkitkan projek baru. Suatu projek terdiri
dari beberapa file untuk membangun suatu aplikasi yang dikembangkan. Tempat untuk melihat
dan mengorganisasi file—seperti file- file formulir, unit, resource, objek, dan library— ini disebut
Project Manager. Project Manager dapat digunakan untuk menggabungkan dan menampilkan
informasi yang terkait projek ke dalam project group tunggal. Dengan mengorganisasi projek yang
terkait dalam satu grup, dapat dilakukan proses kompilasi pada saat bersamaan.
Gambar 8.17 Dialog manajer projek
Sedangkan Project Browser meniti projek secara teliti. Browser menampilkan classes, units, dan
symbol global (types, properties, methods, variables, and routines) dalam suatu projek yang
dideklaraskan atau digunakan dalam tree diagram.
Project Browser memiliki dua ruang: ruang Inspector (di

sisi kiri) dan ruang Detail. Sisi Inspector memiliki tabulasi
globals, classes, dan units.
Globals menampilkan classes, types, properties,

methods, variables, dan routines.
Classes menampilkan kals-klas dalam diagram hierarkis.
Units menampilkan units, identifiers yang dideklarasikan

pada setiap unit, dan unit-unit lain yang menggunakan
dan digunakan oleh unit lainnya.
Gambar 8.18 Dialog Project Browser

9 CARA MEMROGRAM DENGAN DELPHI
9.1 Tujuan
1. Memberikan pengenalan memrogram untuk pengembangan perangkat lunak dengan Delphi;
meliputi menciptakan projek, bekerja dengan formulir, menuliskan teks program, dan
mengkompilasi, mendebug, mengembangkannya.
9.2 Menciptakan projek

Projek terdiri atas sekumpulan file yang dibuat saat design time atau dibangkitkan pada saat
mengkompilasi suatu projek. Saat Delphi mulai dijalankan, satu projek akan terbuka. Projek
tersebut secara otomatis menciptakan file (Project1.dpr), file unit (Unit1.pas), dan file resource
(Unit1.dfm; Unit1.xfm unuk aplikasi CLX), disamping yang lainnya.
Jika sudah ada projek yang terbuka tetapi masih diinginkan projek lain yang baru, dapat dipilih File
| New | Application atau File | New | Other dan double-click icon Application. File | New | Other
akan membuka Object Repository, yang menyediakan formulir, modules, and frames tambahan
sebagaimana templet pradesain pada kotak dialoguntuk menambahkan projek.
9.2.1 Adding data modules

Data module adalah sejenis formulir yang hanya berisi komponen tak tampak (nonvisual). Memang
komponen nonvisual dapat ditempatkan dalam formulir umumnya. Tetapi data module ini akan
memberikan alat pengorganisasian yang mencukupi bila diinginkan pemanfaatan sekumpulan
objek database dan system atau jika diinginkan untuk mengisolasi bagian aplikasi untuk
menghandel koneksi ke database dan kaidah bisnis.
Untuk menciptakan data module, pilih File | New | Data Module. Delphi akan membuka data module
kosong, yang ditampilkan sebagai sebuah file unit tambahan dalam module tersebut, dan
menambah module ke dalam project tersebut sebagai unit baru.
Double-click komponen nonvisual

dalam Palet Komponen untuk
meletakkan komponen tersebut
dalam data module.
Gambar 9.1 Contoh Data Module yang berisi komponen nonvisual
9.3 Membangun Antar Muka Aplikasi

Dengan Delphi, pertama menciptakan antar muka dengan memilih komponen dari palet komponen
dan menempatkannya ke dalam formulir utama.
9.3.1 Menempatkan Komponen di dalam Formulir

Menempatkan komponen di dalam formulir dapat dilakukan dengan salah satu cara berikut:

1. Double-klik komponen, atau
2. Klik komponen sekali dan kemudian klik formulir di tempat komponen yang diinginkan akan
terlihat.
Klik komponen di dalam palet komponen.
Kemudian klik di tempat yang diinginkan di atas formulir.

Atau pilih
komponen yang
terurut secara
abjad
Gambar 9.2 Cara menempatkan komponen di atas formulir
9.3.2 Pengesetan Properti Komponen

Setelah menempatkan komponen dalam formulir, pengesetan properti dan penulisan teks program
event handlers dapat dilakukan. Pengesetan properti komponen merubah cara komponen tampil
dan berperilaku dalam aplikasi. Ketika komponen dipilih di atas formulir, properties dan events-
nya akan ditampilkan dalam Object Inspector.
Beberapa properti memiliki nilai sederhana—seperti nama warna, True or False, dan integer.
Untuk properti Boolean dapat dilakukan dengan cara double-klik kotak (toggle) kata antara True
dan False. Beberapa properti memiliki kaitan dengan editor properti untuk melakukan pengesetan
nilai yang lebih kompleks. Ketika diklik nilai propertinya, akan tampak tanda/tombol ellipsis.
Ketika lebih dari satu komponen yang dipilih dalam formulir, Object Inspector akan menampilkan
semua properti yang sama (shared) dari komponen terpilih tersebut
Double-klik di sini
untuk merubah nilai
dariTrue ke False.
Klik ellipsis untuk
menampilkan editor
properti untuk
properti tersebut.
Klik pada panah-bawahuntuk memilih dari

daftar nilai yang valid.

Object Inspector juga mendukung referensi komponen inline yang diperluas. Hal itu dapat
memberikan akses ke properties dan events suatu komponen yang menjadi referensinya tanpa
perlu harus memilih komponen referensinya sendiri secara langsung. Contohnya, jika ditambahkan
komponen button dan menu ke dalam formulir, ketika memilih komponen button, dalam Object
Inspector kita dapat mengeset properti Popup Menu ke PopupMenu1, yang menampilkan semua
properti pop-up menu ketikan tanda + diklik.
Properti PopupMenu komponen Button diset ke

PopupMenu1, dan semua properti popup
menu's tampil ketika tanda (+) diklik.
Referensi component Inline berwarna merah

dan subpropertinya berwarna hijau are colored
green.
Gambar 9.3 Referensi komponen dalam objek Inspektor
9.4 Penulisan Teks Program

Bagian integral dari aplikasi adalah teks program dibalik setiap komponen. Disamping diberikan
blok-blok teks program, seperti komponen visual dan nonvisual preinstalled oleh lingkungan
pemrograman Delphi, seringkali diperlukan penulisan event handlers, methods, dan mungkin
beberapa klas yang kita definisikan sendiri. Untuk membantu pekerjaan ini , kita dapat memilih
dari ratusan objek di dalam kamus klas.
9.4.1 Penulisan Event Handlers

Teks program kadang memerlukan respon terhadap event yang dapat terjadi pada komponen pada
saat kondisi runtime. Event adalah kaitan antara suatu kejadian dalam sistem, seperti meng-klik
tombol, dan serangkali teks program diperlukan untuk merespon kejadian tadi. Teks program yang
merespon ini disebut event handler. Teks program ini akan memodifikasi nilai properti dan
pemanggilan methodnya.
Untu menampilkan event handlers suatu komponen dalam formulir, pilih Component dan, dalam
Object Inspector, klik tabulasi Events.
Di sini, Button1 dipilih dan tipenya tertampil: TButton. Klik tabulasi
Eventsdi dalam Object Inspector untuk melihat events yang komponen
Button tersebut dapat menghandelnya.
Pilih event handler yang tersedia dari

drop-down list. Atau double-klik dalam
kolom nilai, dan Delphi akan
membangkitkan teks program skeleton
untuk event handler yang baru.

9.4.2 Using the component library
Delphi berisi kamus komponen yang membangun objek, beberapa diantaranya juga komponen atau
controls, yang digunakan pada saat penulisan teks program. Komponen VCL dapat digunakan untuk
aplikasi Windows dan komponen CLX untuk aplikasi Windows dan Linux. Kamus komponen terdiri
dari objek-objek yang tampak pada runtime,—seperti edit controls, buttons, dan elemen antar
muka pengguna lainnya—demikian juga kontrol-kontrol nonvisual seperti datasets dan timers.
Diagram berikut menggambarkan beberapa klas utama yang membangun hierarki VCL (juga CLX).
Gambar 9.4 Hirarki klas dalam Delphi
Objek menurunkan TComponent yang memiliki properties dan methods yang membolehkannya
diinstal dalam palet komponen dan ditambahkan dalam formulir Delphi atau data modules. Karena
komponen disisipkan dalam IDE, kita dapat memanfaatkan tool seperti Form Designer untuk
mengembangkan aplikasi dengan cepat.
Komponen adalah sangat encapsulated (terbungkus). Contohnya, buttons diprogram untuk
merespon klik tetikus dengan menyulut OnClick events. Jika digunakan control button, maka tidak
perlu lagi menuliskan teks program untuk menangani kejadian yang dibangkitkan ketika button
diklik; kita hanya bertanggung jawab terhadap logika aplikasi yang berjalan dalam merespon
kejadian klik itu sendiri.
9.5 Kompilasi dan pendebugan Projek

Setelah teks program dituliskan, dalam projek perlu dilakukan proses kompilasi dan debug. Projek
dapat dikompilasi dahulu lalu didebug secara terpisah, atau dikompilasi dan sekaligus didebug
dalan satu tahap dengan menggunakan debugger yang terintegrasi. Untuk mengkompilasi program
dengan informasi debug, pilih Project | Options, klik halaman Compiler, dan pastikan Debug
information harus dicentang (checked).
Delphi memanfaatkan debugger terintegrasi, sehingga eksekusi program dapat dikendalikan,
mengamati variables, dan memodifikasi nilai data. Dapat juga dilakukan langkah demi langkah
untuk setiap baris pernyataan teks program, menilai keadaan program pada setiap breakpoint.

Untuk menggunakan debugger terintegrasi, pilih Tools | Debugger Options, klik General page, dan
pastikan Integrated debugging telah dicentang. Kita juga dapat memulai sesi pendebugandalam IDE
dengan mengklik tombol Run pada toolbar Debug, pilih Run | Run, atau tekan F9.
Pilih beberapa perintah untuk

pendebugan dari menu Run.
Beberapa perintah juga tersedia
dalam toolbar.
Tombol Run
Gambar 9.5 Akses ke perintah debug program
Dengan debugger terintegrasi, beberapa jendela debugging tersedia, meliputi Breakpoints, Call
Stack, Watches, Local Variables, Threads, Modules, CPU, and Event Log. Untuk menampilkan pilih
View | Debug Windows. Tidak semua tampilan debugger tersedia dalam semua edisi Delphi.
Gambar 9.6 Penggabungan debugging dapat dilakukan dengan mudah

10 DATA TYPE, VARIABEL, DAN KONSTANTA DELPHI
Ada beberapa cara mengelompokkan type dalam objek Pascal, diantaranya:
 type yang telah didefinisikan sebelumnya (built-in); kompiler akan mengenali secara otomatis
tanpa perlu mendeklarasikannya. Hampir seluruh type yang terdokumentasi adalah jenis ini.
Beberapa type dibentuk dengan deklarasi, yaitu terd iri dari type yang didefinisikan-pengguna
dan type yang didefinisikan dari produk suatu kamus.
 Type dapat dikelompokkan sebagai dasar atau generic. Range dan format type dasar memiliki
implementasi yang sama dalam objek Pascal dengan mengabaikan CPU dan system operasinya.
Sedangkan type generic merupakan platform khusus dan dapat berbeda implementasinya.
Hampir semua type adalah dasar, tetapi type integer, character, string, dan pointer adalah
generic. Ide bagus jika menggunakan type generic untuk memberikan kinerja dan portability
yang optimal. Kadang, merubah format type sederhana di dalam penyimpan dari implementasi
type generic ke selanjutnya menyebabkan masalah kompabilitas, contohnya streaming data
menjadi file.
 Type dapat diklasifikasikan sebagai sederhana, terstruktur, pointer, procedural, atau varian.
Sebagai tambahan, type identifier sendiri dapat dipandang sebagai memiliki “type” tertentu
karena mereka dapat dilewatkan sebagai parameter ke suatu fungsi tertentu (seperti High, Low,
and SizeOf).
Outline di bawah ini menunjukkan taksonomi type dalam Object Pascal.
simple
ordinal
integer
character
Boolean
enumerated
subrange
real
string
structured
set
array
record
file
class
class reference
interface
pointer
procedural
variant
type identifier
Fungsi standar SizeOf dapat diterapkan pada semua variabel dan type. Fungsi tersebut
mengirimkan nilai integer yang menunjukkan jumlah memori (byte) yang digunakan untuk

menyimpan data type tersebut. Contoh, SizeOf (Longint) bernilai 4 artinya satu variabel Longint
menggunakan memory empat byte.
10.1 Type Sederhana

Type sederhana terdiri dari type ordinal dan real.
10.1.1 Type Ordinal

Type ordinal meliputi type integer, character, Boolean, enumerated, and subrange. Type ini
mendefinisikan urutan himpunan nilai yang memiliki nilai unik untuk predesesornya (kecuali
urutan pertama) dan nilai unik untuk suksesornya (kecuali urutan terakhir). Jika suatu nilai
memiliki urutan dalam n, maka suksesornya adalah urutan n+1 dan predesesornya urutan n-1.
Fungsi yang digunakan:
Fungsi Parameter Nilai yang dikirimkan Keterangan
Ord Ekspresi ordinal Mengekspresikan nilai Tidak digunakan untuk type
ordinal int64
Pred Ekspresi ordinal Predesesor dari nilai Jangan digunakan untuk properti
ekspresinya yang memiliki prosedur write
Succ Ekspresi ordinal Suksesor dari nilai Jangan digunakan untuk properti
ekspresinya yang memiliki prosedur write
High Variabel type ordinal Nilai tertinggi dari type Dapat diterapkan pada type
Variabel type ordinal short string dan array
Low Variabel type ordinal Nilai terendah dari type Dapat diterapkan pada type
Variabel type ordinal short string dan array
10.1.1.1 Type Integer

Type integer generik diimplemntasikan dalam 32-bit, ada dua Intege dan Cardinal. Gunakan type generic
ini untuk memberikan kinerja CPU yang lebih baik.
Type Range Format
Integer –2147483648.. 2147483647 32-bit bertanda
Cardinal 0..4294967295 32-bit tak bertanda
Type integer dasar terdiri dari Shortint, Smallint, Longint, Int64, Byte, Word, dan Longword.
Type Range Format
Shortint –128..127 8-bit bertanda

Smallint –32768..32767 16-bit bertanda
Longint –2147483648..2147483647 32-bit bertanda
Int64 –263..263–1 64-bit bertanda
Byte 0..255 8-bit tak bertanda
Word 0..65535 16-bit tak bertanda
Longword 0..4294967295 32-bit tak bertanda
10.1.2 Type Real

Type real menyatakan himpunan angka-angka yang dapat direpresentasikan dengan notasi floating-
point. Tabel di bawah ini menampilkan range dan format penyimpan dari type real dasar.
Type Range Ketelitian Digit Ukuran(byte)
Real48 2.9 x 10–39 .. 1.7 x 1038 11-12 6
Single 1.5 x 10–45 .. 3.4 x 1038 7-8 4
Double 5.0 x 10–324 .. 1.7 x 10308 15-16 8
Extended 3.6 x 10–4951 .. 1.1 x 104932 19-20 10
Comp –263+1 .. 263 –1 19-20 8
Currency –922337203685477.5808.. 19-20 8

922337203685477.5807
Real 5.0 x 10–324 .. 1.7 x 10308 15-16 8

11 MENULIS PROGRAM HELLO
Dalam bagian ini akan dijelaskan beberapa program “Hello” mulai dari aplikasi sederhana, yaitu yang
memanfaatkan console sampai beberapa pengenalan fungsi kotak dialog.
11.1 Langkah demi Langkah Program Hello -1

Jalankan aplikasi Delphi dan tutup semua projek yang aktif pada saat itu. Dari Menu utama File | New |
Other akan muncul kotak dialog berikut, pilih Console Application dan tekan tombol OK.
Dalam teks editor program tertulis nama program Project1 dengan jenis aplikasi console. Terdapat suatu
remark, yaitu teks yang berwarna hijau dalam tanda kurung kurawal buka dan tutup. Pada bagian ini
akan digantikan dengan instruksi program berikut:

Kemudian tekan kunci F9 untuk menjalankan program, akan tertampil seperti berikut:

12 20 KAIDAH UNTUK OOP DI DELPHI1
Kebanyakan pemrogram Delphi menggunakan lingkungan pengembangan mereka karena
mereka yang akan menggunakan Visual Basic [Editor menyerah dan ngeri membayangkannya
saja], tanpa menyadari dan mengambil keuntungan dari daya yang mereka miliki di tangan
mereka!. Delphi didasarkan pada arsitektur berorientasi objek, yang tidak hanya pada dampak
struktur VCLnya tetapi juga setiap aplikasi Delphi.
Pada artikel ini saya tidak ingin menutup teori OOP, tetapi hanya menyarankan beberapa
aturan sederhana yang dapat membantu Anda memperbaiki struktur program Anda. Aturan-
aturan praktis harus dianggap sebagai saran, untuk diterapkan atau tidak tergantung pada jenis
aplikasi yang sebenarnya Anda sedang kembangkan. Saran saya hanya untuk menjaga mereka
dalam pikiran.
Prinsip kunci yang saya ingin menggarisbawahi adalah enkapsulasi. Kami ingin menciptakan
kelas yang fleksibel dan kuat, yang akan memungkinkan kita untuk mengubah pelaksanaan
nanti tanpa mempengaruhi sisa program. Ini bukan satu-satunya kriteria untuk OOP yang baik,
tapi mewakili yayasan, jadi jika aku benar-benar over-stress itu dalam artikel ini saya memiliki
beberapa alasan baik untuk melakukannya.
Akhirnya, untuk menggarisbawahi fakta bahwa prinsip-prinsip ini harus digunakan dalam
pekerjaan sehari-hari kita dengan kita semua programmer Delphi, aku akan fokus terutama
pada pengembangan bentuk, bahkan jika beberapa peraturan yang sama berlaku untuk
pengembangan komponen. Mereka yang menulis komponen harus mempertimbangkan OOP
dan kelas sebagai elemen pusat. Mereka yang menggunakan komponen pada kali lupa tentang
OOP: artikel ini dapat dianggap sebagai pengingat.
12.1 Bagian 1: Formulir Adalah Kelas

Seorang pemrogram Kelas biasanya memperlakukan bentuk sebagai obyek, sementara pada
kenyataannya mereka kelas. Perbedaannya adalah bahwa Anda dapat memiliki beberapa
1
Marco Cantu, 20 RULES FOR OOP IN DELPHI, The Delphi Magazine, July 1999

bentuk objek berdasarkan kelas bentuk yang sama. Yang membingungkan adalah bahwa Delphi
menciptakan obyek global default untuk setiap kelas formulir yang Anda tetapkan. Hal ini
tentunya berguna bagi pendatang baru, namun dapat berubah menjadi kebiasaan buruk.
12.1.1 Aturan 1: Satu Kelas, Satu Unit

Selalu ingat bahwa bagian private dan protected dari sebuah class yang tersembunyi hanya
untuk kelas dan pro-cedures di unit lain. Oleh karena itu, jika Anda ingin memiliki enkapsulasi
efektif, Anda harus menggunakan unit yang berbeda untuk setiap kelas. Untuk kelas sederhana,
mewarisi satu dari yang lain, Anda benar-benar dapat menggunakan unit bersama, tetapi hanya
jika jumlah kelas terbatas: Jangan menempatkan kelas 20-hirarki yang kompleks dalam satu
kesatuan, bahkan jika Borland melakukannya di kode sumber VCL ...
Jika Anda berpikir tentang bentuk, Delphi berikut kelas satu ', satu unit' prinsip secara default,
yang tentu saja berguna. Ketika menambahkan bentuk non-kelas untuk proyek, membuat unit
terpisah baru.
12.1.2 Aturan 2: Komponen Nama

Hal ini sangat penting untuk memberikan nama-ingful berarti untuk setiap bentuk dan setiap
unit. Sayangnya kedua nama harus berbeda, meskipun saya cenderung menggunakan nama
yang mirip untuk dua, seperti AboutForm dan About.pas.
Sangat penting untuk menggunakan nama deskriptif untuk komponen juga. Notasi yang paling
umum adalah dengan menggunakan huruf kecil beberapa huruf awal untuk jenis kelas, diikuti
oleh peran komponen, seperti dalam btnAdd atau editName. Sebenarnya ada banyak notasi
mirip gaya berikut ini dan ada benar-benar ada alasan untuk mengatakan salah satu dari
mereka adalah yang terbaik, terserah selera pribadi Anda.
12.1.3 Peraturan 3: Nama Acara

Hal ini bahkan lebih penting untuk memberikan nama yang tepat untuk metode penanganan
event. Jika Anda nama komponen dengan benar, nama default Button1Click, misalnya,
menjadi btnAddClick. Meskipun kita bisa menebak apa yang metode tidak dari nama
tombol, saya pikir itu adalah cara yang lebih baik untuk menggunakan nama yang
menggambarkan pengaruh metode, bukan komponen terpasang. Misalnya, event OnClick
dari tombol btnAdd dapat diberi nama AddToList. Hal ini membuat kode lebih mudah

dibaca, terutama ketika Anda menelepon pengendali event dari metode lain kelas, dan
membantu pengembang melampirkan metode yang sama untuk beberapa peristiwa atau
komponen yang berbeda, meskipun saya harus mengatakan bahwa Tindakan menggunakan
pilihan saat ini pilihan saya untuk program non-trivial (sepele).
12.1.4 Aturan 4: Gunakan Metode Formulir

Jika bentuk adalah kode kelas mereka dikumpulkan dalam metode. Selain pengendali event,
yang memainkan peran khusus tetapi masih dapat disebut sebagai metode lainnya, seringkali
sangat berguna untuk menambah metode kustom untuk membentuk kelas. Anda dapat
menambahkan metode-metode melakukan tindakan dan mengakses ke status formulir. Adalah
jauh lebih baik untuk menambahkan metode umum untuk bentuk daripada membiarkan
bentuk-bentuk lain beroperasi pada komponen secara langsung.
12.1.5 Aturan 5: Tambahkan Konstruktor Formulir

Bentuk sekunder dibuat pada saat runtime dapat menyediakan konstruktor spesifik lain selain
default (mewarisi bentuk kelas TComponent). Jika Anda tidak perlu compatibility dengan versi
Delphi sebelum 4, saran saya adalah metode create overload, menambahkan parameter
inisialisasi yang dibutuhkan, lihat contoh gambar 12.1.
Gambar 12.1 Menambahkan konstuktor formulir
public
constructor Create (Text: string); reintroduce; overload;
constructor TFormDialog.Create(Text: string);
begin
inherited Create (Application);
Edit1.Text := Text;
end;
12.1.6 Aturan 6: Hindari Global Variabel

Global variabel (yaitu, variabel dideklarasikan di bagian interface unit) harus dihindari. Berikut
adalah beberapa saran untuk membantu Anda melakukan hal ini.
Jika Anda memerlukan penyimpanan data tambahan untuk membentuk, tambahkan beberapa
bidang swasta untuk itu. Dalam hal ini setiap contoh formulir akan memiliki salinan sendiri dari
data.
Anda dapat menggunakan variabel unit (dideklarasikan di bagian implementation dari

unit) untuk data dibagi di antara beberapa contoh bentuk kelas.

Jika Anda membutuhkan data dibagi di antara bentuk dari berbagai jenis, Anda dapat berbagi
mereka dengan menempatkan data dalam bentuk utama, atau dalam sebuah objek global, dan
menggunakan metode atau properti untuk mengakses data.
12.1.7 Aturan 7: Jangan Gunakan Form1 Dalam TForm1

Anda tidak harus merujuk pada objek tertentu dalam metode kelas obyek tersebut. Dengan
kata lain, tidak pernah merujuk ke Form1 dalam metode kelas TForm1. Jika Anda perlu
mengacu pada objek saat ini, gunakan kata kunci diri. Perlu diingat bahwa sebagian besar
waktu ini tidak diperlukan, karena Anda dapat merujuk langsung ke metode dan data dari objek
saat ini.
Jika Anda tidak mengikuti aturan ini, Anda akan mendapatkan masalah ketika Anda membuat
beberapa contoh formulir.
12.1.8 Aturan 8: Jarang Gunakan Form1 Dalam Formulir Lain

Bahkan dalam kode bentuk lain, cobalah untuk menghindari referensi langsung ke obyek global,
seperti Form1. Adalah jauh lebih baik untuk mendeklarasikan variabel lokal atau field
private untuk merujuk ke bentuk lain.
Misalnya, bentuk utama dari sebuah program dapat memiliki field private mengacu pada
kotak dialog. Jelas aturan ini menjadi sangat penting jika Anda berencana membuat beberapa
contoh bentuk sekunder. Anda dapat menyimpan daftar dalam bidang bentuk utama, atau
hanya menggunakan array Form dari objek Screen global.
12.1.9 Peraturan 9: Hapus Form1

Sebenarnya, saran saya adalah untuk menghapus bentuk global obyek yang secara otomatis
ditambahkan oleh Delphi untuk program ini. Ini adalah pos-an hanya jika Anda menonaktifkan
penciptaan auto-matic dari bentuk (lagi ditambahkan oleh Delphi), sesuatu yang saya sarankan
Anda harus menyingkirkan pula.
Saya berpikir bahwa menghapus objek bentuk global sangat berguna bagi pendatang baru
Delphi, yang kemudian tidak akan bingung antara kelas dan objek global lagi. Bahkan, setelah
obyek global telah dihapus, setiap referensi untuk kemudian akan berakibat pada kesalahan.

12.1.10 Peraturan 10: Tambahkan Properties Formulir
Seperti yang sudah disebutkan, ketika Anda membutuhkan data untuk formulir, tambahkan
bidang swasta. Jika Anda perlu untuk mengakses data dari kelas lain, kemudian tambahkan
properti untuk form. Dengan pendekatan ini, Anda akan dapat mengubah kode dari formulir
dan data perusahaan (termasuk user interface-nya) tanpa harus mengubah kode bentuk lain
atau kelas.
Anda juga harus menggunakan properti atau metode untuk menginisialisasi suatu bentuk
sekunder atau kotak dialog, dan untuk membaca keadaan akhir. inisialisasi juga dapat dilakukan
menggunakan konstruktor, seperti telah saya jelaskan.
12.1.11 Peraturan 11: Paparkan Properties Komponen

Bila Anda perlu mengakses status bentuk lain, Anda tidak harus merujuk langsung kepada-nents
komponen nya. Ini akan mengikat kode bentuk lain atau kelas ke antarmuka pengguna, yang
merupakan salah satu melakukan perbaikan por-aplikasi yang tunduk pada perubahan yang
paling. Sebaliknya, menyatakan bentuk properti dipetakan ke properti komponen: ini dilakukan
dengan metode yang membaca Dapatkan status komponen dan metode Set yang menulis itu.
Misalkan sekarang Anda mengubah antarmuka pengguna, mengganti komponen dengan yang
lain. Yang harus Anda lakukan adalah memperbaiki dan Set Dapatkan metode yang terkait
dengan properti itu, Anda tidak perlu memeriksa dan memodifikasi kode sumber dari semua
bentuk dan kelas yang merujuk pada komponen itu. Anda dapat melihat contoh pada gambar
12.2.
Gambar 12.2 Dapat ditambahkan satu properti ke formulir untuk menyatakan properti/sifat komponen
private
function GetText: String;
procedure SetText(const Value: String);
public
property Text: String read GetText write SetText;
function TFormDialog.GetText: String;
begin
Result := Edit1.Text;
end;
procedure TFormDialog.SetText(const Value: String);
begin
Edit1.Text := Value;
end;

12.1.12 Peraturan 12: Properties Array
Jika Anda perlu menangani serangkaian nilai-nilai dalam bentuk, Anda dapat mendeklarasikan
array properti. Dalam hal ini merupakan informasi yang penting untuk membentuk Anda dapat
membuat juga properti array default formulir, sehingga Anda dapat langsung mengakses nilai
dengan menulis SpecialForm[3].
Gambar 12.3 menunjukkan bagaimana Anda dapat mengekspos item dari listbox sebagai
properti array default formulir hosting.
Gambar 12.3 Definisi satu array property yang default di dalam formulir
type
TFormDialog = class(TForm)
private
ListItems: TListBox;
function GetItems(Index: Integer): string;
procedure SetItems(Index: Integer; const Value: string);
public
property Items[Index: Integer]: string read Get Items write SetItems; default;
end;
function TFormDialog.GetItems(Index: Integer): string;
begin
if Index >= ListItems.Items.Count then
raise Exception.Create('TFormDialog: Out of Range'); Result := ListItems.Items [Index];
end;
procedure TFormDialog.SetItems(Index: Integer; const Value: string);
begin
if Index >= ListItems.Items.Count then
raise Exception.Create('TFormDialog: Out of Range');
ListItems.Items [Index] := Value;
end;
12.1.13 Peraturan 13: Gunakan Side-Effects Dalam Properties

Ingat bahwa salah satu keuntungan menggunakan properti alih-alih mengakses data secara
global adalah bahwa Anda dapat menyebabkan efek samping saat menulis (atau membaca)
nilai dari properti.
Misalnya, Anda dapat menggambar langsung pada permukaan bentuk, mengatur nilai-nilai
beberapa properti, panggilan metode khusus, mengubah status dari komponen sekaligus, atau
kebakaran acara, jika tersedia.
12.1.14 Peraturan 14: Sembunyikan Komponen

Terlalu sering saya mendengar keluhan puritan OOP karena Delphi membentuk termasuk daftar
komponen pada bagian published, sebuah pendekatan yang tidak sesuai dengan prinsip
enkapsulasi. Mereka benar-benar menunjukkan sebuah isu penting, tapi kebanyakan dari

mereka tampaknya tidak menyadari bahwa solusinya adalah di tangan tanpa menulis ulang
Delphi atau mengubah bahasanya.
Komponen referensi yang Delphi menambahkan untuk membentuk dapat dipindahkan ke

bagian private, sehingga mereka tidak akan dapat diakses oleh bentuk-bentuk lainnya.
Dengan cara ini Anda dapat membuat wajib penggunaan properti dipetakan ke komponen
(lihat Aturan 11 di atas) untuk mengakses status mereka.
Jika Delphi tempat semua komponen di bagian published, hal ini karena cara bidang ini
terikat pada komponen yang dibuat dari file DFM.. Ketika Anda menetapkan nama komponen
yang melekat secara otomatis VCL objek komponen untuk referensi di formulir. Ini hanya
mungkin jika referensi adalah published, karena Delphi menggunakan RTTI dan metode
TObject untuk melakukan ini.
Jika Anda ingin memahami informasi rinci, lihat gambar 12.4, yang memiliki kode metode
SetReference kelas TComponent, yang disebut oleh InsertComponent,
RemoveComponent dan SetName.
Gambar 12.4 Teks program VCL biasa untuk menyangkutkan suatu komponen kepada acuannya di dalam fromulir
pemilik
var
Field: ^TComponent;
begin
if FOwner <> nil then begin
Field := FOwner.FieldAddress(FName);
if Field <> nil then
if Enable then
Field^ := Self
else
Field^ := nil;
end;
end;
Setelah Anda mengetahui hal ini, Anda menyadari bahwa dengan memindahkan referensi
komponen dari published ke bagian private Anda kehilangan perilaku yang otomatis.
Untuk memperbaiki permasalahan, cukup membuatnya manual, dengan menambahkan kode
berikut ini untuk setiap komponen dalam event handler OnCreate dalam bentuk:
Edit1: = FindComponent ('Edit1') as TEdit;
Operasi kedua harus Anda lakukan adalah mendaftar kelas komponen dalam sistem, sehingga
mereka RTTI informasi termasuk dalam program disusun dan dibuat mampu memanfaatkan-

sistem. Hal ini diperlukan sekali saja untuk setiap kelas komponen, dan hanya jika Anda
memindahkan semua komponen referensi jenis ini ke bagian pribadi. Anda dapat
menambahkan
panggilan ini bahkan ifit tidak diperlukan, sebagai tambahan untuk panggilan metode
RegisterClasses tidak berbahaya. Metode RegisterClasses biasanya ditambahkan
ke bagian inisialization unit hosting formulir:
RegisterClasses ([TEdit]);
12.1.15 Peraturan 15: Formulir OOP Wizard

Mengulangi dua kegiatan di atas untuk setiap komponen dari setiap bentuk pasti
membosankan dan memakan waktu. Untuk menghindari hal ini beban berlebihan, saya telah
menulis sebuah wizard sederhana yang menghasilkan baris kode untuk menambahkan program
dalam jendela kecil. Anda harus melakukan dua copy paste sederhana dan operasional untuk
masing-masing bentuk.
Sang penyihir tidak Cally automati-tempat source code di lokasi yang tepat: Aku bekerja untuk
memperbaiki ini dan Anda dapat memeriksa website saya (www.marcocantu.com) untuk versi
terbaru.
12.2 Bagian 2: Warisan

Setelah set pertama aturan yang ditujukan untuk kelas, dan terutama bentuk kelas, inilah daftar
pendek lain saran dan tips yang berhubungan dengan warisan dan warisan bentuk visual.
12.2.1 Peraturan 16: Formulir Visual Warisan

Ini adalah mekanisme yang kuat, jika digunakan dengan benar. Dari pengalaman saya, nilainya
tumbuh dengan ukuran proyek. Dalam program yang kompleks Anda dapat menggunakan
hubungan hierarki antara bentuk untuk beroperasi pada kelompok dengan bentuk
polimorfisme.
bentuk warisan Visual memungkinkan Anda untuk berbagi perilaku umum dari berbagai
bentuk: Anda dapat memiliki metode umum, properti, pengendali event, komponen, sifat
komponen, komponen pengendali event, dan sebagainya.

12.2.2 Peraturan 17: Batas Dilindungi Data
Ketika membangun sebuah hirarki kelas, beberapa programmer cenderung menggunakan
bidang terutama yang dilindungi, sebagai bidang swasta tidak dapat diakses oleh subclass. Saya
tidak akan mengatakan ini adalah selalu salah, namun jelas
terhadap enkapsulasi. The implementasi pemikiran-data yang dilindungi dibagi di antara semua
bentuk warisan, dan Anda mungkin harus memperbarui semua dari mereka dalam hal definisi
asli dari perubahan data.
Perhatikan bahwa jika Anda mengikuti aturan menyembunyikan komponen (Kaidah 14) bentuk
warisan tidak mungkin mengakses komponen swasta dari kelas dasar. Dalam bentuk warisan,
kode seperti t1.TextEdit: =''; tidak akan dikompilasi lagi. Aku dapat melihat ini tidak
mungkin menjadi sangat berguna, tapi setidaknya dalam teori itu harus dianggap sebagai hal
yang positif, tidak negatif. Jika Anda merasa ini terlalu banyak konsesi untuk enkapsulasi,
menyatakan referensi komponen di bagian dilindungi dari bentuk dasar.
12.2.3 Peraturan 18: Metode akses yang dilindungi

Adalah jauh lebih baik, sebaliknya, untuk menjaga referensi komponen di bagian private dan
menambahkan fungsi akses ke properti mereka ke kelas dasar. Jika fungsi-fungsi akses hanya
digunakan secara internal dan tidak bagian dari antarmuka kelas, Anda harus menyatakan
mereka sebagai yang dilindungi. Sebagai contoh, GetText dan metode bentuk SetText
dijelaskan dalam Kaidah 11 dapat menjadi dilindungi dan kita bisa mengakses mengedit teks
dengan menghubungi:
SetText ('');
Sebenarnya, sebagai metode tersebut dipetakan ke properti, kami hanya bisa menulis:
Teks: ='';
12.2.4 Peraturan 19: Protected Virtual Method

Titik kunci lain untuk memiliki hirarki fleksibel adalah untuk menyatakan metode virtual Anda
dapat memanggil dari kelas eksternal untuk mendapatkan polimorfisme. Jika ini merupakan
pendekatan yang umum, ini kurang sering melihat dilindungi metode virtual, yang disebut
dengan metode publik lainnya. Ini merupakan teknik penting, karena Anda dapat menyesuaikan
metode virtual dalam kelas turunan, memodifikasi perilaku objek.

12.2.5 Peraturan 20: Virtual Metode Untuk Properties
metode properti Bahkan akses dapat dideklarasikan sebagai virtual, sehingga kelas turunan
dapat mengubah perilaku properti tanpa harus mendefinisikan kembali itu. Pendekatan ini
jarang digunakan oleh VCL tapi sangat fleksibel dan kuat. Untuk mencapai hal ini, hanya
menyatakan sebagai virtual Get dan Set metode Peraturan 11. Bentuk dasar akan memiliki
properti, lihat gambar 12.5.
Gambar 12.5 Fromulir dengan properties yang diimplementasikan dengan virtual methods
type
TFormDialog = class(TForm)
procedure FormCreate(Sender: TObject);
private
Edit1: TEdit;
protected
function GetText: String; virtual;
procedure SetText(const Value: String); virtual;
public
constructor Create (Text: string); reintroduce; overload;
property Text: String read GetText write SetText;
end;
Dalam bentuk yang diwarisi kini Anda dapat mengganti metode virtual SetText, untuk
menambahkan beberapa perilaku tambahan:
procedure TFormInherit.SetText(const Value: String);
begin
inherited SetText(Value);
if Value= ‘’‘then
Button1.Enabled:= False;
end;
12.3 Teks Program (Code)

Semua fragmen kode dalam artikel ini dapat ditemukan dalam proyek contoh OopDemo,
termasuk pada disk bulan ini. Anda harus memeriksa secara khusus bentuk sekunder (dalam
unit frm2) dan yang diturunkan (di unit inher). Perhatikan bahwa untuk digunakan, pada saat
yang sama, sebuah konstruktor kustom dengan kode inisialisasi dan referensi komponen
swasta, perlu untuk mengatur properti OldCreateOrder formulir. Jika kode inisialisasi dalam
konstruktor bentuk (yang menggunakan komponen) akan dilakukan sebelum metode OnCreate
dari bentuk, yang menghubungkan referensi komponen yang sebenarnya.
Pada disk Anda juga akan menemukan paket dikompilasi versi draft pertama Form Wizard OOP,
tetapi Anda harus (mudah-mudahan) dapat menemukan versi yang lebih lengkap di website
saya.

12.4 Kesimpulan
Pemrograman di Delphi sesuai dengan prinsip-prinsip OOP yang baik adalah jauh dari jelas,
karena beberapa peraturan saya telah terdaftar sorot. Saya tidak berpikir bahwa Anda harus
mempertimbangkan semua aturan saya wajib, karena beberapa dari mereka mungkin stretch
kesabaran Anda. Aturan harus diterapkan dalam konteks yang tepat, dan menjadi semakin
penting sebagai ukuran aplikasi tumbuh, bersama dengan jumlah programer yang bekerja di
atasnya. Bahkan untuk program yang lebih kecil, namun, mengingat prinsip-prinsip OOP yang
mendasari aturan saya (enkapsulasi sebelum semua yang lain) benar-benar dapat membantu.
Tentu saja ada aturan lain praktis Anda bisa datang dengan, karena saya belum mencoba untuk
masuk ke dalam memori dan penanganan masalah RTTI, yang begitu kompleks untuk pantas
artikel tertentu.
Kesimpulan saya adalah bahwa mengikuti aturan saya sudah disorot memiliki biaya, dalam hal
kode tambahan: itu adalah harga yang Anda harus membayar untuk mendapatkan program
yang lebih fleksibel dan kuat. Ini adalah harga pemrograman berorientasi obyek. Mari kita
berharap bahwa masa depan versi Delphi membantu kami mengurangi harga itu.

DAFTAR REFERENSI
[Knuth-1971] Knuth, D.E : "The Art of Computer Programming", Vol. 3 : "Sorting and Searching",
Addison Wisley, 1971
[Liem-2007] Liem, Inggriani: “Diktat Kuliah Dasar Pemrograman: (Bagian Pemrograman
Prosedural)”, STEI-ITB, Edisi 2007
[Borland-2001] Borland: “Object Pascal Language Guide”, Borland Software Corporation, 2001
[Cantu-1999] Cantu, Marco, “20 Rules for OOP in Delphi”, The Delphi Magazine, July 1999

Modul Pemrograman (Draft)

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Modul Pemrograman (Draft)

Diunggah oleh

Hak Cipta:

Format Tersedia

Draft

Penyusunan Bahan Ajar Kurikulum Berbasis Kompetensi (Kurikulum 2007)

PROGRAM STUDI TEKNIK KONVERSI ENERGI

Bandung, 27 Agustus 2010

Sri Paryanto Mursid, MSc. Ir Teguh sasono, MT

Sri Wuryanti, MSc.

Dasar-Dasar Pemrograman-TE Polban Hlmn. iii

B. TUJUAN INSTRUKSIONAL UMUM

Dasar-Dasar Pemrograman-TE Polban Hlmn. iv

Dasar-Dasar Pemrograman-TE Polban Hlmn. viii

Dasar-Dasar Pemrograman-TE Polban Hlmn. ix

Dasar-Dasar Pemrograman-TE Polban Hlmn. x

{Spesifikasi teks algoritmik secara umum}

{Pada bagian ini, dilakukan pendefinisian nama konstanta, nama variabel,

Dasar-Dasar Pemrograman-TE Polban Hlmn. 1

1.2 Judul (Header)

Dasar-Dasar Pemrograman-TE Polban Hlmn. 2

{Nama Type, hanya untuk type yang bukan type dasar}

type Point : <X:real,Y:real>{koordinat pada sumbu kartesian}

{Nama Konstanta, harus menyebutkan type dan nilai}

constant PI: real = 3.14159

constant Ka: character = 'K'

constant Faktor: integer = 3

constant Benar: boolean = true

{Nama Informasi, menyebutkan type}

Found: boolean {Hasil pencarian, true jika ketemu}

P : Point {Posisi pena pada bidang kartesian}

CC: character {Current character}

{Spesifikasi Fungsi, menyebutkan nama fungsi, domain dan range}

function RealToInt (i:real)-> integer

{Spesifikasi Prosedur, menyebutkan Nama, parameter, Initial State (I.S.) , Final

Dasar-Dasar Pemrograman-TE Polban Hlmn. 3

F.S. Semua nama global dalam kamus terdefinisi nilainya

Proses: Menginisialisasi semua nama informasi global}

procedure Tulis (Input Pesan: string)

F.S. Pesan tertulis di layar

Proses : Menulis isi Pesan ke layar}

 instruksi dasar seperti input/output, assignmnet

Dasar-Dasar Pemrograman-TE Polban Hlmn. 4

2.1 Type Dasar

 boolean (bilangan logika)

2.1.1 Boolean/ Bilangan Logika

Domain : [true, false]

Konstanta : true, false

Operator : not, or, and, xor

Hasil operasinya dapat dilihat pada table kebenaran berikut

Dasar-Dasar Pemrograman-TE Polban Hlmn. 5

Operant Hasil operasi Operator

true true true true false

true false true false true

false true true false true

False false false false false

not true False not false true

2.1.2 Integer / Bilangan Bulat

Konstanta : 0 4 -23 1000

Bilangan integer ini memiliki keterurutan berikut

Operator : Operator aritmatika dan relasional

Tabel 2.2 Operator integer

Kategori operator Operator Arti Hasil

Aritmatika + Tambah integer

div Bagi integer

mod Sisa pembagian bulat integer

abs Nilai absolute Integer>0