PRAKTIKUM 4: Mengimplementasikan pemrograman berorientasi objek
1.Buatlah sebuah program dalam bahasa C yang mengimplementasikan konsep kelas dan objek.
Buatlah kelas "Mahasiswa" yang memiliki atribut nama, nim, dan nilai. Program ini harus
mampu membuat objek Mahasiswa, mengisi nilai atribut, dan mencetak atribut Mahasiswa
tersebut.
JAWABAN;
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
1. #include <stdio.h>
2.
3. // Deklarasi kelas Mahasiswa
4. typedef struct {
5. char nama[50];
6. int nim;
7. float nilai;
8. } Mahasiswa;
9.
10. int main() {
11. // Membuat objek Mahasiswa
12. Mahasiswa mhs;
13.
14. // Mengisi nilai atribut Mahasiswa
15. printf("Masukkan nama: ");
16. gets(mhs.nama);
17.
18. printf("Masukkan NIM: ");
19. scanf("%d", &mhs.nim);
20.
21. printf("Masukkan nilai: ");
22. scanf("%f", &mhs.nilai);
23.
24. // Mencetak atribut Mahasiswa
25. printf("Nama: %s\n", mhs.nama);
26. printf("NIM: %d\n", mhs.nim);
27. printf("Nilai: %.2f\n", mhs.nilai);
28.
29. return 0;
30. }
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
▪ berikut hasilnya
Program ini menggunakan struktur untuk merepresentasikan data mahasiswa. Hal ini memungkinkan pengorganisasian data yang terkait dalam satu entitas. Dengan menggunakan struktur,program dapat dengan mudah mengelola data mahasiswa, seperti nama, NIM, dan nilai. Penggunaan struktur juga memudahkan pengelolaan data yang kompleks.
2. Buatlah sebuah program dalam bahasa C yang mengimplementasikan hubungan pewarisan
antara dua kelas. Buatlah kelas "Hewan" sebagai kelas induk dan kelas "Kucing" sebagai kelas
anak. Kelas Hewan memiliki atribut nama dan metode "berbicara()", sedangkan kelas Kucing
memiliki atribut "ras" dan mengoverride metode "berbicara()". Program ini harus mampu
membuat objek Kucing, mengisi nilai atribut, dan memanggil metode "berbicara()" untuk
objek Kucing tersebut.
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
1. #include <stdio.h>
2.
3. // Deklarasi kelas Hewan
4. typedef struct {
5. char nama[50];
6. } Hewan;
7.
8. // Deklarasi kelas Kucing sebagai turunan dari Hewan
9. typedef struct {
10. Hewan hewan;
11. char ras[50];
12. } Kucing;
13.
14. // Metode "berbicara()" untuk kelas Hewan
15. void berbicaraHewan() {
16. printf("Hewan berbicara!\n");
17. }
18.
19. // Metode "berbicara()" untuk kelas Kucing (override)
20. void berbicaraKucing() {
21. printf("Meow!\n");
22. }
23.
24. int main() {
25. // Membuat objek Kucing
26. Kucing kucing;
27.
28. // Mengisi nilai atribut
29. printf("Masukkan nama kucing: ");
30. gets(kucing.hewan.nama);
31.
32. printf("Masukkan ras kucing: ");
33. gets(kucing.ras);
34.
35. // Memanggil metode "berbicara()"
36. berbicaraHewan(); // Memanggil metode dari kelas Hewan
37. berbicaraKucing(); // Memanggil metode dari kelas Kucing
(override)
38.
39. // Mencetak atribut Kucing
40. printf("Nama kucing: %s\n", kucing.hewan.nama);
41. printf("Ras kucing: %s\n", kucing.ras);
42.
43. return 0;
44. }
▪ berikut hasilnya
Analisis
Program ini menggunakan struktur “Hewan” dan “Kucing” untuk
merepresentasikan hewan dan kucing. Di dalam “main()”, program
meminta pengguna memasukkan nama dan ras kucing. Program juga
mendefinisikan fungsi “berbicaraHewan()” dan
“berbicaraKucing()” yang digunakan untuk menunjukkan konsep
override pada pemrograman berorientasi objek. Program mencetak
suara hewan dan atribut kucing ke layar.
3. Buatlah sebuah program dalam bahasa C yang mengimplementasikan konsep enkapsulasi.Buatlah kelas "Kendaraan" yang memiliki atribut jenis, warna, dan kecepatan. Program ini
harus mampu mengubah nilai atribut kecepatan hanya melalui metode setter dan mencetak
nilai atribut menggunakan metode getter.
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
1. #include <stdio.h>
2.
3. // Deklarasi kelas Kendaraan
4. typedef struct {
5. char jenis[50];
6. char warna[50];
7. float kecepatan;
8. } Kendaraan;
9.
10. // Metode setter untuk atribut kecepatan
11. void setKecepatan(Kendaraan *k, float kecepatanBaru) {
12. k->kecepatan = kecepatanBaru;
13. }
14.
15. // Metode getter untuk atribut kecepatan
16. float getKecepatan(Kendaraan k) {
17. return k.kecepatan;
18. }
19.
20. int main() {
21. // Membuat objek Kendaraan
22. Kendaraan mobil;
23.
24. // Mengisi nilai atribut
25. printf("Masukkan jenis kendaraan: ");
26. gets(mobil.jenis);
27.
28. printf("Masukkan warna kendaraan: ");
29. gets(mobil.warna);
30.
31. setKecepatan(&mobil, 60.0); // Mengubah nilai atribut
menggunakan metode setter
32.
33. // Mencetak atribut Kendaraan
34. printf("Jenis kendaraan: %s\n", mobil.jenis);
35. printf("Warna kendaraan: %s\n", mobil.warna);
36. printf("Kecepatan kendaraan: %.2f\n", getKecepatan(mobil));
// Mengambil nilai atribut menggunakan metode getter
37.
38. return 0;
39. }
▪ berikut hasilnya
4. Buatlah sebuah program dalam bahasa C yang mengimplementasikan konsep komposisi antara
dua kelas. Buatlah kelas "Mobil" dan kelas "Roda" sebagai komponen mobil. Kelas Mobil
memiliki atribut merek dan objek Roda. Program ini harus mampu membuat objek Mobil,
mengisi nilai atribut merek dan atribut Roda, serta mencetak nilai atribut Mobil beserta atribut
Roda yang terkait.
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
1. #include <stdio.h>
2.
3. // Deklarasi kelas Roda
4. typedef struct {
5. int jumlah;
6. } Roda;
7.
8. // Deklarasi kelas Mobil
9. typedef struct {
10. char merek[50];
11. Roda roda;
12. } Mobil;
13.
14. int main() {
15. // Membuat objek Mobil
16. Mobil mobil;
17.
18. // Mengisi nilai atribut Mobil
19. printf("Masukkan merek mobil: ");
20. gets(mobil.merek);
21.
22. printf("Masukkan jumlah roda mobil: ");
23. scanf("%d", &mobil.roda.jumlah);
24.
25. // Mencetak atribut Mobil dan atribut Roda yang terkait
26. printf("Merek mobil: %s\n", mobil.merek);
27. printf("Jumlah roda mobil: %d\n", mobil.roda.jumlah);
28.
29. return 0;
30. }
▪ berikut hasilnya
5. Buatlah sebuah program dalam bahasa C yang mengimplementasikan konsep polimorfisme.
Buatlah kelas "Bentuk" dengan metode "luas()" yang mengembalikan luas bentuk tersebut.
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
1. #include <stdio.h>
2.
3. // Deklarasi kelas Bentuk
4. typedef struct {
5. int sisi;
6. } Bentuk;
7.
8. // Metode "luas()" untuk kelas Bentuk
9. int luasBentuk(Bentuk b) {
10. return b.sisi * b.sisi;
11. }
12.
13. // Deklarasi kelas Persegi sebagai turunan dari Bentuk
14. typedef struct {
15. Bentuk bentuk;
16. } Persegi;
17.
18. // Metode "luas()" untuk kelas Persegi (override)
19. int luasPersegi(Persegi p) {
20. return luasBentuk(p.bentuk);
21. }
22.
23. // Deklarasi kelas Lingkaran sebagai turunan dari Bentuk
24. typedef struct {
25. Bentuk bentuk;
26. } Lingkaran;
27.
28. // Metode "luas()" untuk kelas Lingkaran (override)
29. float luasLingkaran(Lingkaran l) {
30. return 3.14 * l.bentuk.sisi * l.bentuk.sisi;
31. }
32.
33. int main() {
34. // Membuat objek Persegi
35. Persegi persegi;
36. persegi.bentuk.sisi = 5;
37.
38. // Membuat objek Lingkaran
39. Lingkaran lingkaran;
40. lingkaran.bentuk.sisi = 7;
41.
42. // Memanggil metode "luas()"
43. printf("Luas persegi: %d\n", luasPersegi(persegi));
44. printf("Luas lingkaran: %.2f\n", luasLingkaran(lingkaran));
45.
46. return 0;
47. }
▪ berikut hasilnya
6. Buatlah kelas "Persegi" dan kelas "Lingkaran" yang merupakan turunan dari kelas Bentuk dan
mengoverride metode "luas()". Program ini harus mampu membuat objek Persegi dan
Lingkaran, mengisi nilai atribut yang diperlukan, dan memanggil metode "luas()" untuk
masing-masing objek..
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// Deklarasi kelas Bentuk
typedef struct {
// Pointer untuk fungsi menghitung luas
float (*luas)(void *);
} Bentuk;
// Deklarasi kelas Persegi sebagai turunan dari Bentuk
typedef struct {
Bentuk bentuk;
float sisi;
} Persegi;
// Fungsi untuk menghitung luas Persegi
float luasPersegi(void *p) {
Persegi *persegi = (Persegi *)p;
return persegi->sisi * persegi->sisi;
}
// Deklarasi kelas Lingkaran sebagai turunan dari Bentuk
typedef struct {
Bentuk bentuk;
float radius;
} Lingkaran;
// Fungsi untuk menghitung luas Lingkaran
float luasLingkaran(void *l) {
Lingkaran *lingkaran = (Lingkaran *)l;
return M_PI * lingkaran->radius * lingkaran->radius;
}
int main() {
// Membuat objek Persegi
Persegi persegi;
persegi.bentuk.luas = luasPersegi; // Menetapkan fungsi luas
printf("Masukkan panjang sisi persegi: ");
scanf("%f", &persegi.sisi);
// Menghitung dan menampilkan luas Persegi
printf("Luas Persegi: %.2f\n", persegi.bentuk.luas(&persegi));
// Membuat objek Lingkaran
Lingkaran lingkaran;
lingkaran.bentuk.luas = luasLingkaran; // Menetapkan fungsi luas
printf("Masukkan radius lingkaran: ");
scanf("%f", &lingkaran.radius);
// Menghitung dan menampilkan luas Lingkaran
printf("Luas Lingkaran: %.2f\n", lingkaran.bentuk.luas(&lingkaran));
return 0;
}
▪ berikut hasilnya
b) Mengimplementasikan kelas dan objek
Pertanyaan:
1. Anda diminta untuk mengimplementasikan kelas "Tanaman" dalam pemrograman
berorientasi objek menggunakan bahasa C. Setiap objek "Tanaman" harus memiliki atribut
sebagai berikut:
Nama Tanaman (string)
Jenis Tanaman (string)
Jumlah Tanaman (integer)
Luas Lahan (float)
Selain itu, kelas "Tanaman" juga harus memiliki method sebagai berikut:
setNamaTanaman(nama: string): Method ini digunakan untuk mengatur nama tanaman.
setJenisTanaman(jenis: string): Method ini digunakan untuk mengatur jenis tanaman.
setJumlahTanaman(jumlah: int): Method ini digunakan untuk mengatur jumlah tanaman.
setLuasLahan(luas: float): Method ini digunakan untuk mengatur luas lahan.
getNamaTanaman(): Method ini digunakan untuk mendapatkan nama tanaman.
getJenisTanaman(): Method ini digunakan untuk mendapatkan jenis tanaman.
getJumlahTanaman(): Method ini digunakan untuk mendapatkan jumlah tanaman.
Politeknik Semen Indonesia
Program Studi Diploma Tiga Teknologi Informasi
M o d u l P r a k t i k u m A l g o r i t m a d a n P e m r o g r a m a n P a g e 15 | 21
getLuasLahan(): Method ini digunakan untuk mendapatkan luas lahan.
hitungTotalProduksi(): Method ini digunakan untuk menghitung total produksi tanaman
berdasarkan jumlah tanaman dan luas lahan. Rumusnya adalah jumlah tanaman dikali luas
lahan.
Implementasikan kelas "Tanaman" dan buatlah objek tanaman baru dengan nama, jenis,
jumlah, dan luas lahan sesuai dengan input pengguna. Selanjutnya, panggil method
hitungTotalProduksi() dan cetak hasilnya ke layar.
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
1. #include <stdio.h>
2. #include <string.h>
3.
4. // Deklarasi kelas Tanaman
5. typedef struct {
6. char namaTanaman[50];
7. char jenisTanaman[50];
8. int jumlahTanaman;
9. float luasLahan;
10. } Tanaman;
11.
12. // Method untuk mengatur nama tanaman
13. void setNamaTanaman(Tanaman *tanaman, char nama[]) {
14. strcpy(tanaman->namaTanaman, nama);
15. }
16.
17. // Method untuk mengatur jenis tanaman
18. void setJenisTanaman(Tanaman *tanaman, char jenis[]) {
19. strcpy(tanaman->jenisTanaman, jenis);
20. }
21.
22. // Method untuk mengatur jumlah tanaman
23. void setJumlahTanaman(Tanaman *tanaman, int jumlah) {
24. tanaman->jumlahTanaman = jumlah;
25. }
26.
27. // Method untuk mengatur luas lahan
28. void setLuasLahan(Tanaman *tanaman, float luas) {
29. tanaman->luasLahan = luas;
30. }
31.
32. // Method untuk mendapatkan nama tanaman
33. char* getNamaTanaman(Tanaman tanaman) {
34. return tanaman.namaTanaman;
35. }
36.
37. // Method untuk mendapatkan jenis tanaman
38. char* getJenisTanaman(Tanaman tanaman) {
39. return tanaman.jenisTanaman;
40. }
41.
42. // Method untuk mendapatkan jumlah tanaman
43. int getJumlahTanaman(Tanaman tanaman) {
44. return tanaman.jumlahTanaman;
45. }
46.
47. // Method untuk mendapatkan luas lahan
48. float getLuasLahan(Tanaman tanaman) {
49. return tanaman.luasLahan;
50. }
51.
52. // Method untuk menghitung total produksi tanaman
53. float hitungTotalProduksi(Tanaman tanaman) {
54. return tanaman.jumlahTanaman * tanaman.luasLahan;
55. }
56.
57. int main() {
58. // Membuat objek tanaman baru
59. Tanaman tanaman;
60.
61. // Input data tanaman dari pengguna
62. char nama[50];
63. char jenis[50];
64. int jumlah;
65. float luas;
66.
67. printf("Masukkan nama tanaman: ");
68. fgets(nama, sizeof(nama), stdin);
69. setNamaTanaman(&tanaman, nama);
70.
71. printf("Masukkan jenis tanaman: ");
72. fgets(jenis, sizeof(jenis), stdin);
73. setJenisTanaman(&tanaman, jenis);
74.
75. printf("Masukkan jumlah tanaman: ");
76. scanf("%d", &jumlah);
77. setJumlahTanaman(&tanaman, jumlah);
78.
79. printf("Masukkan luas lahan (hektar): ");
80. scanf("%f", &luas);
81. setLuasLahan(&tanaman, luas);
82.
83. // Menghitung total produksi tanaman
84. float totalProduksi = hitungTotalProduksi(tanaman);
85.
86. // Menampilkan hasil
87. printf("\n");
88. printf("Total produksi tanaman %s: %.2f hektar\n",
getNamaTanaman(tanaman), totalProduksi);
89.
90. return 0;
91. }
▪ berikut hasilnya
2. Anda diminta untuk membuat program sederhana yang mengelola data buku di perpustakaan.
Setiap buku memiliki atribut berikut:
Judul
Penulis
Tahun Terbit
Jumlah Halaman
Anda diminta untuk membuat kelas "Buku" yang memiliki metode berikut:
Konstruktor untuk menginisialisasi atribut buku.
Metode "cetakInfo" untuk mencetak informasi buku (judul, penulis, tahun terbit, jumlah
halaman).
Selanjutnya, buatlah objek dari kelas "Buku" dan panggil metode "cetakInfo" untuk mencetak
informasi buku tersebut.
Tugas Anda adalah mengimplementasikan kelas "Buku" dan membuat objek buku beserta
pemanggilan metode "cetakInfo" dalam bahasa C.
▪ Buka Text Editor Code::Blocks,
▪ Pilih menu klik file → New→Empty File
▪ Ketikan koding di bawah ini
▪ Klik menu file Save, ketikan nama
▪ Klik Build →Build and Run atau icon
1. #include <stdio.h>
2.
3. // Deklarasi kelas Buku
4. struct Buku {
5. char judul[50];
6. char penulis[50];
7. int tahunTerbit;
8. int jumlahHalaman;
9. };
10.
11. // Metode untuk mencetak informasi buku
12. void cetakInfo(struct Buku buku) {
13. printf("Informasi Buku:\n");
14. printf("Judul : %s\n", buku.judul);
15. printf("Penulis : %s\n", buku.penulis);
16. printf("Tahun Terbit: %d\n", buku.tahunTerbit);
17. printf("Jumlah Halaman: %d\n", buku.jumlahHalaman);
18. }
19.
20. int main() {
21. // Membuat objek buku
22. struct Buku buku1;
23.
24. // Mengisi atribut buku
25. strcpy(buku1.judul, "Pemrograman Berorientasi Objek");
26. strcpy(buku1.penulis, "John Doe");
27. buku1.tahunTerbit = 2021;
28. buku1.jumlahHalaman = 300;
29.
30. // Memanggil metode cetakInfo
31. cetakInfo(buku1);
32.
33. return 0;
34. }
▪ berikut hasilnya
Comments
Post a Comment