analisa konstruktor mm.docx analisa data

analisa pemrograman

1. ANALISA KONSTRUKTOR
Program 1 :
public class PersegiPanjang {
// Atribut
int panjang;
int lebar;
// Constructor: untuk inisialisasi atribut
public PersegiPanjang(int p, int l) {
panjang = p;
lebar = l;
}
// Method untuk menghitung luas
public int hitungLuas() {
return panjang * lebar;
}
// Method untuk menghitung keliling
public int hitungKeliling() {
return 2 * (panjang + lebar);
}
// Main Method
public static void main(String[] args) {
// Membuat objek PersegiPanjang
PersegiPanjang pp1 = new PersegiPanjang(5, 3);
PersegiPanjang pp2 = new PersegiPanjang(10, 7);
// Menampilkan hasil
System.out.println("Persegi Panjang 1");
System.out.println("Luas: " + pp1.hitungLuas());
System.out.println("Keliling: " + pp1.hitungKeliling());
System.out.println("-----------------------");
System.out.println("Persegi Panjang 2");
System.out.println("Luas: " + pp2.hitungLuas());
System.out.println("Keliling: " + pp2.hitungKeliling());
}
}
ANALISA PROGRAM:

2. 1. Class PersegiPanjang
Atribut:
Class ini memiliki dua atribut utama, yaitu panjang dan lebar, yang menyimpan nilai
panjang dan lebar dari persegi panjang. Kedua atribut ini bertipe data int.
2. Constructor PersegiPanjang(int p, int l)
Fungsi:
Constructor digunakan untuk menginisialisasi nilai dari panjang dan lebar saat objek
PersegiPanjang dibuat. Parameter p dan l digunakan untuk mengisi nilai atribut
panjang dan lebar objek tersebut.
Tujuan:
Dengan menggunakan constructor, setiap objek PersegiPanjang dapat memiliki nilai
panjang dan lebar yang berbeda-beda, sesuai dengan input yang diberikan saat objek
dibuat.
3. Method hitungLuas()
Fungsi:
Method ini digunakan untuk menghitung luas persegi panjang. Rumus luas persegi
panjang adalah panjang * lebar.
Proses:
Method ini mengembalikan hasil perkalian antara atribut panjang dan lebar objek
tersebut.
4. Method hitungKeliling()
Fungsi:
Method ini digunakan untuk menghitung keliling persegi panjang. Rumus keliling
persegi panjang adalah 2 * (panjang + lebar).
Proses:
Method ini mengembalikan hasil perhitungan keliling berdasarkan atribut panjang dan
lebar objek.
5. Method main(String[] args)
Fungsi:
Ini adalah method utama untuk menjalankan program. Di dalam method main:
1.Dibuat dua objek PersegiPanjang, yaitu pp1 dan pp2, dengan panjang dan
lebar yang berbeda untuk masing-masing objek.
2.Setelah objek dibuat, method hitungLuas() dan hitungKeliling() dipanggil
untuk menghitung luas dan keliling dari masing-masing objek.
3.Hasil perhitungan luas dan keliling dari kedua objek ditampilkan ke layar.
6. Proses Output
Program menampilkan hasil perhitungan untuk kedua objek persegi panjang.

