**Pengaturcaraan berorientasi objek** (bahasa Inggeris: *object-oriented programming*, juga dikenali dengan singkatan ***OOP***) ialah sejenis paradigma pengaturcaraan.

OOP sering dipanggil sebagai "paradigma", dan bukan hanya gaya atau jenis pengaturacaraan. Ini adalah untuk menekankan yang OOP boleh mengubah cara perisian dibangunkan.

Pengenalan
----------

Aspek permulaan bagi pengaturcaraan berorientasi objek ialah, sebuah atur cara Komputer yang terdiri daripada sekumpulan unit-unit atau objek. Untuk membolehkan perkomputeran berlaku, setiap objek berupaya untuk menerima dan menghantar mesej (pesanan) kepada objek lain. Dengan cara ini, mesej dapat ditangani oleh sebahagian daripada kod, tetapi boleh juga ditangani oleh blok kod yang lain secara lancar.

Dalam OOP, objek adalah mudah, serba lengkap (self-contained), dan mudah dikenalpasti. 

Sesungguhnya, pengaturcaraan berorientasi objek dimulakan dengan melakarkan situasi masalah. Seterusnya, dengan proses memasukkan objek, atau pembolehubah (sebagai kata-nama), kaedah (sebagai kata kerja), dan atribut (sebagai kata sifat/adjektif), rangka-kerja bagi atur cara dihasilkan, yang dimodelkan untuk situasi tersebut.

Majoriti daripada penulis atur cara bersetuju bahawa OOP merupakan langkah ke depan yang besar, berbanding kaedah berasaskan tatacara yang begitu kompleks sebelum ini. OOP memberi faedah besar dalam projek besar di mana kaedah bertatacara yang diguna menghasilkan banyak *loop* bersyarat serta cabang-cabang yang rumit, sehingga sukar hendak difahami dan diselenggara.

Konsep asas
-----------

* **Kelas** *(class)* — sebuah kelas mentakrifkan ciri-ciri abstrak bagi sesuatu benda. Ini termasuklah sifat-sifat yang ada padanya dan peranannya. Contohnya, kelas `Kucing` akan terdiri dari sifat-sifat yang ada pada kucing (baka, bulu, jantina dan sebagainya).

* **Objek** *(object)* — tentuan (instance) bagi suatu kelas. Kelas `Kucing` memiliki semua sifat yang mungkin ada pada seekor kucing, manakala objek `SiComel` memiliki sifat-sifat yang tertentu sahaja. Kucing mempunyai bulu, `SiComel` mempunyai bulu putih bertompok hitam.

* **Kaedah** *(method)* — kebolehan bagi sebuah objek. `SiComel`, sebagai seekor `Kucing`, mempunyai kebolehan mengiau. Maka `mengiau()` ialah salah satu kaedah bagi `SiComel`. `SiComel` juga boleh memiliki kaedah lain, umpamanya `makan()` atau `berlari()`. Dalam sebuah atur cara, penggunaan satu kaedah hanya berkesan pada objek yang ditentukan sahaja, semua `Kucing` boleh mengiau, tetapi anda mesti ada seekor sahaja untuk mengiau.

* **Pewarisan** *(inheritance)* — Lazimnya sebuah kelas boleh memiliki "subkelas" yang *mengkhususkan* kelas tersebut. Contohnya, kelas `Kucing` boleh mempunyai subkelas `KucingSiam`, `KucingBurma` dan `KucingParsi`. Semua subkelas ini akan "mewarisi" segala sifat yang ada pada keturunannya; contohnya apabila kelas `Kucing` memiliki kaedah `mengiau()`, maka setiap subkelasnya (`KucingSiam`, `KucingBurma` dan `KucingParsi`) juga akan memiliki kaedah `mengiau`. Ini bermakna bahawa seorang pengaturcara akan menulis kaedah ini sekali sahaja. Subkelas boleh "mentakrifkan semula" (mengubah), menyekang atau menambah ciri-ciri yang tidak ada pada kelas asalnya. Contohnya `Kucing` memiliki sifat `bulu`, maka `KucingSiam` menentukan sifat `bulu` kepada 'licin dan berkilat'.

