Konsep Dasar dalam Java

            OOP berputar pada konsep dari obyek yang merupakan elemen dasar dari program Anda. Ketika kita membandingkan dengan dunia nyata, kita dapat menemukan beberapa obyek disekitar kita seperti mobil, singa, manusia dan seterusnya. Obyek ini dikarakterisasi oleh atribut dan tingkah lakunya.Di dalam OOP dibagi 4 konsep dasar pemrograman,yaitu:

1. Abstraction (filtering/memilah-milah)

    Abstraksi mengabaikan aspek dari subyek yang tidak sesuai dengan tujuan yang ada supaya lebih banyak mengkonsentrasikan yang ada.

2. Encapsulation (membungkus data)

    Enkapsulasi menunjuk pada prinsip dari menyembunyikan desain atau mengimplementasikan informasi yang tidak sesuai pada object yang ada.Sementara enkapsulasi menyembunyikan detail.

3. Inheritence (penurunan/generalisasi)

    Inheritence adalah hubungan antara class dimana dalam satu class ada superclass atau class induk dari class yang lain. Inheritence menunjuk pada properti dan behaviour yang diterima dari nenek moyang dari class. Ini dikenal juga sebagai hubungan “is-a”.

4. Polymorph (bentuk khusus)

    Polymorph adalah setiap anak dari induk yang sama mempunyai sifat yang berbeda.

      Sebelum melangkah pada fitur-fitur menarik yang ada pada Java, mari kita meninjau beberapa hal yang telah Anda pelajari pada pelajaran pemograman pertama Anda. Pelajaran ini menyajikan diskusi tentang perbedaan konsep-konsep berorientasi object dalam Java.Sebelum melengkapi pelajaran ini, Anda sebaiknya mampu untuk:

1. Mengetahui dan menggunakan konsep dasar beorientasi object.

· class
· object
· atribut
· method
· konstruktor

2. Mengetahui dengan jelas penggunaan kata kunci this, super, final dan static

3. Membedakan antara method overloading dan method overridding

A. Konsep Berorientasi object 

1. Class

          Class adalah struktur dasar dari pemrograman berorientasi objek yang mendefinisikan variable dan  method-method pada seluruh objek tertentu. 

          Class juga mendefinisikan tipe data baru untuk menciptakan model dari objek yang dibuat sesuai dengan tipe data baru tersebut. Dengan kata lain class menciptakan instant dari objek. class juga merupakan grup suatu object dengan kemiripan attributes/properties, behaviour dan relasi ke object lain.

Mendeklarasikan class Java:

<classDeclaration> ::=
<modifier> class <name> {
<attributeDeclaration>*
<constructorDeclaration>*
<methodDeclaration>*
}

dimana <modifier> adalah sebuah access modifier, yang mana boleh dikombinasikan dengan tipe
yang laen dari modifier.

Contoh berikut ini mendeklarasikan blueprint SuperHero.

Class SuperHero {
String superPowers[];
void setSuperPowers(String superPowers[]) {
this.superPowers = superPowers;
}
void printSuperPowers() {
for (int i = 0; i < superPowers.length; i++) {
System.out.println(superPowers[i]);
           }
}
   }

2.  Object

     Objek adalah instance dari class. Objek merupakan perangkat lunak yang berisi sekumpulan variable dan method-method terkait. Objek merupakan entitas yang memiliki keadaan, behaviour dan identitas yang tugasnya dirumuskan dalam suatu lingkup masalah dengan baik.

3. Attribute

    Atribut menunjuk pada elemen data dari sebuah object. Atribut menyimpan informasi tentang object.Dikenal juga sebagai member data, variabel instance, properti atau sebuah field data.

Mendeklarasikan Atribut:

<attributeDeclaration> ::=
<modifier> <type> <name> [= <default_value>];
<type> ::=
byte | short | int | long | char | float | double | boolean
| <class>