3. oUntuk objek pp1 dengan panjang 5 dan lebar 3, akan dihitung luas dan
kelilingnya, lalu hasilnya ditampilkan.
oUntuk objek pp2 dengan panjang 10 dan lebar 7, hal yang sama dilakukan.
Kesimpulan
Object-Oriented Programming (OOP): Program ini menunjukkan prinsip OOP
dengan mendefinisikan sebuah class PersegiPanjang yang memiliki atribut,
constructor, dan method untuk menghitung luas dan keliling.
Constructor: Digunakan untuk menginisialisasi nilai panjang dan lebar pada objek
yang dibuat.
Method: Digunakan untuk menghitung luas dan keliling berdasarkan nilai yang
diberikan saat objek dibuat.
Reusability: Dengan membuat objek berbeda, program ini memungkinkan kita untuk
menghitung luas dan keliling persegi panjang dengan berbagai ukuran yang berbeda.
Program 2:
public class Produk {
// Atribut
String namaProduk;
double harga;
int stok;
// Constructor
public Produk(String namaProduk, double harga, int stok) {
this.namaProduk = namaProduk;
this.harga = harga;
this.stok = stok;
}
// Method untuk menampilkan informasi produk
public void tampilkanInfo() {
System.out.println("Nama Produk : " + namaProduk);
System.out.println("Harga : Rp " + harga);
System.out.println("Stok Tersisa: " + stok + " unit");
System.out.println("---------------------------------");
}
// Main Method
public static void main(String[] args) {
// Membuat objek produk

4. Produk produk1 = new Produk("Laptop Asus", 8500000, 5);
Produk produk2 = new Produk("Mouse Logitech", 150000, 20);
Produk produk3 = new Produk("Keyboard Mechanical", 650000, 10);
// Menampilkan informasi produk
produk1.tampilkanInfo();
produk2.tampilkanInfo();
produk3.tampilkanInfo();
}
}
Analisa program:
1
️
. Tujuan Program
Program ini dibuat untuk memodelkan sebuah produk dalam dunia nyata ke dalam bentuk
objek di Java. Setiap produk memiliki 3 karakteristik utama:
Nama produk
Harga produk
Jumlah stok produk
Dengan menggunakan class Produk, data produk bisa lebih terstruktur dan mudah diatur
dalam sebuah sistem yang berbasis OOP (Object-Oriented Programming).
2
️
. Struktur Class
Komponen Keterangan
Nama ClassProduk
Atribut namaProduk (String), harga (double), stok (int)
ConstructorProduk(String namaProduk, double harga, int stok)
Method tampilkanInfo()
Main Methodpublic static void main(String[] args)
3
️
. Detail Atribut
namaProduk
oTipe Data: String
oFungsi: Menyimpan nama dari produk, contoh: "Laptop Asus".
harga

5. oTipe Data: double
oFungsi: Menyimpan harga dari produk, misalnya 8500000.
stok
oTipe Data: int
oFungsi: Menyimpan sisa jumlah produk di gudang, misalnya 5.
4
️
. Constructor
Bertugas menginisialisasi data produk ketika sebuah objek dibuat.
Parameter:
oNama produk (String),
oHarga produk (double),
oStok produk (int).
Keuntungan:
Menghemat penulisan kode karena setiap kali objek baru dibuat, atributnya langsung
terisi.
5
️
. Method tampilkanInfo()
Fungsi: Menampilkan informasi lengkap tentang sebuah produk ke konsol.
Output:
Nama produk, harga produk, dan stok produk ditampilkan dalam format teks yang
rapi.
Catatan:
oOutput harga tidak menggunakan format pemisah ribuan.
oTerdapat garis pemisah (---------------------------------) untuk memudahkan
pembacaan.
6
️
. Main Method
Berfungsi sebagai titik awal eksekusi program.
Dalam main:
oTiga objek Produk dibuat:
produk1 = Laptop Asus, Rp 8.500.000, stok 5.
produk2 = Mouse Logitech, Rp 150.000, stok 20.
produk3 = Keyboard Mechanical, Rp 650.000, stok 10.