* **Pengkapsulan** *(encapsulation)* — Mengasingkan pelaksanaan (implementasi) daripada antaramuka

* **Pengabstrakan** *(abstraction)*

* **Polimorfisme** *(polymorphism)* — Menggunakan nama yang sama untuk memulakan operasi yang berlainan pada objek yang menggunakan jenis data berbeza.

Sejarah
-------

Konsep pengaturcaraan berorientasi objek pertama kali muncul di dalam Simula 67, suatu bahasa pengaturcaraan yang direkabentuk untuk menjalankan simulasi. Ia dicipta oleh Ole-Johan Dahl dan Kristen Nygaard, dari Norwegian Computing Centre di Oslo.

Menurut laporan tertentu mereka sedang mengusahakan program simulasi untuk kapal, dan mendapati yang jenis-jenis kapal boleh digabung kepada beberapa kelas objek. Di mana setiap kelas objek berperanan menakrif datanya sendiri, termasuk perlakuannya.

Konsep ini kemudiannya digunakan dalam Smalltalk, yang dibangunkan di Simula, Xerox PARC. Bagaimanapun, ia direkabentuk sebagai sistem yang dinamik penuh, di mana objek boleh dicipta dan diubahsuai dengan mudah, dan bukan hanya sistem yang berpandukan program statik.

Pengaturcaraan berorientasi objek berkembang sebagai kaedahologi pengaturcaraan yang dominan pada pertengahan 1980an. Ini terutamanya dipengaruhi oleh kemunculan C++, iaitu Bahasa lanjutan daripada Bahasa Pengaturcaraan C. Pengaruhnya semakin luas dengan kepopularan antara muka grafik pengguna, yang sesuai dibangunkan dengan pengaturcaraan berorientasi objek. Aliran perubahan ini, mengubah fokus pengguna daripada penggunaan antaramuka berdasarkan teks yang mengguna arahan berjujukan, kepada memanipulasi komponen secara dinamik. Contoh penggunaan pustaka GUI(antaramuka Grafik) yang dinamik, dan bahasa pengaturcaraan berorientasi objek, boleh didapati dalam rangka kerja Cocoa pada Mac OS X. Ia ditulis di dalam Objective C, iaitu Bahasa Berorientasikan Objek, berdasarkan Smalltalk.

Di ETH ZUrich, Nikalus Wirth dan rakan-rakannya telah mengkaji beberapa topik seperti pengabstrakan data dan Pengaturcaraan Modular. Kedua-dua konsep ini termasuk di dalam Modula-2, dan rekabentuk mereka yang seterusnya, iaitu Oberan mengguna pendekatan yang lebih unik terhadap pengorientasi objek, class, dan sebagainya. Pendekatan mereka adalah berbeza dengan Smalltalk dan C++.

Ciri-ciri pengaturcaraan berorientasi objek telah dimuatkan dalam pelbagai Bahasa Pengaturcaraan pada masa itu. Ini termasuk Ada, BASIC, Lisp, Pascal, dan banyak lagi. Disebabkan bahasa-bahasa ini pada dasarnya bukan berkonsepkan OOP(pengaturcaraan Berorientasikan Objek), maka timbulnya masalah kompatibiliti(kesesuaian), dan penyelenggaraan kod. bahasa pengaturcaraan berorientasi objek yang "tulen" pula, kurang ciri-ciri yang sering digunakan oleh Juruaturcara. Dalam mengurangkan jurang perbezaan ini, beberapa percubaan telah dibuat untuk mencipta bahasa baru yang berdasarkan kaedah OOP, di samping membenarkan sifat Pengaturcaraan Berstruktur secara "selamat". Bahasa Pengaturcaraan Eiffel yang dibangunkan oleh Bertrand Meyer adalah bahasa terawal dicipta berdasarkan matlamat ini.