Petunjuk Penulisan Program:
        [] = Menunjukkan bahwa bagian ini hanya pilihan.

Inilah contohnya.
public class AttributeDemo {
private String studNum;
public boolean graduating = false;
protected float unitsTaken = 0.0f;
String college;
}

4. Method

    Sebuah method menjelaskan behaviour dari sebuah object. Method juga dikenal sebagai fungsi atau prosedur. Sebagai contoh, method yang mungkin tersedia untuk entiti siswa adalah method register.
Mendeklarasikan Method:
<methodDeclaration> ::=
<modifier> <returnType> <name>(<parameter>*) {
<statement>*
}
<parameter> ::=
<parameter_type> <parameter_name>[,] 
Sebagai contoh:
class MethodDemo {
int data;
int getData() {
return data;
}
void setData(int data) {
this.data = data;
}
void setMaxData(int data1, int data2) {
data = (data1>data2)? data1 : data2;
}
}

5. Konstruktor

   Konstruktor adalah sebuah tipe khusus dari method yang digunakan untuk membuat dan menginisialisasi sebuah object baru. Konstruktor merupakan suatu method yang memiliki nama yang sama dengan nama classnya.Ingat bahwa konstruktor bukan member(yaitu atribut,method atau inner class dari sebuah object).
Mendeklarasikan sebuah Konstruktor:
<constructorDeclaration> ::=
<modifier> <className> (<parameter>*) {
<statement>*
}
Jika tidak ada konstruktor yang disediakan secara jelas, konstruktor default secara otomatis
membuatkannya untuk Anda. Konstruktor default tidak membawa argumen dan tidak berisi
pernyataan pada tubuh class.
Petunjuk Penulisan Program:
Nama konstruktor harus sama dengan nama class.<modifier> yang valid untuk konstruktor adalah public, protected, dan private.Konstruktor tidak memiliki nilai return.
Perhatikan contoh berikut.
class ConstructorDemo {
private int data;
public ConstructorDemo() {
data = 100;
}
ConstructorDemo(int data) {
this.data = data;
}
}

Sekarang saatnya kita implementasikan dalam program kita. Langsung ke Source aja yah...

public class Kucing{
/* attributes
* mendeklarasikan atribut (variable) yang dimiliki kucing
*/
String nama;
String warna;
String suara;

/* methods
* mendeklarasikan tingkah laku (method) yang dimiliki kucing
*/

public void makan(){
System.out.println("kucing bernama "+nama+" yang berwarna "

+warna+" sedang makan");
}
public void tidur(){
System.out.println("kucing bernama "+nama+" yang berwarna "

+warna+" sedang tidur");
}
public void mengeong(){
System.out.println("kucing bernama "+nama+" yang berwarna "

+warna+" bersuara "+suara);
}

/* 
*memulai method main atau fungsi utama
*/
public static void main (String[] args) {
//membuat object kucingku dan kucingmu bertipe class Kucing
Kucing kucingku = new Kucing();
Kucing kucingmu = new Kucing();

//mengisikan value ke dalam attribut
kucingku.nama="mocin";
kucingku.warna="putih";
kucingku.suara="meoong";     

kucingmu.nama="karin";
kucingmu.warna="hitam";
kucingmu.suara="miauuw";

//memanggil method dari object
kucingku.makan();
kucingku.tidur();
kucingku.mengeong();

System.out.println();

kucingmu.makan();
kucingmu.tidur();
kucingmu.mengeong();
}
}

Jika di-compile dan di-run, kurang lebih hasilnya akan seperti ini:

kucing bernama mocin yang berwarna putih sedang makan
kucing bernama mocin yang berwarna putih sedang tidur
kucing bernama mocin yang berwarna putih bersuara meoong

kucing bernama karin yang berwarna hitam sedang makan
kucing bernama karin yang berwarna hitam sedang tidur
kucing bernama karin yang berwarna hitam bersuara miauuw

