Java2D | Animasi thread pelanggaran lalu lintas

Postingan kali ini kita akan membahas mengenai animasi thread dengan java, namun kali ini saya tidak akan menjelaskan satu persatu mengenai program tersebut. mungkin lain waktu akan saya jelaskan.. :)
Bagi anda yang ingin mengembangkan animasi ini anda bisa mendownloadnya disini

Interface dalam java

Oke tanpa panjang lebar, langsung pada bahasan kita yang masih mengenai pemrograman berorientasi objek, sub bab kali ini membahas tentang interface, apakah itu???
interface adalah Jenis khusus dari blok yang hanya berisi method signature (atau constant ). Interface mendefinisikan sebuah kumpulan method tanpa tubuh.
Interface mendefinisikan sebuah cara standar dan umum dalam menetapkan sifat-sifat dari class-class. Mereka menyediakan class-class, tanpa memperhatikan lokasinya dalam hirarki class, untuk mengimplementasikan sifat-sifat yang umum. Dengan catatan bahwa interface-interface juga menunjukkan polimorfisme.
Untuk memanggil class interface ini kita harus menambahkan keyword implement setelah nama class dan setelah itu tambahkan nama class interface tadi..
langsung ke program agar tidak bingung.
Contoh program kali ini kita akan membuat aplikasi bank sederhana yang menerapkan konsep interface tentunya..
Pertama buat kelas interface berikut:

/**
*
* @author syauqil
*/
public interface InterfaceBank {


void deposit(double Ammout);
boolean withDraw(double Ammout);
double cekSaldo();


}

Setelah buat class yang mengimplement class interface diatas, source codenya sebagai berikut:

/**
*
* @author syauqil
*/
public class BankImplement implements InterfaceBank {


double saldo;
double WithDraw;


public BankImplement(double Ammout) {
saldo = Ammout;
}


public void deposit(double Ammout) {
System.out.println("\nSaldo : " + saldo);
System.out.println("deposit anda : " + Ammout);
saldo = saldo + Ammout;
System.out.println("Saldo Sekarang adalah : " + saldo);
}


public boolean withDraw(double Ammout) {
boolean ambil = false;
WithDraw = Ammout;
System.out.println("\nWithDraw anda adalah : " + WithDraw);
if (saldo > Ammout) {
saldo = saldo - WithDraw;
System.out.println("Saldo Sekarang adalah : " + saldo);
} else {
System.out.println("WithDraw is Rejected " + "Saldo :" + saldo);
}
return ambil;
}


public double cekSaldo() {
System.out.println("\nSaldo Anda sekarang adalah " + saldo);
return saldo;
}
}

Nah sekarang tinggal buat class main yang akan menjalankan program kita diatas, berikut codenya:

/**
 *
 * @author syauqil
 */
public class BankApp {

    public static void main(String[] args) {
        InterfaceBank ib = new BankImplement(125000);
        for(int i=0; i<2; i++){
        ib.deposit(Math.random() * 99999);
        ib.withDraw(Math.random() * 99999);
        ib.cekSaldo();
        }
    }
}

Polimorfisme Java

Oke sekarang masuk pada sub bab selanjutnya yaitu bahasan tentang polimorfisme. Apa sich polimorfisme itu????
polimorfisme adalah turunan dari bahasa latin yang artinya banyak bentuk.. nah ap maksudnya???
maksudnya adalah polimorfisme mengizinkan kelas induk mendefinisikan sebuah method general untuk semua kelas turunannya, dan selanjutnya kelas turunandapat memperbaharui implementasi dari method tersebut secara lebih spesifik sesuai dengan karakteristiknya masing masing.
gimana udah paham??? kalo lom paham mari langsung ke source codenya..
kita akan membuat aplikasi penghitung gaji pegawai sederhana yang memiliki 3 aktor.
pertama kita buat class pegawai sebagai induk class-nya..

public class Pegawai {


public int gaji;
public void hitungGaji(){
return;
}
}

selanjutnya kita buat aktor yang pertama yaitu direktur

import javax.swing.JOptionPane;


/**
*
* @author syauqil
*/
public class Direktur extends Pegawai {


@Override
public void hitungGaji() {
try {
gaji = Integer.parseInt(JOptionPane.showInputDialog("Masukkan gaji"));
int tunjanganF = Integer.parseInt(JOptionPane.showInputDialog("Masukkan Tunjangan Fungsional" ));
int tunjanganJ = Integer.parseInt(JOptionPane.showInputDialog("Masukkan Tunjangan jabatan"));
JOptionPane.showMessageDialog(null, "Gaji Direktur adalah:\n"
+ (gaji + tunjanganF + tunjanganJ));
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Karakter yang Anda masukkan tidak sesuai");
}
}
}

aktor selanjutnya adalah manager

import javax.swing.JOptionPane;


/**
*
* @author syauqil
*/
public class Manager extends Pegawai {


@Override
public void hitungGaji() {
try {
gaji = Integer.parseInt(JOptionPane.showInputDialog("Masukkan gaji"));
int gajiTunjangan = Integer.parseInt(JOptionPane.showInputDialog("Masukkan Tunjangan "));
JOptionPane.showMessageDialog(null, "Gaji Manager adalah:\n"
+ (gaji + gajiTunjangan));
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Karakter yang Anda masukkan tidak sesuai");
}
}
}

aktor yang terakhir adalah OB

import javax.swing.JOptionPane;


/**
*
* @author syauqil
*/
public class OB extends Pegawai {


@Override
public void hitungGaji() {
try {
gaji = Integer.parseInt(JOptionPane.showInputDialog("Masukkan gaji"));
int makan = Integer.parseInt(JOptionPane.showInputDialog("Masukkan Uang makan"));
JOptionPane.showMessageDialog(null, "Gaji OB adalah:\n"
+ (gaji + makan));
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Karakter yang Anda masukkan tidak sesuai");
}
}
}

