Pelajaran oop java ii pengertian method dan cara pembuatan method by hermawan

1PELAJARAN OOP JAVA DISUSUN OLEH HERMAWAN
STMIK MERCUSUAR BEKASI JAWA BARAT
PELAJARAN JAVA OOP 1
MEMBUAT PROGRAM BANGUN DATAR GUI MENGGUNAKAN NETBEANS
pada pembahasan kali ini kita akan coba membuat program penghitung luas untuk bangun
datar (persegi, persegi panjang, segituga dan lingkaran). mari ikuti langkahnya.
buatlah project baru di netbeans dengan cara klik menu File -> New Project ->Java -
> java Application -> next.
beri nama project dengan nama “bangunDatar”.
hilangkan semua centang -> klik finish
oke project sudah jadi jika bingung silahkan lihat matericara membuat project menggunakan
netbeans atau materi ini. setelah membuat project buatlah 2 package baru di dalam project
dengan nama “logic” dan “tampilan”. package logic digunakan untuk menyimpan semua
kelas java yang bertugas sebagai logic program dan package tampilan untuk menyimpan
semua kelas untuk User Interface (GUI). berikut ini caranya :
pada window project, carilah project anda dan klik kanan ikon (cangkir kopi) ->
new -> java package -> beri nama logic -> finish. atau klik kanan menu file ->
new File -> java -> java package -> beri nama logic-> finish. jika bingung silahkan
lihat materi ini dan pelajari window dari netbeans.
setelah package logic jadi, ulangi lagi membuat package dengan nama tampilan.
oke, saya anggap sudah jadi packagenya lalu kita harus membuat kelas – kelas logic yang
menangani perhitungan luas dan keliling masing – masing bangun datar. mari kita buat
membuat kelas Persegi, caranya pada icon package logic klik kanan -> new -> java
class -> beri nama Persegi -> finish. berikut ini kode dari kelas persegi
1
2
3
4
5
6
7
8
9
10
11
package logic;
/**
*
* hermawan
*/
public class Persegi {
private double sisi;
public void setSisi(double s){
sisi = s;

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
}
public double getSisi(){
return sisi;
}
public double hitungLuas(){
double luas = 0;
luas = sisi*sisi;
return luas;
}
public double hitungKeliling(){
double keliling = 0;
keliling = 4*sisi;
return keliling;
}
}
setelah itu kita buat kelas yang menangani logic dari sebuah persegi panjang, kita buat
kelas bernama PersegiPanjang. caranya sama dengan pembuatan kelas Persegi yaitu
didalam package logic, berikut ini kode kelas PersegiPanjang
1
2
3
4
5
6
7
8
9
10
11
package logic;
/**
*
* @author lahardi alkawero
*/
public class PersegiPanjang {
private double panjang;
private double lebar;
public void setPanjang(double p){

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
panjang = p;
}
public void setLebar(double l){
lebar = l;
}
public double getPanjang(){
return panjang;
}
public double getLebar(){
return lebar;
}
double luas = 0;
luas = panjang*lebar;
return luas;
}
keliling = (2*panjang)+(2*lebar);
return keliling;
}
}
lalu buat kelas yang menangani logic dari sebuah segitiga, kita buat kelas Segitiga di
dalam package logic, berikut kodenya
1
2
3
4
5
package logic;
/**
*
* hermawan WIN-7

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
*/
public class Segitiga {
private double alas;
private double tinggi;
private double sisi1;
public void setAlas(double a){
this.alas = a;
}
public void setTinggi(double t){
this.tinggi = t;
}
public void setSisi1(double s1){
this.sisi1 = s1;
}
this.sisi2 = s2;
}
this.sisi3 = s3;
}
public double getAlas(){
return alas;
}
public double getTinggi(){

39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
return tinggi;
}
double luas = 0;
luas = 0.5*alas*tinggi;
return luas;
}
keliling = sisi1+sisi2+sisi3;
return keliling;
}
}
dan kelas yang terakhir adalah kelas Lingkaran, caranya sama dengan pembuatan
kelas Persegi, tapi nama kelasnya adalah Lingkaran, berikut ini kodenya :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package logic;
/**
*
* @hermawan
*/
public class Lingkaran {
private double jari;
public void setJari(double j){
jari = j;
}
public double getJari(){
return jari;

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
}
double luas=0;
luas = Math.PI * Math.pow(jari, 2);
return luas;
}
double keliling=0;
keliling = 2 * Math.PI * jari;
return keliling;
}
}
Itulah kelas – kelas yang menangani logic dari program yang akan kita buat.
selanjutnya kita akan buat tampilannya / GUInya tapi pada sesi berikutnya.

ABSTRACT CLASS DI JAVA , APA ITU DAN UNTUK APA ?
Abstract class/kelas abstrak, sesuai namanya adalah kelas yang belum jelas
spesifikasinya contohnya adalah gambar berikut
Dapat dilihat jenis kelas diatas, kelas paling atas adalah kelas Bangun datar lalu
turunan dari kelas bangun datar adalah kelas persegi, segitiga, persegi panjang. nah.. dapat
diketahui kelas bangun datar adalah kelas Abstraknya. misalkan sebuah kelas memiliki
method, maka dapat diperkirakan method dari bangun datar adalah hitungLuas() atau
hitungKeliling(). dapatkah anda menjelaskan dengan spesifik seperti apa perhitungan luas
dari kelas BangunDatar. method yang belum jelas seperti itu bisa disebut method abstrak. dan
sebuah kelas jika ada 1 saja method yang abstrak, maka dia akan menjadi kelas abstrak.
Lalu perhatikan kelas persegi, jika kelas persegi memiliki method hitungLuas()
dibawah ini adalah contohnya.
hitungLuas(int sisi){
int luas = 0;
luas = sisi*sisi;
System.out.println(luas);
}

