Java adalah bahasa berorientasi objek. Ini berarti Anda perlu menulis program Java menggunakan paradigma berorientasi objek. Dan paradigma ini memerlukan penggunaan objek dan kelas dalam program Anda. Mari kita coba menggunakan contoh untuk memahami apa itu kelas dan objek, dan bagaimana menerapkan prinsip dasar OOP (abstraksi, pewarisan, polimorfisme, dan enkapsulasi) dalam praktik.
Apa itu objek?
Dunia tempat kita hidup terdiri dari benda-benda. Melihat sekeliling, kita dapat melihat bahwa kita dikelilingi oleh rumah, pohon, mobil, perabot, piring, dan komputer. Semua hal ini adalah objek, dan masing-masing memiliki serangkaian karakteristik, perilaku, dan tujuan tertentu. Kami terbiasa dengan objek, dan kami selalu menggunakannya untuk tujuan yang sangat spesifik. Misalnya, jika kita perlu berangkat kerja, kita menggunakan mobil. Jika kita ingin makan, kita menggunakan piring. Dan jika kita ingin istirahat, kita mencari sofa yang nyaman. Manusia terbiasa berpikir dalam bentuk objek untuk memecahkan masalah dalam kehidupan sehari-hari. Ini adalah salah satu alasan mengapa objek digunakan dalam pemrograman. Pendekatan ini disebut pemrograman berorientasi objek. Mari kita beri contoh. Bayangkan Anda telah mengembangkan ponsel baru dan ingin memulai produksi massal. Sebagai pengembang ponsel, Anda tahu kegunaannya, bagaimana fungsinya, dan apa bagian-bagiannya (bodi, mikrofon, speaker, kabel, tombol, dll.). Terlebih lagi, hanya Anda yang tahu cara menghubungkan bagian-bagian ini. Tetapi Anda tidak berencana membuat ponsel sendiri — Anda memiliki seluruh tim pekerja untuk melakukan ini. Untuk menghilangkan kebutuhan untuk berulang kali menjelaskan cara menghubungkan bagian-bagian telepon, dan untuk memastikan bahwa semua telepon dibuat dengan cara yang sama, sebelum Anda mulai memproduksinya, Anda perlu membuat gambar yang menjelaskan bagaimana pengaturan telepon. Dalam OOP, kami menyebut deskripsi, gambar, diagram, atau templat semacam itu sebagai kelas. Ini membentuk dasar pembuatan objek saat program sedang berjalan. Kelas adalah deskripsi objek dengan tipe tertentu — seperti templat umum yang terdiri dari bidang, metode, dan konstruktor. Objek adalah turunan dari kelas.
Abstraksi
Sekarang mari kita pikirkan tentang bagaimana kita bisa berpindah dari objek di dunia nyata ke objek dalam program. Kami akan menggunakan telepon sebagai contoh. Alat komunikasi ini memiliki sejarah yang terbentang lebih dari 100 tahun. Telepon modern adalah perangkat yang jauh lebih kompleks daripada pendahulunya di abad ke-19. Saat menggunakan telepon, kami tidak memikirkan organisasinya dan proses yang terjadi di dalamnya. Kami cukup menggunakan fungsi yang disediakan oleh pengembang ponsel: tombol atau layar sentuh untuk memasukkan nomor telepon dan melakukan panggilan. Salah satu antarmuka telepon pertama adalah engkol yang perlu diputar untuk melakukan panggilan. Tentu saja, ini sangat tidak nyaman. Tapi itu memenuhi fungsinya dengan sempurna. Jika Anda membandingkan ponsel paling modern dan pertama, Anda dapat segera mengidentifikasi fungsi yang paling penting untuk perangkat akhir abad ke-19 dan untuk smartphone modern. Mereka adalah kemampuan untuk melakukan panggilan dan kemampuan untuk menerima panggilan. Padahal, inilah yang menjadikan ponsel sebagai ponsel, dan bukan yang lain. Sekarang hanya menerapkan prinsip OOP: mengidentifikasi karakteristik dan informasi objek yang paling penting. Prinsip ini disebut abstraksi. Dalam OOP, abstraksi juga dapat didefinisikan sebagai metode untuk merepresentasikan elemen tugas dunia nyata sebagai objek dalam suatu program. Abstraksi selalu dikaitkan dengan generalisasi sifat-sifat tertentu dari suatu objek, jadi yang utama adalah memisahkan informasi yang bermakna dari yang tidak penting dalam konteks tugas yang dihadapi. Selain itu, bisa ada beberapa tingkat abstraksi. Membiarkan' Coba terapkan prinsip abstraksi ke ponsel kita. Untuk memulai, kami akan mengidentifikasi jenis ponsel yang paling umum — dari ponsel pertama hingga ponsel saat ini. Misalnya, kita dapat merepresentasikannya dalam bentuk diagram pada Gambar 1. Dengan menggunakan abstraksi, kita sekarang dapat mengidentifikasi informasi umum dalam hierarki objek ini: objek abstrak umum (telepon), karakteristik umum telepon (misalnya tahun pembuatannya), dan antarmuka umum (semua telepon dapat menerima dan melakukan panggilan). Begini tampilannya di Jawa:
public abstract class AbstractPhone {
private int year;
public AbstractPhone(int year) {
this.year = year;
}
public abstract void call(int outgoingNumber);
public abstract void ring(int incomingNumber);
}
Dalam sebuah program, kita dapat membuat jenis ponsel baru menggunakan kelas abstrak ini dan menerapkan prinsip dasar OOP lainnya, yang akan kita jelajahi di bawah.
Enkapsulasi
Dengan abstraksi, kami mengidentifikasi apa yang umum untuk semua objek. Namun setiap jenis ponsel itu unik, entah bagaimana berbeda dari yang lain. Dalam sebuah program, bagaimana kita menarik batasan dan mengidentifikasi individualitas ini? Bagaimana kita membuatnya sehingga tidak ada orang yang sengaja atau tidak sengaja merusak ponsel kita atau mencoba mengubah satu model ke model lainnya? Di dunia nyata, jawabannya jelas: Anda harus memasukkan semua bagian ke dalam casing ponsel. Lagi pula, jika Anda tidak - alih-alih meninggalkan semua bagian internal ponsel dan menghubungkan kabel di luar - beberapa peneliti yang ingin tahu pasti ingin "memperbaiki" ponsel kita. Untuk mencegah utak-atik seperti itu, prinsip enkapsulasi digunakan dalam desain dan operasi objek. Prinsip ini menyatakan bahwa atribut dan perilaku objek digabungkan dalam satu kelas, objek ' implementasi internal disembunyikan dari pengguna, dan antarmuka publik disediakan untuk bekerja dengan objek. Tugas pemrogram adalah menentukan atribut dan metode objek mana yang harus tersedia untuk akses publik, dan detail implementasi internal mana yang seharusnya tidak dapat diakses.
Enkapsulasi dan kontrol akses
Misalkan informasi tentang telepon (tahun produksi atau logo pabrikan) terukir di punggungnya saat dibuat. Informasi (statusnya) khusus untuk model khusus ini. Kami dapat mengatakan bahwa pabrikan memastikan bahwa informasi ini tidak dapat diubah — tidak mungkin ada orang yang berpikir untuk menghapus ukiran tersebut. Di dunia Java, sebuah kelas menggambarkan keadaan objek masa depan menggunakan bidang, dan perilakunya dijelaskan menggunakan metode. Akses ke status dan perilaku objek dikontrol menggunakan pengubah yang diterapkan ke bidang dan metode: privat, terlindungi, publik, dan default. Misalnya, kami memutuskan bahwa tahun produksi, nama pabrikan, dan salah satu metode adalah detail implementasi internal kelas dan tidak dapat diubah oleh objek lain dalam program. Dalam kode,
public class SomePhone {
private int year;
private String company;
public SomePhone(int year, String company) {
this.year = year;
this.company = company;
}
private void openConnection(){
// findSwitch
// openNewConnection...
}
public void call() {
openConnection();
System.out.println("Calling");
}
public void ring() {
System.out.println("Ring-ring");
}
}
Pengubah pribadi memungkinkan bidang dan metode kelas untuk diakses hanya di dalam kelas ini. Ini berarti tidak mungkin untuk mengakses bidang pribadi dari luar, karena metode pribadi tidak dapat dipanggil. Membatasi akses ke metode openConnection juga memberi kita kemampuan untuk secara bebas mengubah implementasi internal metode tersebut, karena metode tersebut dijamin tidak akan digunakan oleh atau mengganggu pekerjaan objek lain. Untuk bekerja dengan objek kami, kami membiarkan metode panggilan dan dering tersedia menggunakan pengubah publik. Menyediakan metode publik untuk bekerja dengan objek juga merupakan bagian dari enkapsulasi, karena jika akses ditolak sepenuhnya, itu akan menjadi tidak berguna.
Warisan
Mari kita lihat lagi diagram ponsel. Anda dapat melihat bahwa ini adalah hierarki di mana model memiliki semua fitur model yang terletak lebih tinggi di sepanjang cabangnya, dan menambahkan beberapa fiturnya sendiri. Misalnya, ponsel cerdas menggunakan jaringan seluler untuk komunikasi (memiliki sifat ponsel), nirkabel dan portabel (memiliki sifat telepon nirkabel), dan dapat menerima dan melakukan panggilan (memiliki sifat telepon). Apa yang kita miliki di sini adalah pewarisan properti objek. Dalam pemrograman, pewarisan berarti menggunakan kelas yang ada untuk mendefinisikan yang baru. Mari pertimbangkan contoh penggunaan warisan untuk membuat kelas smartphone. Semua telepon nirkabel ditenagai oleh baterai yang dapat diisi ulang, yang memiliki masa pakai baterai tertentu. Karenanya, kami menambahkan properti ini ke kelas telepon nirkabel:
public abstract class CordlessPhone extends AbstractPhone {
private int hour;
public CordlessPhone (int year, int hour) {
super(year);
this.hour = hour;
}
}
Ponsel mewarisi properti telepon nirkabel, dan kami menerapkan metode panggilan dan dering di kelas ini:
public class CellPhone extends CordlessPhone {
public CellPhone(int year, int hour) {
super(year, hour);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Calling " + outgoingNumber);
}
@Override
public void ring(int incomingNumber) {
System.out.println("Incoming call from " + incomingNumber);
}
}
Dan terakhir, kami memiliki kelas smartphone, yang tidak seperti ponsel klasik, memiliki sistem operasi yang lengkap. Anda dapat memperluas fungsionalitas ponsel cerdas Anda dengan menambahkan program baru yang dapat berjalan di sistem operasinya. Dalam kode, kelas dapat digambarkan sebagai berikut:
public class Smartphone extends CellPhone {
private String operationSystem;
public Smartphone(int year, int hour, String operationSystem) {
super(year, hour);
this.operationSystem = operationSystem;
}
public void install(String program) {
System.out.println("Installing " + program + " for " + operationSystem);
}
}
Seperti yang Anda lihat, kami membuat sedikit kode baru untuk mendeskripsikan kelas Smartphone , tetapi kami mendapatkan kelas baru dengan fungsionalitas baru. Prinsip OOP ini memungkinkan untuk secara signifikan mengurangi jumlah kode Java yang diperlukan, sehingga memudahkan programmer.
Polimorfisme
Terlepas dari perbedaan dalam tampilan dan desain berbagai jenis ponsel, kami dapat mengidentifikasi beberapa perilaku umum: semuanya dapat menerima dan melakukan panggilan, dan semuanya memiliki serangkaian kontrol yang cukup jelas dan sederhana. Dalam hal pemrograman, prinsip abstraksi (yang sudah kita kenal) katakanlah objek telepon memiliki antarmuka yang sama. Itulah mengapa orang dapat dengan mudah menggunakan berbagai model ponsel yang memiliki kontrol yang sama (tombol mekanis atau layar sentuh), tanpa mempelajari detail teknis perangkat tersebut. Dengan demikian, Anda menggunakan ponsel terus-menerus dan Anda dapat dengan mudah melakukan panggilan dari telepon rumah teman Anda. Prinsip OOP yang mengatakan bahwa program dapat menggunakan objek dengan antarmuka umum tanpa informasi apa pun tentang struktur internal objek disebut polimorfisme. Membiarkan' Bayangkan bahwa kita memerlukan program kita untuk mendeskripsikan pengguna yang dapat menggunakan telepon apa pun untuk menelepon pengguna lain. Inilah cara kami melakukannya:
public class User {
private String name;
public User(String name) {
this.name = name;
}
public void callAnotherUser(int number, AbstractPhone phone){
// And here's polymorphism: using the AbstractPhone type in the code!
phone.call(number);
}
}
}
Sekarang kami akan menjelaskan beberapa jenis ponsel. Salah satu ponsel pertama:
public class ThomasEdisonPhone extends AbstractPhone {
public ThomasEdisonPhone(int year) {
super(year);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Crank the handle");
System.out.println("What number would you like to connect to?");
}
@Override
public void ring(int incomingNumber) {
System.out.println("The phone is ringing");
}
}
Telepon darat biasa:
public class Phone extends AbstractPhone {
public Phone(int year) {
super(year);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Calling " + outgoingNumber);
}
@Override
public void ring(int incomingNumber) {
System.out.println("The phone is ringing");
}
}
Dan terakhir, telepon video yang keren:
public class VideoPhone extends AbstractPhone {
public VideoPhone(int year) {
super(year);
}
@Override
public void call(int outgoingNumber) {
System.out.println("Connecting video call to " + outgoingNumber);
}
@Override
public void ring(int incomingNumber) {
System.out.println("Incoming video call from " + incomingNumber);
}
}
Kita akan membuat objek dalam metode main() dan menguji metode callAnotherUser() :
AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Jason");
user.callAnotherUser(224466, firstPhone);
// Crank the handle
// What number would you like to connect to?
user.callAnotherUser(224466, phone);
// Calling 224466
user.callAnotherUser(224466, videoPhone);
// Connecting video call to 224466
Memanggil metode yang sama pada objek pengguna menghasilkan hasil yang berbeda. Implementasi khusus dari metode panggilan dipilih secara dinamis di dalam metode callAnotherUser() berdasarkan jenis objek tertentu yang diteruskan saat program sedang berjalan. Ini adalah keunggulan utama polimorfisme – kemampuan untuk memilih implementasi saat runtime. Dalam contoh kelas telepon yang diberikan di atas, kami menggunakan penggantian metode — sebuah trik di mana kami mengubah penerapan metode yang ditentukan di kelas dasar tanpa mengubah tanda tangan metode. Ini pada dasarnya menggantikan metode: metode baru yang didefinisikan dalam subkelas dipanggil saat program dijalankan. Biasanya, saat kita mengganti metode, @Overrideanotasi digunakan. Ini memberi tahu kompiler untuk memeriksa tanda tangan dari metode yang diganti dan diganti. Terakhir, untuk memastikan program Java Anda konsisten dengan prinsip OOP, ikuti tips berikut:
mengidentifikasi karakteristik utama suatu objek;
mengidentifikasi properti dan perilaku umum dan menggunakan pewarisan saat membuat kelas;
gunakan tipe abstrak untuk mendeskripsikan objek;
cobalah untuk selalu menyembunyikan metode dan bidang yang terkait dengan implementasi internal kelas.
Dengan menggunakan abstraksi, kita sekarang dapat mengidentifikasi informasi umum dalam hierarki objek ini: objek abstrak umum (telepon), karakteristik umum telepon (misalnya tahun pembuatannya), dan antarmuka umum (semua telepon dapat menerima dan melakukan panggilan). Begini tampilannya di Jawa:
GO TO FULL VERSION