Dalam dekad akhir ini, Java telah berkembang secara meluas. Ini disebabkan sintaks penulisannya yang serupa dengan C/C++. Namun Java yang menarik minat golongan pengaturcara, ialah penggunaan mesin maya, yang bertujuan untuk menjalankan kod dalam pelantar komputer yang berbeza. Microsoft .Net dibangunkan dengan objektif yang sama, di samping memberi sokongan terhadap bahasa pengaturcaraan yang baru.

Pada masa terkini, sejumlah bahasa baru telah muncul yang berorientasi objek, tetapi juga sesuai dengan kaedahologi pengaturcaraan bertatacara. Ini termasuk Python, dan Ruby. Selain daripada Bahasa Pengaturcaraan Java, bahasa berorientasi objek lain yang popular secara komersil, adalah VB.NET dan C#(C sharp) yang direkabentuk untuk platform Microsoft .NET.

Kaedah rekabentuk berorientasikan objek telah menyumbang kepada penggunaan corak reka bentuk (*design pattern*), reka bentuk secara kontrak (*design by contract*), dan bahasa pemodelan (*modelling language*) seperti UML.

OOP dengan bahasa pengaturcaraan berstruktur
--------------------------------------------

Dalam bahasa pengaturcaraan bertatacara, OOP digunakan dalam bentuk di mana jenis data dikembangkan untuk menyerupai objek dalam OOP. Ia serupa dengan jenis data abstrak dengan tambahan seperti perwarisan. Setiap kaedah merupakan atur cara bawahan (subprogram) yang secara sintatiknya terikat kepada class.

Takrifan rasmi
--------------

Definisi OOP sering didebatkan. Secara umumnya, OOP merujuk kepada konsep bahawa perisian memanipulasikan objek, dan bukannya aksi yang dijalankan. Ini berbeza dengan paradigma pengaturcaraan seperti pengaturcaraan kefungsian dan pengaturcaraan bertatacara, di mana fokus utama adalah terhadap aksi.

Gaya-gaya pengaturcaraan berorientasi objek
-------------------------------------------

### Model berdasarkan kelas

Model OOP yang popular ialah model berasaskan kelas, bertentangan dengan model berasaskan objek. Dalam model ini, objek adalah entiti yang menggabungkan keadaan(state) (seperti, data) dan perlakuan(behaviour) (seperti, tatacara atau kaedah). Satu objek didefinisikan oleh satu kelas. Class ialah definisi,  bagi kesemua objek dengan jenis tertentu. Suatu objek perlu dicipta berdasarkan suatu kelas. Objek yang dicipta dianggap ahli kepada kelas. Suatu objek adalah serupa dengan satu Struktur, tetapi dengan tambahan lain, seperti penunjuk kaedah, kawalan capaian ahli, dan ahli data yang merujuk kepada lokasi objek di dalam hirarki kelas. 

### Pewarisan

Suatu data objek dan/atau fungsi boleh berdasarkan kepada data objek dan/atau fungsi bagi objek lain. Objek itu dikatakan mewarisi sifat objek lain. Sifat ini membenarkan suatu objek dicipta dan diguna berulangkali. Perwarisan juga boleh termasuk *subtyping*, di mana suatu jenis objek ditakrif lebih khusus daripada objek yang asal. (lihat Prinsip Penggantian Liskov). 

### Model berdasarkan prototaip

Satu contoh bahasa pengaturcaraan berorientasi objek yang mengguna model ini ialah SELF, yang dibangunkan oleh Sun Microsystems.

### Model berdasarkan Objek

Teknik ini termasuk konsep bagi suatu objek, iaitu pengkapsulan dan pengabstrakan, tetapi tidak termasuk pewarisan.

Contoh atur cara
----------------

Menulis perisian dalam bahasa pengaturcaraan berorientasi objek adalah lebih kepada cara menulis kod berbanding cara menulis tatacara khas.