Jika kelas BangunDatar adalah abstrack, maka kelas Persegi karena sudah jelas
dapat disebut sebagai kelas kongkret. kelas abstrak digunakan untuk membuat sebuah kelas
yang memiliki method yang belum jelas implementasinya. berikut ini aturan nya :
jika sebuah kelas memiliki method abstrak maka kelas itu harus menjadi kelas
abstrak.
sebuah kelas abstrak dapat saja memiliki method yang tidak abstrak.
jika sebuah kelas abstrak diturunkan menjadi kelas konkret, maka semua method
abstrak dari kelas abstrak haruslah ditulis ulang / dibuat ulang di kelas konkretnya dan
diberi detail dari methodnya.
jika method abstrak di turunkan dan kelas turunannya adalah kelas abstrak, maka
tidak perlu menulis ulang method yang abstrak.
Sementara itu dulu aturan yang harus dipahami ketika anda membuat kelas abstrak dan
menggunakan kelas abstrak, aturan – aturan lain akan anda temui ketika anda mulai
membuatnya.
Jika kelas BangunDatar kita buat kodenya kira – kira akan menjadi seperti ini
1
2
3
public abstract class abstrack {
abstract int hitungLuas();
}
lalu kita akan membuat kelas turunannya yaitu Persegi
1
2
3
4
5
6
7
8
9
10
11
12
13
class Persegi extends abstrack{
int sisi;
public Persegi(int s){
this.sisi = s;
}
public int hitungLuas() {
//method ini harus diberi implementasi
int luas = sisi*sisi;
return luas;
}

14
15
16
17
18
19
20
public static void main(String[] args){
Persegi p = new Persegi(5);
int luas = p.hitungLuas();
System.out.println(luas);
}
}
Yaa seperti itulah contohnya, silahkan anda buat untuk luas persegi panjang dan juga
segitiga, termasuk kelilingnya

PELAJAR JAVA OOP 3
OOP DI JAVA
Apa sih OOP?
Mungkin saudara yang udah pada tahu tentang pemrograman prosedural.
Pemrograman prosedural itu pemrograman yang memecah persoalan menjadi beberapa
prosedur/fungsi).
kalau di java sendiri prosedur/fungsi disebut method itu yang punya syntax seperti ini.
Contohnya :
1
2
3
4
5
6
7
8
9
//susunanan untuk pembuatan method di java ->
//hak_akses[spasi]
//tipe _kembalian(kalau void tidak mengembalikan apa2)[spasi]
//nama_method[spasi]
//(argumen/variable2(bisa dikosongkan))
public void contohMethod(){
//kodingan
}
tujuannya dipecah tentunya untuk mempermudah ketika nanti kalau method tersebut kita
perlukan lagi, kita ga perlu cape-cape nulis method itu lagi. Selain itu pemecahan tersebut
juga berguna untuk mempermudah kita dalam menyelesaikan masalah.
OOP tidak jauh beda dengan pemrograman prosedural. OOP itu singkatan dari object
oriented programming. Bisa dibilang bahwa semua yang kita buat dalam program kita, kita
anggap sebagai object. Jadi setiap bagian dari program kita pecah menjadi satu class. Kalau
kelas tersebut di deklarasikan dalam variable maka akan menjadi satu object. Jadi suatu class
bisa menghasilkan banyak object, Untuk lebih jelasnya misalkan kita punya class ayam. Si
ayam tersebut memilika atribut cakar dan sayap serta memiliki method menari, lari dan
bernyanyi. Maka ketika kita menciptakan variable anto, andi dan abu yang bertype class
ayam maka si anto, andi dan abu juga memiliki atribut dan method yang sama. Mereka dapat
menari, lari, dll karena merek sama-sama object dari class ayam.
Jadi OOP disebut OOP karena seperti yang sudah saya katakan diatas, bahwa setiap
code kita dianggap sebagai object-object yang merupakan instance dari class.

Lalu bagaimana kita menjalankan program kita?
Kalau di java kita harus punya namanya main class. Apa itu main class? Kalau
saudara pakai IDE netbeants atau eclipse, secara otomatis pasti akan dibikinin Main Class
seperti dibawah ini.
1
2
3
4
5
6
7
8
public class namaMainClass {
/**
* @hermawan
*/
public static void main(String[] args) {
// TODO code application logic here
}
}
Main class dalam bahasa indonesia adalah class utama. Main class merupak class
yang pertama kali dijalankan ketika program dijalankan. Bagian code yang berada dalam
method public static void main(String[] args) merupakan code yang dijalankan, jadi ketika
program dijalankan maka method static void main yang akan dijalankan.
Bagaimana membuat class dan apa saja sih isi dari class? Pertama saya akan mencoba
menjelaskan dari belakang, yaitu mengenai isi dari class. Class memiliki dua buah elemen
penting yaitu atribut dan method. Kalau diibaratkan atribut merupakan penyusun, atau
sesuatu yang dimiliki class tersebut. Atribut berupa variable. Contohnya kita mempunyai
class ayam, atributnya tentu cakar, sayap, kaki, mata, usus, dll (mungkin saja bisa bertipe data
int, string dll).
Method sendiri merupakan apa yang bisa dikerjakan dari class tersebut. Misalnya
kalau class ayam dia pasti bisa berhitung, perkalian, dll. Jadi kalau atribut berupa variable,
maka method ini adalah fungsi (sama seperti diatas, cuma biar kelihatan panjang aja sih)
Dalam class di java (dan sebagian besar bahasa pemrograman), atribut dan method memiliki
hak akses tersendiri. Berikut listnya
public : dapat digunakan dari luar kelas maupun package
protected : dapat digunakan dari sub-class atau class lain dalam satu package
tanpa hak akses : dapat digunakan class lain dalam satu package
private : hanya digunakan oleh class tersebut saja

Selain hak akses ada dua atribut yang sering digunakan untuk atribut dan method
yaitu atribut final dan static. Apasih maksudnya?
Atribut final berarti untuk suatu atribut berarti bahwa nilai didalam atribut tersebut
tidak dapat dirubah lagi . Sedangkan untuk method berarti bahwa method tersebut tidak dapat
di overriding. Atribut static sendiri berarti bahwa atribut/method tersebut hanya ada satu di
dalam memori sehingga ketika suatu object memanggil atribut/method tersebut, object
tersebut tidak menghasilkan kopian dari atribut/method tersebut (atribut/method biasanya
menghasilkan satu kopian untuk setiap object yang dihasilkan) namun hanya merujuk ke
atribut/method tersebut.