6. oSetiap objek memanggil tampilkanInfo() untuk menampilkan informasi
produk ke layar.
ANALISA OVERLOADING PADA KONSTRUKTOR
Program :
public class Buku {
String judul;
String penulis;
double harga;
// Constructor pertama: Tanpa parameter
public Buku() {
this.judul = "Judul Tidak Diketahui";
this.penulis = "Penulis Tidak Diketahui";
this.harga = 0.0;
}
// Constructor kedua: Dengan dua parameter (judul dan penulis)
public Buku(String judul, String penulis) {
this.judul = judul;
this.penulis = penulis;
this.harga = 100000; // Harga default
}
// Constructor ketiga: Dengan tiga parameter (judul, penulis, dan harga)
public Buku(String judul, String penulis, double harga) {
this.judul = judul;
this.penulis = penulis;
this.harga = harga;
}
// Method untuk menampilkan informasi buku
public void tampilkanInfo() {
System.out.println("Judul : " + judul);
System.out.println("Penulis : " + penulis);
System.out.println("Harga : Rp " + harga);
System.out.println("---------------------------");
}
// Main method
public static void main(String[] args) {
// Membuat objek dengan constructor yang berbeda

7. Buku buku1 = new Buku(); // Constructor pertama (default)
Buku buku2 = new Buku("Java for Beginners", "John Doe"); // Constructor
kedua
Buku buku3 = new Buku("Advanced Java", "Jane Doe", 250000); // Constructor
ketiga
// Menampilkan data buku
buku1.tampilkanInfo();
buku2.tampilkanInfo();
buku3.tampilkanInfo();
}
}
Analisa program:
1. Struktur Kelas
Kelas bernama Buku dibuat untuk merepresentasikan sebuah objek buku yang memiliki tiga
atribut, yaitu:
judul (bertipe String) — menyimpan judul buku,
penulis (bertipe String) — menyimpan nama penulis buku,
harga (bertipe double) — menyimpan harga buku.
2. Overloading Constructor
Dalam kelas ini terdapat tiga konstruktor yang di-overload (dibuat dengan nama yang sama,
tapi parameter berbeda):
Constructor 1 (Tanpa Parameter)
Digunakan ketika objek buku dibuat tanpa informasi apapun. Atribut judul dan
penulis diisi dengan teks default, dan harga diatur ke 0.0.
Constructor 2 (Dengan 2 Parameter)
Digunakan ketika informasi judul dan penulis diketahui, namun harga tidak diberikan.
Maka, harga akan di-set ke nilai default 100000.
Constructor 3 (Dengan 3 Parameter)
Digunakan ketika seluruh informasi buku (judul, penulis, harga) diberikan secara
lengkap.
Manfaat Overloading ini:
Memudahkan pembuatan objek Buku dalam kondisi informasi yang bervariasi, tanpa harus
membuat kode tambahan di luar kelas.

8. 3. Method tampilkanInfo
Method ini bertugas mencetak informasi lengkap tentang buku ke konsol. Setiap atribut
(judul, penulis, harga) akan ditampilkan dengan format yang rapi. Cocok untuk memeriksa
data dari objek Buku yang sudah dibuat.
4. Fungsi main
Dalam fungsi main, tiga buah objek Buku dibuat menggunakan tiga konstruktor berbeda.
Setelah itu, masing-masing objek memanggil method tampilkanInfo() untuk mencetak data
buku ke layar.
5. Konsep OOP yang Diterapkan
Encapsulation (pengenkapsulan)
Data buku disimpan dalam atribut, dan bisa diakses melalui method.
Overloading
Konstruktor dibuat dalam beberapa bentuk untuk fleksibilitas pembuatan objek.
Instansiasi Objek
Objek-objek dibuat menggunakan new dan dipanggil methodnya secara individual.
Kesimpulan
Kode ini merupakan contoh sederhana tapi jelas dalam:
mengajarkan pembuatan class di Java,
memahami constructor overloading,
menerapkan object instantiation,
dan menampilkan data dengan method sederhana.
OVERLOADING PADA METODE
Program :
public class Kalkulator {

// Method pertama: Menambahkan dua bilangan
public int tambah(int a, int b) {
return a + b;
}

9. // Method kedua: Menambahkan tiga bilangan
public int tambah(int a, int b, int c) {
return a + b + c;
}
// Method ketiga: Menambahkan dua bilangan desimal (double)
public double tambah(double a, double b) {
return a + b;
}
// Method untuk menampilkan hasil
public void tampilkanHasil(String operasi, double hasil) {
System.out.println("Hasil " + operasi + " : " + hasil);
}
// Main method
public static void main(String[] args) {
Kalkulator kalkulator = new Kalkulator();

// Menggunakan method tambah dengan dua parameter integer
int hasil1 = kalkulator.tambah(5, 10);
kalkulator.tampilkanHasil("Tambah (2 bilangan)", hasil1);

// Menggunakan method tambah dengan tiga parameter integer
int hasil2 = kalkulator.tambah(5, 10, 15);
kalkulator.tampilkanHasil("Tambah (3 bilangan)", hasil2);

// Menggunakan method tambah dengan dua parameter double
double hasil3 = kalkulator.tambah(5.5, 10.5);
kalkulator.tampilkanHasil("Tambah (2 bilangan desimal)", hasil3);
}
}
Analisa program:
1. Struktur Kelas
Kelas Kalkulator berfungsi sebagai simulasi kalkulator sederhana, yang mampu melakukan
operasi penjumlahan dengan berbagai jenis input:
Penjumlahan dua bilangan bulat (int),
Penjumlahan tiga bilangan bulat (int),