B. penggunaan kata kunci this, super, final dan static 

1. Kata kunci this

Kata kunci this dapat digunakan untuk beberapa alasan berikut:
          1. Adanya ambigu pada atribut lokal dari variabel lokal
          2. Menunjuk pada object yang meminta method non-static
          3. Menunjuk pada konstruktor lain.
    Sebagai contoh pada maksud pertama, perhatikan kode berikut dimana variabel data disediakan
    sebagai sebuah atribut dan parameter lokal pada saat yang sama. 

class ThisDemo1 {
int data;
void method(int data) {
this.data = data;
/* this.data menunjuk ke atribut
sementara data menunjuk ke variabel lokal */
}
}

      Contoh berikut menunjukkan bagaimana object this secara mutlak menunjuk ketika anggota  nonstatic dipanggil.

class ThisDemo2 {
int data;
void method() {
System.out.println(data); //this.data
}
void method2() {
method(); //this.method();
}

       Sebelum melihat ke contoh yang lain, mari pertama meninjau pengertian method overloading.Konstruktor seperti juga method dapat juga menjadi overload. Method yang berbeda dalam class dapat memberi nama yang sama asalkan list parameter juga berbeda. Method overloaded harus berbeda dalam nomor dan/atau tipe dari parameternya. Contoh selanjutnya memiliki konstruktor overloaded dan referensi this yang dapat digunakan untuk menunjuk versi lain dari konstruktor.

class ThisDemo3 {
int data;
ThisDemo3() {
this(100);
}
ThisDemo3(int data) {
this.data = data;
          }
}

Petunjuk Penulisan Program:
Memanggil this() harus ada pernyataan pertama dalam konstruktor.

2. Kata kunci super

    Penggunaan kata kunci super berhubungan dengan pewarisan. Super digunakan untuk meminta konstruktor superclass. Super juga dapat digunakan seperti kata kunci this untuk menunjuk pada anggota dari superclass.Program berikut mendemonstrasikan bagaimana referensi super digunakan untuk memanggil konstruktor superclass.

class Person {
String firstName;
String lastName;
Person(String fname, String lname) {
firstName = fname;
lastName = lname;
         }
}

class Student extends Person {
String studNum;
Student(String fname, String lname, String sNum) {
super(fname, lname);
studNum = sNum;
}
         }

Petunjuk Penulisan Program:
super() menunjuk pada superclass dengan segera. Ini harus berada pada pernyataan pertama
dalam konstruktor superclass.
Kata kunci dapat juga digunakan untuk menunjuk anggota superclass seperti yang ditunjukkan
pada contoh berikut.

class Superclass{
int a;
void display_a(){
System.out.println("a = " + a);
}
}
class Subclass extends Superclass {
int a;
void display_a(){
System.out.println("a = " + a);
}
void set_super_a(int n){
super.a = n;
}
void display_super_a(){
super.display_a();
}
}
class SuperDemo {
public static void main(String args[]){
Superclass SuperObj = new Superclass();
Subclass SubObj = new Subclass();
SuperObj.a = 1;
SubObj.a = 2;
SubObj.set_super_a(3);
SuperObj.display_a();
SubObj.display_a();
SubObj.display_super_a();
System.out.println(SubObj.a);
}
            }

Program tersebut akan menampilkan hasil berikut.
             a = 1
a = 2
a = 3
             2

3. Kata Kunci static
      Kata kunci static dapat digunakan untuk anggota dari sebuah class. Kata kunci ini menyediakan static atau anggota class untuk diakses sama sebelum beberapa instance dari class dibuat.