OOP DI JAVA
Selain atribut, method, hak akses, atribut final dan static, ada lagi yang sering kita
gunakan di dalam OPP ya itu variable.
this Apasih variable this?
Variable this adalah varible yang digunakan untuk mengacu kedalam class dimana
kita coding. Jadi misalkan kita coding di class ayam lalu di dalam salah satu method kita
mengetikan this, berarti kita mengacu kepada class ayam yang lagi kita coding.
Apa manfaat kita mengacu ke class yang sedang kita kerjakan? Manfaatnya adalah
kita bisa menggunakan atribut maupun method yang dimiliki kelas tersebut. Sebagai contoh
silahkan lihat potongan code dibawah :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private String Nama;
private int Usia;
public Atlit(String Nama, int Usia) {
//mengacu this.Nama kepada
//Nama yang menjadi atribut class tersebut
//sedangkan Nama mengacu kepada variable
//masukan dari constructor kelas ini
this.Nama = Nama;
this.Usia = Usia;
}
public String getNama(){
System.out.println("Method 1 " +this.Nama);
return Nama;
}
public void getNamaBerulang(){
System.out.println("Method 2 " +this.getNama());
}

Dari code program diatas bisa dilihat bahwa kita menggunakan this. Nama mengacu
kepada Nama yang menjadi atribut class tersebut, sedangkan Nama mengacu kepada variable
masukan dari contructor . sebenarnya tidak hanya dalam constructor namun bisa juga dalam
method) kelas ini. Jadi kita bisa menggunakan nama yang sama dalam suatu method ketika
mendeklarasikan local variable, dan untuk membedakannya dengan atribut class kita, kita
bisa menggunakan this.
Bagaimana dengan method? Variable this juga dapat digunakan untuk memanggil
method lain yang dimiliki class tersebut. Seperti pada potongan code di atas, kita memanggil
getNama di getNamaBerulang.
Setelah ngejawab apa aja yang ada di dalam class, sekarang saya mau jawab
pertanyaan pertama, yaitu gimana sih cara membuat class?
Cara membuat class di java gampang pertama, saudara buat sebuah file java (kalau di
netbeans tinggal klik kanan->new->pilih bikin java class) lalu di dalamnya kita deklarasikan
sebuah class seperti code dibawah ini.
1public class NamaClass {}
Bisa dilihat, cara pembuatan class itu sama seperti method
hak_akses[spasi]atribut(final/abstract/dll)[spasi]class[spasi]nama_klass. Selanjutnya, kita
perlu membuat constructor.
Apasih constructor? Constructor itu sama seperti method. Constructor kalau
diibaratkan seperti sebuah method, ketika object diciptakan, maka constructor dijalankan dan
menjalankan code di dalamnya. Jadi bisa dibilang constructor adalah bagian yang digunakan
untuk menginisiasi nilai-nilai awal dari object. Ada beberapa perbedaan constructor dengan
method yaitu :
Namanya harus sama dengan nama class
Tidak mengembalikan nilai jadi tidak perlu ditulis tipe kembalian, bahkan void
Berikut contoh class yang sudah diberi constructor.
1
2
3
4
5
6
public class Atlit {
private int Usia;
//constructor

7
8
9
10
11
this.Nama = Nama;
this.Usia = Usia;
}
}
Dari potongan code diatas bisa dilihat bahwa constructor digunakan untuk
menginisiasi nilai nama dam usia : perhatian Kalau kita tidak membuat constructor apa yang
terjadi? Tidak terjadi apa-apa : dipukul karena secara default ada constructor default yang
tidak melakukan apa-apa. saudara selanjutnya tinggal menambahkan method-method yang
anda perlukan dalam program anda Sebagai contoh :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Atlit {
private int Usia;
this.Nama = Nama;
this.Usia = Usia;
}
public String getNama(){
System.out.println("Method 1 " +this.Nama);
return Nama;
}
public void getNamaBerulang(){
System.out.println("Method 2 " +this.getNama());
}
}
Selanjutnya bagaimana caranya kita menciptakan object dari class yang kita miliki?
Caranya gampang, sama seperti deklarasi variable biasa (NamaClass NamaObject).
Lalu untuk menjadikan object yang sempurna kita harus menginisiasinya dengan new

NamaClass (memberikan parameter masukan dari class sesuai dengan constructor yang kita
buat).
1
2
//paramater masukan berupa nama dan usia
Atlit atlit1 = new Atlit("Anto", 20);
Untuk memanggil method yang telah kita buat, kita tinggal mengetikan seperti contoh
dibawah ini.
1
2
//namaVariable(titik)namaMethod
atlit1.getNamaBerulang();
Code- code penginisiasian object ini, tinggal anda ketik di Main Class lalu anda coba
jalankan pastikan hasilnya seperti ini.
1
2
Method 1 Anto
Method 2 Anto

Apa itu objek , kelas, variabel, method dalam object oriented programming (oop) ?
Dalam java, secara garis besar sebuah program terdiri dari class, object, atribut,
method.
Jika di ilustrasikan, saya ingin membuat program yang bekerja seperti seorang mahasiswa,
maka saya akan membuat kelas yang bernama mahasiswa. setelah itu kita tentukan atribut /
variabel nya.
Maka atribut dari kelas mahasiswa ini diantaranya : nama, nim, tanggal_lahir, usia;
dan lainnya. Berarti atribut adalah sesuatu yang dimiliki oleh sebuah mahasiswa. Setelah itu
kita harus tentukan apa yang dapat dilakukan oleh seorang mahasiwa?? misalnya :
berkenalan, berhitung, dll. Dalam java hal – hal yang dapat dilakukan itu disebut method atau
behaviour, saya lebih suka menyebutnya method.
Baiklah kita sudah mengenal kelas, atribut, method dan object yang saya coba beri
contoh
Kelas Objek
Mahasiswa Mahasiswa bernama alka
Mobil sedan Honda city seri 1
Karyawan Karyawan dengan nik sekian..
Jadi kelas adalah jenis – jenis atau kategori sesuatu misal jenis mobil sedan maka
object dari mobil sedan adalah bentuk nyata yang dapat dilihat, diraba, dan memiliki
kemampuan tertentu misal honda city seri 1. misalnya lagi kelas mahasiswa maka bentuk
nyata dari mahasiswa adalah seorang mahasiswa bernama alka. Baiklah mari kita coba buat
programnya :
1. buatlah project baru di netbean, jika sudah buatlah kelas baru bernama Mahasiswa .
Kita akan memiliki kode seperti berikut
1
2
public class Mahasiswa{
}
2. kita berikan atribut/variabel, kita pikirkan apa yang dimiliki mahasiswa, nim, nama,
alamat kode kita menjadi :