10. Penjumlahan dua bilangan desimal (double).
2. Method Overloading
Di dalam kelas ini, terdapat beberapa metode dengan nama yang sama, yaitu tambah, tetapi
memiliki parameter yang berbeda:
Versi 1 menerima dua parameter bilangan bulat.
Versi 2 menerima tiga parameter bilangan bulat.
Versi 3 menerima dua parameter bilangan desimal.
Overloading ini memungkinkan program memanggil metode tambah yang sesuai dengan tipe
dan jumlah argumen yang diberikan, sehingga:
kode lebih singkat,
lebih mudah dibaca,
lebih fleksibel.
3. Method tampilkanHasil
Method ini bertugas mencetak hasil perhitungan ke layar, sekaligus memberi informasi nama
operasi. Metode ini memperjelas output agar pengguna tahu hasil dari proses apa yang sedang
ditampilkan.
4. Fungsi main
Di dalam method main:
Dibuat sebuah objek Kalkulator.
Objek tersebut memanggil metode tambah sebanyak tiga kali, masing-masing dengan
kombinasi parameter yang berbeda.
Setelah perhitungan, hasilnya langsung dicetak ke layar dengan memanfaatkan
method tampilkanHasil.
5. Konsep OOP yang Diterapkan
Method Overloading
Tiga versi tambah menunjukkan kemampuan Java dalam membedakan metode
berdasarkan jumlah dan tipe parameter, meskipun nama metodenya sama.
Instansiasi Objek
Objek kalkulator dibuat dari kelas Kalkulator, lalu dipakai untuk memanggil method.

11. Pemrosesan Tipe Data
Program menunjukkan perbedaan antara operasi pada bilangan bulat (int) dan
bilangan desimal (double), sekaligus contoh bagaimana Java menangani tipe data
dalam method.
Kesimpulan
Program ini sangat cocok untuk memperkenalkan:
Prinsip OOP, terutama polimorfisme lewat overloading,
Penggunaan method dalam memproses data,
Penerapan main sebagai pengontrol alur program,
Pengolahan data dengan tipe yang berbeda (int dan double).
ANALISA PEWARISAN
Program 1:
// Superclass (Induk)
class Kendaraan {
String merk;
void berjalan() {
System.out.println(merk + " sedang berjalan...");
}
}
// Subclass (Mobil)
class Mobil extends Kendaraan {
int jumlahPintu;
void infoMobil() {
System.out.println("Merk: " + merk + ", Pintu: " + jumlahPintu);
}
}
// Program Utama
public class Main {
public static void main(String[] args) {
Mobil mobilSaya = new Mobil();
mobilSaya.merk = "Toyota";
mobilSaya.jumlahPintu = 4;
mobilSaya.infoMobil();

12. mobilSaya.berjalan();
}
}
Analisa program:
Struktur Program
Program terdiri dari dua kelas utama:
1.Kendaraan → sebagai superclass (induk)
2.Mobil → sebagai subclass (anak) yang mewarisi dari Kendaraan.
Ada juga satu kelas Main yang berisi method main() sebagai titik awal eksekusi
program.
Konsep OOP yang Diterapkan
1.Pewarisan (Inheritance)
Kelas Mobil mewarisi atribut dan method dari kelas Kendaraan.
Dengan pewarisan ini:
oMobil bisa menggunakan atribut merk dan method berjalan() dari Kendaraan
tanpa harus menuliskannya ulang.
oMobil juga menambahkan atribut khusus jumlahPintu dan method infoMobil()
sebagai ciri khas kendaraan jenis mobil.
2.Penggunaan Objek
Di dalam main(), dibuat sebuah objek dari kelas Mobil. Objek ini diberi nilai pada
atribut merk (dari superclass) dan jumlahPintu (dari subclass).
Kemudian:
oMethod infoMobil() dipanggil untuk menampilkan informasi lengkap mobil.
oMethod berjalan() dipanggil untuk menampilkan aksi kendaraan bergerak.
3.Pemanfaatan Pewarisan
oKode lebih hemat dan terstruktur karena Mobil tidak perlu mendefinisikan
ulang properti merk dan method berjalan().
oSubclass (Mobil) bisa memperluas atau memodifikasi perilaku kelas induk
(Kendaraan) jika dibutuhkan.