Nah sekarang tinggal buat class main serta nerapin konsep polimorfisme yang menjadi bahasan kita kali ini

import javax.swing.JOptionPane;


/**
*
* @author syauqil
*/
public class main {


public static void main(String[] args) {


Pegawai pegawai = new Pegawai();
Manager manager = new Manager();
Direktur direktur = new Direktur();
OB ob = new OB();


String pilihan = JOptionPane.showInputDialog(null, "Pilihan :\n"
+ "1. Manager \n"
+ "2. Direktur \n"
+ "3. OB");
int pilih = Integer.parseInt(pilihan);
switch (pilih) {
case 1:
pegawai = manager;
pegawai.hitungGaji();
break;
case 2:
pegawai = direktur;
pegawai.hitungGaji();
break;
case 3:
pegawai = ob;
pegawai.hitungGaji();
break;
default:
break;
}
}
}

Gimana?? mudah sekali bukan...
sekian terima kasih.. salam JAVATAR..

Inheritance (pewarisan) java

Selanjutnya masih mengenai pemrograman berorientasi objek pada sub bab inheritance..
inti dari inheritance / pewarisan adalah suatu subclass dapat mewarisi semua atau sebagian member dari parent classnya. .
untuk menerapkan inheritance dalam java kita harus menambahkan keyword extends setelah deklarasi nama class kemudian diikuti nama parent class-nya..
Dalam inheritance semua file akan diwariskan kecuali file bertipe private.
untuk contoh program adalah sebagai berikut..
pertama kita buat dulu kelas induknya yang ntar bakal diwariskan ke subclass-nya

public class Manusia {

String nama;
int umur;
String pekerjaan;

public Manusia(String nm, int um, String pkj) {
this.nama = nm;
this.umur = um;
this.pekerjaan = pkj;
}

public String tampilkanNama() {
return nama;
}

public int tampilkanUmur() {
return umur;
}

public String tampilkanPekerjaan() {
return pekerjaan;
}

public void olahraga() {
System.out.println("Jogging");
}

public void kerja() {
System.out.println(" ");
}
}

sekarang kita buat anak kelasnya

public class Programmer extends Manusia{

public Programmer(String nm4, int um4, String pkj4) {
super(nm4, um4, pkj4);
}

@Override
public void kerja() {
System.out.println("tik tak tok");
}
}

sekarang kita buat kelas main-nya

public class main {

public static void main(String args []){
Manusia orang1 = new Programmer("Syauqil", 20, "Programmer");
System.out.println("Nama :"+orang1.tampilkanNama());
System.out.println("Nama :"+orang1.tampilkanUmur());
System.out.println("Nama :"+orang1.tampilkanPekerjaan());
orang1.olahraga();
orang1.kerja();
}
}

Enkapsulasi - Pemrograman Berorientasi Objek

Postingan kali ini kita akan membahas mengenai pemrograman berorientasi objek, tentunya menggunakan JAVA, yang pertama kita menuju pada pembahasan tentang Enkapsulasi (pengkapsulan). Pengkapsulan memiliki arti mengelompokkan program dalan satu unit sehingga program mudah untuk digunakan.
Tujuan digunakannya enkapsulasi yaitu untuk melindungi program dari pengaksesan variabel kritis atau perubahan oleh programmer selama tahap pembangunan program.
Enkapsulasi memiliki manfaat sebagai berikut:
> Modularitas
    Source code dari sebuah class dapat dikelola secara independen dari source code class yang lain. Perubahan internal pada sebuah class tidak akan berpengaruh bagi class yang menggunakannya.
> Information Hiding
Penyembunyian informasi yang tidak perlu diketahui objek lain.
Langsung ke contoh program ya biar tidak bingung...
Sekarang buka netbeans buat class dengan nama mahasiswa...

public class Mahasiswa {

private String nama;
private String npm;

public Mahasiswa(String n, String npm) {
this.nama = n;
this.npm = npm;
}

public String tampilkanNama() {
return nama;
}

public String tampilkanNpm() {
return npm;
}

public void makan() {
System.out.println("Nyam... Nyam... Nyam...");
}

public void minum() {
System.out.println("segaaarrrr......");
}

public void olahraga() {
System.out.println("Sehat sehat sehat");
}

public void Belajar() {
System.out.println("Pintar pintar pintar");
}
}

Nah sekarang kita buat kelas main-nya

public class main {

public static void main(String[] args) {
Mahasiswa syauqil = new Mahasiswa("Syauqil", "000000000");
System.out.println("Nama \t : " + syauqil.tampilkanNama());
System.out.println("NIM \t : " + syauqil.tampilkanNpm());
syauqil.makan();
syauqil.minum();
syauqil.Belajar();
syauqil.olahraga();
System.out.println();

Mahasiswa anda = new Mahasiswa("Anda", "000000001");
System.out.println("Nama \t : " + anda.tampilkanNama());
System.out.println("NIM \t : " + anda.tampilkanNpm());
anda.makan();
anda.minum();
anda.Belajar();
anda.olahraga();
System.out.println();

Mahasiswa kamu = new Mahasiswa("Kamu", "000000002");
System.out.println("Nama \t : " + kamu.tampilkanNama());
System.out.println("NIM \t : " + kamu.tampilkanNpm());
kamu.makan();
kamu.minum();
kamu.Belajar();
kamu.olahraga();
System.out.println();
}
}

Sekarang tinggal jalanin dech,, :-)
Sekian terima kasih