1
2
3
4
5
6
7
8
9
String nim; // ini adalah komentar
String nama; // menjelaskan bahwa variabel nama bertipe String
String alamat; // variabel alamat bertipe String
}
kita sudah mendefinisikan variabelnya, jika belum paha dengan tipe dari variabel bisa
baca tipe data di java.
3. lalu kita berikan dia keahlian, kode program kita akan tampak seperti ini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//mendeklarasikan variabel – variabel
//mendeklarasikan method
void berkenalan() {
System.out.println(“halo nama saya ”+ nama); //mencetak lalu enter
System.out.println(“nim saya ”+nim); // mencetak lalu enter perhatikan println
System.out.print(“alamat saya ”+alamat); //mencetak tulisan tapi tidak enter perhatikan

20
21
22
23
24
25
print
System.out.println(“ hahahahaha”);
}
}
Jika belum mengerti cara mendeklarasikan method, harap baca tentang mendeklarasikan
method di java.
4. Sudah bisa dibilang kalau kelas mahasiswa ini sudah jadi, kira – kira sudah bisa jalan
atau belum (di RUN). Jawabanya adalah belum. karena kita belum memiliki method
yang khusus untuk mengeksekusi sebuah file / kelas java. Method sepecial ini adalah
method main. Cara mendeklarasikannya adalah dengan menulis code yang ada di
bawah ini:
1
2
3
}
5. Method ini dapat ditaruh di file / kelas yang anda inginkan untuk bisa mengeksekusi,
baik mengeksekusi dirinya sendiri atau kelas lain. Berikut kode program kita jika di
beri method main.
1
2
3
4
5
6
7
8
9
10
11

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void berkenalan() {
print
}
//kode untuk dieksekusi tempatnya disini.
}
}
Seperti itulah kira – kira, anda bisa taruh methodnya dimana saja dalam file anda asalkan
berada di luar tanda { } dari method lain. Maksudnya tidak mengapa jika anda ingin taruh di
tempat deklarasi variabel. Namun kurang baik, sebaiknya deklarasi variabel di bawah
deklarasi kelas lalu di ikuti oleh method – method yang dimilikinya.
5. Untuk membuat objectnya anda memerlukan sebuah method special yang disebut
method konstruktor. Seperti namanya konstruktor ini bertugas mengkonstruk, atau
menciptakan sebuah objek dari kelas tertentu, aturan pembuatan konstruktor adalah :
nama konstruktor harus sama dengan nama kelas
sebuah kelas bisa terdiri dari satu atau beberapa konstruktor.
Jika kontruktor tidak anda buat, maka java akan membuatkan kostruktor default
dengan nama NamaKelasAnda(){}

sebaiknya anda deklarasikan saja agar sesuai ingin anda.Baiklah mari kita buat,
berikut contoh kodenya :
1
2
3
4
5
6
7
8
9
public Mahasiswa(String nama, String nim, String alamat){
this.nama = nama;
this.nim = nim;
this.alamat = alamat;
}
this maksudnya adalah variabel nama dari kelas ini adalah String nama yang di
inputkan, variabel nim dari kelas ini adalah String nim yang diinputkan, dst.
Kode program kita akan seperti ini :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//mendeklarasikan method konstruktor
this.nama = nama;
this.nim = nim;

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
}
void berkenalan() {
print
}
//kode untuk dieksekusi tempatnya disini.
}
}
6. Selanjutnya adalah menjalankannya programnya tahapannya adalah
1. menciptakan object dengan cara menuliskannya dalam method main sebagai
berikut
1
2
3
4
Mahasiswa alka = new Mahasiswa(“lahardi alkawero”, “M0508107”,”Tangerang”) ;
}

Object kita sudah jadi, bagaimana maksudnya? Jadi aturannya seperti ini : NamaKelas
namaObjek = new namaKonstruktor(Stringnama, stringnim, stringalamat); kenapa kok jadi
diinputkan “lahardi alkawero” kok bukan lahardi alkawero tanpa tanda petik, karena tipe
datanya String, jika bukan misa integer atau angka, maka tidak perlu tanda petik.
7. Sekarang kita buat si objek dari mahasiswa yaitu si alka untuk menunjukkan
keahliannya. Karena keahliannya hanya berkenalan, maka kita suruh dia berkenalan
dengan cara menuliskan berikut setelah kode penciptaan object
:alka.berkenalan();yang maksudnya abjek alka mengakses kemempuan / method
berkenalan.
8. Mari kita lihat kodenya
1
2
3
4
5
6
7
8
9
this.nama = nama;
this.nim = nim;
}
“this” Maksudnya adalah variabel nama dari kelas ini adalah String nama yang di
inputkan, variabel nim dari kelas ini adalah String nim yang diinputkan, dst.
Kode program kita akan seperti ini :
1
2
3
4
5
6
7
8
9
10
11
//mendeklarasikan method konstruktor

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
this.nama = nama;
this.nim = nim;
}
void berkenalan() {
print
}
Mahasiswa alka = new Mahasiswa(“lahardi alkawero”, “M0508107”,”Tangerang”);
alka.berkenalan();
}

45
}
9. mari kita jalankan dengan menekan shift + f6, dengan menekannya kita
memerintahkan netbeans untuk menjalankan file, jika ingin menjalankan project
dengan banyak kelas dan satu kelas utama dengan method main didalamnya kita tekan
f6 saja.