13. oProgram lebih mudah dikembangkan: misalnya kalau nanti ingin membuat
Motor atau Truk, cukup buat subclass baru yang mewarisi Kendaraan.
Kesimpulan
Program ini menunjukkan contoh pewarisan yang sangat mendasar:
Kelas Mobil mendapatkan fitur dasar dari Kendaraan.
Kelas Mobil juga menambahkan fitur spesifik yang hanya dimiliki mobil, yaitu
jumlahPintu.
Objek mobilSaya bisa mengakses method dari induk dan anak kelas dengan
mudah.
Program 2:
// Kelas Induk
public class Kendaraan {
String merk;
int tahun;
public Kendaraan setMerk(String merk) {
this.merk = merk;
return this; // method chaining
}
public Kendaraan setTahun(int tahun) {
this.tahun = tahun;
return this;
}
public void info() {
System.out.println("Merk: " + merk);
System.out.println("Tahun: " + tahun);
}
public void suaraMesin() {
System.out.println("Mesin kendaraan menyala: Brrrmmm...");
}
}
// Kelas Turunan
class Mobil extends Kendaraan {
String tipe;

14. public Mobil setTipe(String tipe) {
this.tipe = tipe;
return this; // method chaining
}
@Override
public void suaraMesin() {
System.out.println("Mesin mobil " + merk + " menyala: Vroooom!");
}
@Override
public void info() {
super.info(); // panggil method info() di induk
System.out.println("Tipe: " + tipe);
}
}
// Main Program
public class Main {
public static void main(String[] args) {
// Membuat objek Mobil dengan method chaining
Mobil avanza = new Mobil()
.setMerk("Toyota")
.setTahun(2020)
.setTipe("Avanza");
avanza.info(); // Cetak informasi mobil
avanza.suaraMesin(); // Polimorfisme: suara mesin mobil
}
}
Analisa program:
Struktur Program
Program ini terdiri dari tiga bagian:
1.Kelas Induk (Superclass) — merepresentasikan Kendaraan
2.Kelas Turunan (Subclass) — merepresentasikan Mobil
3.Main Program — tempat eksekusi dimulai dan objek dibuat.
Konsep yang Diterapkan
1.Pewarisan (Inheritance)

15. Kelas Mobil mewarisi atribut merk dan tahun, serta method setMerk(), setTahun(),
info(), dan suaraMesin() dari kelas Kendaraan.
Ini mencerminkan hubungan "is-a" (Mobil adalah Kendaraan).
2.Method Chaining
Method setMerk(), setTahun(), dan setTipe() semuanya mengembalikan objek this,
sehingga pemanggilan bisa berantai dalam satu baris:
Contoh:
new Mobil().setMerk().setTahun().setTipe();
Teknik ini membuat kode lebih ringkas dan rapi.
1.Polimorfisme melalui Overriding
Mobil melakukan override pada dua method milik Kendaraan:
osuaraMesin() diubah agar output sesuai karakteristik mobil.
oinfo() diubah agar selain menampilkan merk dan tahun, juga menampilkan
tipe mobil.
2.Penggunaan super
Pada method info() milik Mobil, dipanggil super.info() untuk menggunakan method
dari kelas induk dan menambahkan informasi khusus di kelas turunan (tipe).
Proses Jalannya Program
Objek Mobil dibuat dan diisi data merk, tahun, dan tipe melalui method chaining.
Method info() dipanggil untuk mencetak detail objek.
Method suaraMesin() dipanggil untuk mencetak suara mesin yang telah di-override
sesuai dengan jenis objek (Mobil).
Kesimpulan
Program ini sangat baik untuk memahami:
Pewarisan : Subclass mewarisi atribut danmethod superclass.
Polimorfisme: Method suaraMesin() menunjukkan hasil berbeda tergantung tipe objek.
Method Chaining: Membuat kode lebih clean, readable, dan modern.
Reusability: Kelas Kendaraan bisa dipakai ulang untuk membuat subclass lain seperti Motor
atau Truk tanpa perlu menulis ulang atribut dan method dasar.