       Variabel class bersifat seperti variabel umum. Ini artinya bahwa variabel dapat diakses olehsemua instance dari class.
       Method class mungkin dapat diambil tanpa membuat sebuah object dari class tersebut.
Bagaimanapun, mereka hanya dapat mengakses anggota static dari class. Ditambahkan juga,
mereka tidak dapat menunjuk this dan super.
      Kata kunci static dapat juga diaplikasikan pada blok. Ini dinamakan dengan blok static. Blok ini dieksekusi hanya sekali, ketika class diisi. Hal ini biasanya digunakan untuk menginisialisasi
variabel class.

class Demo {
static int a = 0;
static void staticMethod(int i) {
System.out.println(i);
}
static { //blok static
System.out.println("This is a static block.");
a += 1;
}
}
class StaticDemo {
public static void main(String args[]) {
System.out.println(Demo.a);
Demo.staticMethod(5);
Demo d = new Demo();
System.out.println(d.a);
d.staticMethod(0);
Demo e = new Demo();
System.out.println(e.a);
d.a += 3;
System.out.println(Demo.a+", " +d.a +", " +e.a);
           }
}

Keluaran dari source kode ditunjukkan di bawah ini.
This is a static block.
15
10
1
4, 4, 4

4. Kata Kunci final
      Kata kunci final dapat diaplikasikan pada variabel, method dan class. Untuk mengingat fungsi dari kata kunci, ingat bahwa itu secara mudah dibatasi apa yang kita dapat lakukan dengan variabel,method dan class.
      Nilai dari variabel final dapat tidak lama diubah sesudah nilainya telah diatur. Sebagai contoh, 

final int data = 10;

Pernyataan berikut akan menyebabkan terjadi compilation error:

data++;

Method final tidak dapat di-override dalam class anak.

final void myMethod() { //in a parent class
}

myMethod tidak dapat lama di-override dalam class anak.
class final tidak dapat diwariskan tidak seperti class yang biasanya.

final public class MyClass {
}

Petunjuk Penulisan Program:
Perintah penulisan kata kunci final dan public memungkinkan bertukar tempat.
Pernyataan ini akan menyebabkan kesalahan compilation terjadi karena MyClass dapat tidak lama di-extended.

public WrongClass extends MyClass {
}

3. Perbedaan antara method overloading dan method overridding 

     Method subclass override terhadap method superclass ketika subclass mendeklarasikan method yang signaturenya serupa ke method dalam superclass. Signature dari method hanyalah informasi yang ditemukan dalam definisi method bagian atas. Signature mengikutkan tipe return, nama dan daftar parameter method tetapi itu tidak termasuk acces modifier dan tipe yang lain dari kat kunci seperti final dan static.
         Inilah perbedaan dari method overloading. Method overloading secara singkat didiskusikan dalam sub bagian pada kata kunci this.

class Superclass {
void display(int n) {
System.out.println("super: " + n);
}
}
class Subclass extends Superclass {
void display(int k) { //method overriding
System.out.println("sub: " + k);
          }
  }
class OverrideDemo {
public static void main(String args[]) {
Subclass SubObj = new Subclass();
Superclass SuperObj = SubObj;
SubObj.display(3);
((Superclass)SubObj).display(4);
}
         }

Ini akan menghasilkan keluaran sebagai berikut.

               sub: 3
               sub: 4

Pemanggilan method ditentukan oleh tipe data sebenarnya dari object yang diminta method.

Acces modifier untuk method yang dibutuhkan tidak harus sama. Bagaimanapun, acces modifier dari method overridding mengharuskan salah satunya punya acces modifier yang sama seperti itu dari method overridden atau acces modifier yang kurang dibatasi.
Perhatikan contoh selanjutnya. Periksa yang mana dari method overridding berikut akan
menyebabkan waktu meng-compile akan menyebabkan error.

class Superclass {
void overriddenMethod() {
}
}
class Subclass1 extends Superclass {
public void overriddenMethod() {
}
}
class Subclass2 extends Superclass {
void overriddenMethod() {
}
}
class Subclass3 extends Superclass {
protected void overriddenMethod() {
}
}
class Subclass4 extends Superclass {
private void overriddenMethod() {
             }
}