PELJARAN JAVA OOP 6
CARA MEMBUAT METHOD DI JAVA
Method dalam java adalah sesuatu yang bisa dilakukan oleh Kelas / Objek, saya beri
contoh
misal saya punya kelas bernama MahasiswaInformatika, maka kira – kira method dari kelas
ini adalah Kuliah, Berkenalan, Koding, Berhitung, apapun yang kira – kira bisa dilakukan
oleh seorang mahasiswa informatika.
untuk mendeklarasikan method caranya mudah, method harus ada di dalam kelas misal kita
punya kelas MahasiswaInformatika,
class MahasiswaInformatika{
}
deklarasi method adalah dengan menulis :
[sifat akses ] [tipe kembalian] [nama method] (parameter jika ada) {
}
Misal kita ingin membuat method dengan sifat akses public, tipe kembalian void, dan
nama method adalah berhitung, lalu parameter atau inputannya adalah nilai – nilai yang ingin
dihitung maka deklarasikan method dengan mengetik
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class MahasiswaInformatika{
public void berhitung(int, int l){
//method ini menghitung luas persegipanjang dengan panjang = p dan lebar = l, tipe data
keduanya adalah integer
int luas;
luas = p*l;
//lalu mencetaknya
System.out.println("luas persegi panjang dengan panjang "+p+" dan lebar "+l+" adalah
"+luas);
}
//method main agar class ini bisa di RUN langsung

16
17
18
19
20
21
//membuat object dari kelas MahasiswaInformatika
MahasiswaInformatika alka = new MahasiswaInformatika()
alka.berhitung(5,3) ;
}
}
Jika anda belum paham dengan kata public dan void, silahkan baca hak akses dan tipe
kembalian kira – kira seperti itu cara membuat method anda bisa kembangakan dengan fungsi
yang lebih kompleks.

CARA MENULIS / MEMBUAT METHOD DI JAVA
Sebuah method menurut saya adalah kode yang menjelaskan sesuatu yang dapat
dikerjakan oleh sebuah kelas / object, misalkan anda memiliki kelas Penjumlahan maka bisa
diperkirakan salah satu methodnya adalah menjumlah(). langsung saja
(kode tepat dibawah ini tidak bisa dicompile, hanya untuk menjelaskan saja)
penulisan method adalah
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
tipeAkses TipeKembalian namaMethod(){}
atau
tipeAkses TipeKembalian namaMethod(tipeParameter1 parameter1,
tipeParameter2 parameter2){}
tipeParameter bisa int, String, double, float, Object, Kelas, array
atau
final tipeAkses TipeKembalian namaMethod(){}
atau
tipeAkses static TipeKembalian namaMethod(){}
contoh1
public void menjumlah(){} ->> tipe kembali void==tidak kembali apa2
private String menjumlah(){} ->> mengembalikan String
int menjumlah(){} ->> mengembalikan integer
contoh2
public void menjumlah(int a, int b){} ->> dengan paramether
public String menjumlah(int a, int b){} ->> dengan parameter dan tipe
kembali String
contoh3
public final void menjumlah(){} --> dengan keyword final
contoh4
public static void main(String[] args) dengan keyword static,
tanpa tipe kembali dan parameter array dari String

method harus ditulis dalam kurung kurawal {} kelas, misalnya kita punya kelas
dengan nama Penjumlahan dan method menjumlah() maka cara penulisannya adalah
1
2
3
4
5
6
class Penjumlahan{
void menjumlah(){
}
}
tidak boleh ditulis
1
2
3
4
class Penjumlahan{
}
void menjumlah(){
}
method dapat diberi tipe akses (private,protected, public ) juga keyword final. jika
method diberi tipe akses public maka method ini dapat dipanggil dimana saja oleh
object dari kelasnya, jika protected hanya bisa dipanggil oleh object dimana kode
object berada dalam satu package / paket / folder dengan file kelasnya. jika private
maka hanya bisa dipanggil di dalam kelasnya. langsung saja ke contoh pemanggilan
method lewat object
1
2
3
4
5
6
7
8
9
10
11
12
class Penjumlahan{
//bisa private void menjumlah()
//bisa protected void menjumlah()
//bisa juga hanya void menjumlah() -> artinya tipe aksesnya default
public void menjumlah(){
}
Penjumlahan objectPenjumlahan = new Penjumlanan(); //menciptakan object
objectPenjumlahan.menjumlah(); //memanggil method

13
14
15
16
17
//atau bisa juga langsung menciptakan object tanpa nama lalu langsung memanggil method
new Penjumlahan().menjumlah();
}
}
Pemanggilan method dilakukan di dalam kelas yang sama, jika dilakukan di kelas yang
berbeda caranya pun sama dapat menggunakan object dot namaMethod(); terdapat method
main yang berfungsi sebagai method yang harus ada jika ingin file java dapat di eksekusi,
penciptaan object juga bisa dilakukan di method main yang jelas ketika ingin mengeksekusi
sebuah file java haruslah ada method main.
method memiliki tipe kembalian (return value) kita telah menulis method dengan
return value VOID atau tidak mengembalikan apapun. bagaimana jika
mengembalikan sesuatu misal kita buat method menjumlah() mengembalikan nilai
berupa integer.
1
2
3
4
5
6
7
public int menjumlah(){
int i = 2;
int j = 3;
int c = 2+3;
return c;
}
Bisa dilihat ada kata return, maka dia akan mengembalikan nilai yang ada setelah
kata return, dalam contoh return mengembalikan nilai c yaitu 5. Selain tipe kembalian void,
perintah return harus ditulis, dan harus sesuai, jika ditulis String maka kembaliannya pun
harus String, karena di contoh ditulis int maka kembaliannya pun harus int juga. bagaimana
kalau method menjumlah() kita buat mengembalikan nilai String, sangat bisa ini kodenya.
1
2
3
4
5
public String menjumlah(){
int i = 2;
int j = 3;
int c = 2+3;

6
7
8
9
String s = "hasil dari 2 + 3 adalah "+c;
return s;
}
Maka method menjumlah() akan mengembalikan nilai String yaitu s. selanjutnya
bagaimana penggunaan method yang me-return value selain void ? nilai dari return dapat
digunakan untuk proses selanjutnya , contohnya adalah dimasukkan ke dalam variabel lain
yang tipenya sama , misal method menjumlah() yang mengembalikan int dapat dipanggil
sebagai berikut
Penjumlahan p = new Penjumlahan();
int a = p.menjumlah();
System.out.println(a);
Kode diatas akan mencetak nilai a, nilai a adalah return value dari menjumlah() yaitu
c = 5, maka akan dicetak 5;
Selain int dan String, sebuah method juga dapat mengembalikan tipe yang lain.
bila diberi kata-kata static, maka pemanggilan method harus lewat kelas, bukan lewat
object, jika method menjumlah dirubah menjadi
public static int menjumlah(){
int i = 2;
int j = 3;
int c = 2+3;
return c;
}
maka pemanggilan method menjadi
Penjumlahan.menjumlah();
bukan melalui object seperti ini
Penjumlahan objectP = new Penjumlahan();
objectP.menjumlah();
//bukan juga dengan cara seperti ini
new Penjumlahan().menjumlah();