Secara tradisi, pengaturcaraan diajar sebagai pendekatan bawah-ke-atas. Model ini baik untuk pengaturcaraan bertatacara, walaupun dengan bahasa bukan bermodul, seperti Fortran dan Basic. Konsep berorentasi objek, bagaimanapun perlu dipelajari dan digunakan dalam pendekatan atas-ke-bawah, bermula dari objek medel dan interaksi objek.

Walaupun sesetengah bahasa berorentasi objek mengikut metafora objek sehingga aras kenyataan (*statement level*), seperti Smalltalk, bahasa yang paling meluas digunakan masa kini. C++, Pascal dan Java mengikut hampir-hampir catatan tatacara.

Dengan itu, untuk menulis perisian berorentasi objek yang baik, seseorang perlu membentuk model yang baik dan kemudian melaksanakan model dalam bahasa yang dipilih.

```
import javax.swing.*;  

class Character
{
       public static void main(String a[])
       {
               String input;
               char charac0;
               char charac1;
               char charac2;
               char charac3;
               char charac4;  

               // Prompt user to input five characters and assign it into variable "input"
               input=JOptionPane.showInputDialog("Enter five characters: ");  

               // Extract 1st character from variable "input".
               // NOTE THAT the 1st character is at location zero (0) NOT location one(1).
                  charac0=input.charAt(0);  

               // Extract 2nd character from variable "input"
               charac1=input.charAt(1);  

               // Extract 3rd character from variable "input"
               charac2=input.charAt(2);  

               // Extract 4th character from variable "input"
               charac3=input.charAt(3);  

               // Extract 5th character from variable "input"
               charac4=input.charAt(4);  

               // We also can extract the 1st character of input inserted by the user
               // using this statement
               char gred = JOptionPane.showInputDialog("Enter a character: ").charAt(0);  

               // Output statement grouping into one variable that is "out" type of String.
               String out="Character";
                          out+="\nIndex 0: "+charac0;
                          out+="\nIndex 1: "+charac1;
                          out+="\nIndex 2: "+charac2;
                          out+="\nIndex 3: "+charac3;
                          out+="\nIndex 4: "+charac4;
                          out+="\nGred: "+gred;  

               JOptionPane.showMessageDialog(null,out);  

               System.exit(0);  
  

       }
}
```

Bacaan tambahan
---------------

* Booch, Grady. (1993) ISBN 0-8053-5340-2 *Object-Oriented Analysis and Design with Applications (Second Edition)*. Addison-Wesley.
* Gamma, Erich, Richard Helm, Ralph Johnson, John Vlissides. (1995) ISBN 0-201-63361-2 *Design Patterns: Elements of Reusable Object Oriented Software*. Addison-Wesley.
* Meyer, Bertrand. (1997) ISBN 0-13-629155-4 *Object-Oriented Software Construction (Second Edition)*. Prentice Hall.
* Rumbaugh, James, Michael Blaha, William Premerlani, Frederick Eddy, William Lorensen. (1991) ISBN 0-13-629841-9 *Object-Oriented Modeling and Design*. Prentice Hall.
* Jacobsen, Ivar. (1994) ISBN 0-201-54435-0 *Object-Oriented Software Engineering*: A Use Case-Driven Approach. Addison-Wesley.
* Abelson, Harold, Gerald Jay Sussman with Julie Sussman. (1996) ISBN 0-262-01153-0 *Structure and Interpretation of Computer Programs (Second edition)*. The MIT Press

Lihat juga
----------

* Komponen perisian
* Bahasa pemerian pengantara (Interface description language)
* Bahasa pengaturcaraan berorientasi objek
* Pengaturcaraan kefungsian
* Pengaturcaraan bertatacara
* Pengaturcaraan berstruktur
* Pengaturcaraan pasca-objek

Pautan luar
-----------

* Soalan lazim tentang pengaturcaraan berorientasi objek[*pautan mati kekal*]
* Kritikan terhadap pengaturcaraan berorientasi objek Diarkibkan 2005-07-29 di Wayback Machine