INTERFACE DI JAVA
Kelas abstrak yaitu kelas yang belum jelas (memiliki method yang belum bisa
diimplementasikan). kali ini akan kita bahas interface, jika kita pelajari interface sebenarnya
mirip dengan interface yaitu sama – sama memiliki method yang belum diimplementasikan.
tapi ada perbedaannya :
kalau di abstract class untuk menurunkannya menggunakan keyword extends, kalau
di interface kita gunakan keyword implements.
jika kelas hanya bisa meng-extends satu super class, sedangkan di kasus interface
sebuah kelas dapat meng-implements banyak interface.
jika sebuah kelas meng-extends super class, maka subclass harus lah sesuai atau
nyambung. misalnya kelas hewan diturunkan menjadi sapi atau kerbau. sapi adalah
hewan dan kerbau adalah hewan. jika di kasus interface tidak harus seperti itu. misal
kita punya interface dengan nama “Singable” yang memiliki method dengan nama
bernyanyi. maka jika sebuah kelas meng-implemets interface “Singable” dia akan
dapat bernyanyi. misalnya Sapi implements Singable maka sapi akan bisa bernyanyi
begitu juga jika Manusia implements Singable maka Manusia akan bisa bernyanyi,
padahal sapi dan manusia sangat jauh berbeda jika dibandingkan dengan sapi dan
kerbau. mari kita nikmati contohnya. saya akan membuat sebuah interface di java
menggunakan netbeans dengan cara:
Dalam sebuah project buatlah kelas dengan menekan menu File -> new File – > java ->
java interface. lalu tekan next dan beri nama Singable. lalu tekan finish. lengkapi kodenya
menjadi seperti ini.
1
2
3
public interface Singable {
public void bernyanyi();
}
Lalu kita buat kelas yang akan meng-implements interface Singable yaitu kelas Sapi
dan Manusia, kita buat kelas Manusia dulu di netbeans.
1
2
3
4
public class Manusia implements Singable{
@hermwan
public void bernyanyi() {

5
6
7
8
System.out.println("lalala... akuuuu adalah giant.... lalalala....");
}
}
lalu kita buat kelas Sapi
1
2
3
4
5
6
7
8
public class Sapi implements Singable{
hermawan
public void bernyanyi() {
System.out.println("moooooooooooooooooooo");
}
}
Dalam pembuatan kelas yang mengimplementasi interface, jika kelasnya adalah kelas
kongkret(bukan abstract class) maka seluruh method yang ada di interface haruslah di
override (di devinisikan ulang) dan diberi kode detail untuk implementasinya, karena pada
interface methodnya belum mempunyai isi / implementasi.
jika interface di implementasi oleh abstract class maka tidak perlu mendefinisikan ulang
semua method yang ada pada interface.
Untuk menggunakannya maka bisa dengan membuat kelas Testnya yang memiliki
method main silahkan buat kelas testnya dengan nama TestInterface yang kodenya
1
2
3
4
5
6
7
8
9
10
public class TestInterface{
Sapi objectSapi = new Sapi();
Manusia objectMan = new Manusia();
objectSapi.bernyanyi();
objectMan.bernyanyi();
}
}
Silahkan di RUN (Shift + F6).

INHERITANCE DI JAVA
Inheritance artinya penurunan atau pewarisan, dalam pemrograman terutama Java
inheritance adalah pewarisan sifat – sifat yang dimiliki sebuah kelas kepada subkelas(kelas
turunan). yang diwariskan diantaranya.
variabel
method
Di Java, cara membuat turunan dari sebuah kelas adalah dengan kata “extends”, misalnya
anda punya Kelas “Animal” lalu anda ingin memecah lagi menjadi yang lebih spesifik
menjadi “Kucing”, “Anjing”, “Harimau” maka cara membuatnya adalah :
1. membuat kelas bernama Animal
class Animal{}
2. buat turunan dari kelas sepeda yaitu Kucing, Anjing, Harimau
1
2
3
4
class Kucing extends Animal{}
class Anjing extends Animal{}
class Harimau extends Animal{}
Baiklah, seperti itulah caranya. mari kita coba membuatnya agar bisa dijalankan
programnya
1. buatlah kelas Animal lengkap dengan variabel dan methodnya, jika belum tahu caranya
lihat tutorial sebelumnya
1
2
3
4
5
6
7
8
9
10
11
class Animal{
String makanan;
String suara;
//konstruktor
public Animal(String makanan, String suara){
System.out.println("tercipta hewan yang belum jelas");
this.makanan = makanan;
this.suara = suara;
}

12
13
14
15
16
17
18
19
20
21
22
//method - method
void makan(){
System.out.println(".....");
}
void bersuara(){
System.out.println(".....");
}
}
2. buatlah kelas Kucing
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Kucing extends Animal {
String jenisKucing;
//konstruktor
public Kucing(String makanan, String suara, String jenisKucing){
super(makanan,suara);
this.jenisKucing = jenisKucing;
System.out.println("tercipta kucing "+jenisKucing);
}
//overide method makan
void makan(){
System.out.println("kucing memakan "+this.makanan);
}
//override mthod bersuara
void bersuara(){
System.out.println("Kucing suaranya "+suara);
}

22}
3. buatlah kelas untuk mengetesnya dengan nama AnimalTest atau yang lainnya terserah
anda
1
2
3
4
5
6
7
8
9
10
11
class AnimalTest {
Animal animal = new Animal("nasi", "hmmm");
animal.makan();
animal.bersuara();
System.out.println();
Kucing anggora = new Kucing("Ikan","miau..miau..miau","anggora");
anggora.makan();
anggora.bersuara();
}
}
Sebagai latihan buatlah juga kelas anjing dan harimau lalu buat objectnya dan test.

CONTOH LATIHAN INHERITANCE DI JAVA (BANGUN DATAR)
Saya ingin membuat program sederhana yang berfungsi untuk menghitung luas dari
bangun datar, dimana bangun datarnya diantaranya segi empat, persegi panjang dan segitiga.
apa yang harus dilakukan ? ikuti langkah berikut :
1. buat kelas bangun datar dengan nama BangunDatar.java, bangun datar ini hanya
memiliki fungsi menghitung luas dan keliling yang belum jelas.
1
2
3
4
5
6
7
8
9
10
11
public class BangunDatar {
public void hitungLuas()
{
System.out.println("belum terdefinisi / belum jelas luas apa yang di hitung");
}
public void hitungKeliling(){
System.out.println("belum terdefinisi / belum jelas keliling apa yang di hitung");
}
}
2. lalu buat kelas turunan dari kelas BangunDatar, atau dengan kata lain buat subclass
dari BangunDatar, saya ambil contoh kelasnya adalah kelas segi empat dengan nama
SegiEmpat.java, kelas ini sudah jelas dapat menghitung luas segi empat dengan cara
mendefiniskan ulang method superclass nya atau istilahnya mengoverride method dari
superclass nya yaitu kelas BangunDatar, method yang di override adalah method
hitungLuas. kini methodnya sudah jelas dapat melakukan sesuatu yaitu menghitung
luas, kita juga mengoverride method hitungKeliling.
1
2
3
4
5
6
public class SegiEmpat extends BangunDatar{
//deklarasi variabel
double sisi;
//deklarasi method konstruktor tanpa parameter
public SegiEmpat(){

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
}
//deklarasi method konstruktor dengan parameter
public SegiEmpat(double inputsisi){
this.sisi = inputsisi; // menentukan nilai dari variabel sisi adalah parameter inputsisi
}
//deklarasi method untuk menentukan nilai dari variabel sisi
public void setSisi(double inputsisi){
this.sisi = inputsisi;
}
//deklarasi method untuk menghitung luas dengan mengoverride method hitungLuas
//dari superclass nya (kelas BangunDatar)
@hermawan
public void hitungLuas(){
double luas ; //deklarasi variabel lokal
luas = this.sisi * this.sisi;
//mencetak luas
System.out.println("luas segi empat dengan sisi "+sisi+" cm adalah "+luas+" cm
kuadrat");
public void hitungKeliling(){
double keliling ; //deklarasi variabel lokal
keliling = this.sisi * 4;
//mencetak luas
System.out.println("keliling segi empat dengan sisi "+sisi+" cm adalah "+keliling+"
cm.");
}
}
3. selanjutnya kita tinggal membuat kelas yang berfungsi untuk mengetes apakah kelas
BangunDatar dan kelas turunannya yaitu SegiEmpat bisa berjalan dengan baik. kita

beri nama kelas ini BangunDatarTest.java , pembuatan kelas ini agar bisa
mengetesnya adalah sebagai berikut :
a. buat kelasnya public class BangunDatarTest{ }
b. agar bisa di RUN maka kelas ini membutuhkan method khusus yaitu method
“main”, kode kita menjadi public class BangunDatarTest { public static void
main(String[] args){
}
}
c. setelah method main ada, maka kita akan menciptakan object dari masing – masing
kelas dan kode kita akan menjadi seperti ini
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class BangunDatarTest {
//buat objek dari kelas BangunDatar
BangunDatar bd = new BangunDatar();
//membuat objek bd melakukan sesuatu
bd.hitungLuas();
bd.hitungKeliling();
//buatObjek dari Kelas SegiEmpat dengan nama sg
SegiEmpat sg = new SegiEmpat(500);
//membuat objek sg melakukan sesuatu sesuai method yang dipunyai oleh kelas
segiempat
sg.hitungLuas();
sg.hitungKeliling();
}
}
Sebagai latihan anda juga bisa membuat kelas turunan lainnya dari BangunDatar
seperti kelas persegi panjang, kelas segitiga. tentu variabel dan methodnya akan
menyesuaikan dengan kegunaan dari kelas masing masing, misal untuk kelas persegi panjang
variabelnya adalah panjang dan lebar, lalu untuk segitiga variabelnya adalah alas dan tinggi,
untuk methodnya buatlah methodnya dapat menghitung luas dan keliling sesuai dengan jenis
bangun datarnya.

CONTOH LATIHAN POLYMORFISME
Polymorphism adalah salahsatu konsep OOP yang sangat penting di JAVA. kalau
diterjemahkan secara bebas artinya sebuah object bisa memiliki banyak bentuk. namun tidak
ada yang bisa lebih menjelaskan daripada kode :) hehe langsung saja kita buat kodenya
buatlah sebuah interface yang akan kita gunakan sebagai manipulasi bentuk dari
object yang akan kita buat
1
2
3
4
5
public interface MahlukHidup {
void bergerak();
void makan();
void describeName();
}
Interfacenya bersifat sesuai denga namanya yaitu seperti mahluk hidup, bisa bergerak,
bisa makan. jadi…kelas apa saja yang meng-implement interface MahlukHidup, secara tidak
langsung akan menjadi mehluk hidup (bisa makan bisa bergerak). meskipun kelasnya
berbeda2, bahkan bukan kelas turunan dari mahluk hidup jika sudah meng-implement
interface MahlukHidup. tak perduli dia kelas mahluk hidup atau kelas yang lain, tetapi kita
coba buat beberapa kelas mahluk hidup kelas pertama seperti ini.
1
2
3
4
5
6
7
8
9
10
11
12
13
class Manusia implements MahlukHidup{
String nama = "manusia";
@hermawan
public void bergerak() {
System.out.println("bergerak dengan 2 kaki");
}
@Override
public void makan() {
System.out.println("makan nasi atau makanan manusia lainnya");
}

14
15
16
17
18
19
20
@hermawan
public void describeName() {
System.out.println(nama);
}
}
Kelas pertama adalah kelas Manusia, begitu dia meng-implement interface
MahlukHidup, dia dipaksa untuk mengoverride(mendefinisikan kembali) dan
mengimplement(membuat method bekerja sesuai kelasnya) method abstract yang dituliskan
di interface tadi, oke kita buat kelas yang kedua
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Kucing implements MahlukHidup{
String nama = "Kucing Lucu";
@hermawan
System.out.println("bergerak dengan 4 kaki");
}
@hermawan
System.out.println("makan ikan");
}
@hermawan
}
}

lalu kelas yang ke tiga
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class PohonPisang implements MahlukHidup{
String nama = "Pohon Pisang";
@hermawan
System.out.println("bertumbuh ke atas");
}
@hermawan
System.out.println("makan makanan berupa mineral dan sari - sari makanan dalam
tanah");
}
@hermawan
}
}
Jadi bisa kita lihat ketiga kelas adalah kelas yang berbeda dan jelas beda keturunan.
tetapi mereka menjadi punya persamaan, yaitu mereka adalah MahlukHidup karena sama-
sama mengimplement interface MahlukHidup. sekarang mari kita belajar dimana letak
polimorphismenya , buatlah kelas Testnya seperti ini
1
2
3
4
5
6
class Poli {
public static void TestMahlukHidup(MahlukHidup m){
m.describeName();
m.bergerak();
m.makan();

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
}
MahlukHidup man = new Manusia();
MahlukHidup kucing = new Kucing();
MahlukHidup pohon = new PohonPisang();
TestMahlukHidup(man);
System.out.println("_________________");
TestMahlukHidup(kucing);
TestMahlukHidup(pohon);
}
}
bisa kita lihat bahwa penciptaan kelas dilakukan dengan nama kelas MahlukHidup lalu
kontruktornya adalah milik kelas masing2.. coba perhatikan method
1
2
3
4
5
6
public static void TestMahlukHidup(MahlukHidup m){
m.describeName();
m.bergerak();
m.makan();
}
Method ini meminta input parameter merupa MahlukHidup. dan menjalankan method
dari MahlukHidup. dan yang kita masukkan adalah object dari kelas – kelas yang berbeda,
yaitu man, kucing, pohon. secara otomatis mereka akan menjalankan methodnya yang
spesifik untuk jenis kelas mereka.

AGREGASI, KELAS YANG MEMILIKI VARIABLE DENGAN TIPE KELAS
YANG LAIN
Kali ini kita akan bahas kasus yang sering kita jumpai yaitu ketika sebuah kelas
memiliki variable yang tipenya bukan lagi data primitif tapi berupa kelas lain, sebenarnya
kita sudah sering menggunakannya, contohnya adalah String, String adalah sebuah kelas java.
contoh lain adalah jika kita membuat kelas dengan nama Mobil dan memiliki variable mesin
dan roda, mesin dan roda ini pasti memiliki merk dan nama serta ukuran. jadi, sebuah
variable bisa saja memiliki variable juga misalnya nama_roda atau nama_mesin oleh karena
itu kita perlu membuat kelas baru dengan nama Mesin dan kelas baru dengan nama Roda.
lalu kedua kelas ini dipakai dalam kela Mobil. contoh singkatnya seperti ini.
1
2
3
4
class Mesin{
String nama;
String teknologi;
}
lalu kita buat kelas Roda
1
2
3
4
5
class Roda{
String merk;
int ukuran;
}
setelah itu kita buat kelas utama yaitu Mobil
1
2
3
4
5
6
class Mobil{
String namaMobil;
Mesin mesin;
Roda roda;
}
Sekarang kita buat yang sedikit lebih banyak kodenya , pertama kita buat kelas
kalkulator yang memiliki method untuk menghitung penjumlahan, pengurangan, perkalian,
pembagian.sederhana saja.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Kalkulator {
public double penjumlahan(double angka1, double angka2){
return angka1 + angka2;
}
public double pengurangan(double angka1, double angka2 ){
return angka1 - angka2;
}
public double perkalian(double angka1, double angka2){
return angka1 * angka2;
}
public double pembagian(double angka1, double angka2){
return angka1 / angka2;
}
}
Setelah kelas kalkulator jadi, kita akan gunakan untuk keperluan kelas lain yaitu kelas
Person, nanti niatnya kelas Person ini bisa menghitung tanpa harus membuat method
menghitung lagi, yaitu dengan memanfaatkan kelas Kalkulator, berikut ini kodenya
1
2
3
4
5
6
7
8
9
10
import java.util.Scanner;
public class Person {
Kalkulator hitung;
double x, y;
public Person() {
hitung = new Kalkulator();
}

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public void ambilInput(Scanner s) {
System.out.print("masukkan bilangan pertama : ");
x = s.nextDouble();
System.out.print("masukkan bilangan kedua : ");
y = s.nextDouble();
}
public static void main(String[] args) {
Person objekPerson = new Person();
Scanner scan = new Scanner(System.in);
String yes = "";
do {
System.out.println("1. penjumlahan");
System.out.println("2. pengurangan");
System.out.println("3. perkalian");
System.out.println("4. pembagian");
System.out.println("5. exit");
System.out.print("silahkan pilih : ");
int pilihan = scan.nextInt();
if (pilihan == 5) {
System.exit(0);
} else {
switch (pilihan) {
case 1:
objekPerson.ambilInput(scan);
System.out.println("hasilnya : " +
objekPerson.hitung.penjumlahan(objekPerson.x, objekPerson.y));
break;
case 2:

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
objekPerson.hitung.pengurangan(objekPerson.x, objekPerson.y));
break;
case 3:
objekPerson.hitung.perkalian(objekPerson.x, objekPerson.y));
break;
case 4:
objekPerson.hitung.pembagian(objekPerson.x, objekPerson.y));
break;
}
}
System.out.println("ulangi ? (y/n) : ");
yes = scan.next();
for (int i = 0; i < 5; i++) {
System.out.println("");
}
} while (!yes.equals("n"));
}
}

Pelajaran oop java ii pengertian method dan cara pembuatan method by hermawan

More Related Content

What's hot (20)

Similar to Pelajaran oop java ii pengertian method dan cara pembuatan method by hermawan (20)

Recently uploaded (12)

Pelajaran oop java ii pengertian method dan cara pembuatan method by hermawan