Prinsip OOP

Java adalah bahasa berorientasi objek. Ini berarti Anda perlu menulis program Java menggunakan gaya berorientasi objek. Dan gaya ini didasarkan pada penggunaan objek dan kelas dalam program.

Prinsip dasar OOP:

Mari kita coba menggunakan contoh untuk memahami apa itu kelas dan objek, serta bagaimana menerapkan prinsip dasar OOP dalam praktik: abstraksi, pewarisan, polimorfisme, dan enkapsulasi.

Apa itu objek?

Dunia tempat kita tinggal terdiri dari benda-benda. Jika kita melihat sekeliling, kita akan melihat bahwa kita dikelilingi oleh rumah, pohon, mobil, perabotan, piring, komputer. Semua item ini adalah objek, dan masing-masing item memiliki serangkaian karakteristik, perilaku, dan tujuan tertentu. Kita terbiasa dengan benda, dan kita selalu menggunakannya untuk tujuan yang sangat spesifik. Misalnya kalau kita berangkat kerja kita pakai mobil, kalau mau makan kita pakai piring, kalau mau santai kita butuh sofa yang nyaman. Seseorang terbiasa berpikir objektif untuk menyelesaikan permasalahan dalam kehidupan sehari-hari. Inilah salah satu alasan penggunaan objek dalam pemrograman, dan pendekatan untuk membuat program ini disebut berorientasi objek. Mari kita beri contoh. Bayangkan Anda telah mengembangkan model ponsel baru dan ingin meluncurkan produksi massalnya. Sebagai perancang ponsel, Anda mengetahui kegunaannya, bagaimana fungsinya, dan bagian-bagiannya (casing, mikrofon, speaker, kabel, tombol, dll.). Namun, hanya Anda yang tahu cara menyambungkan bagian-bagian tersebut. Namun, Anda tidak berencana memproduksi ponsel secara pribadi, untuk ini Anda memiliki seluruh staf. Agar Anda tidak perlu menjelaskan setiap kali bagaimana cara menyambung bagian-bagian ponsel, dan agar semua ponsel yang diproduksi menjadi sama, sebelum Anda mulai memproduksinya, Anda perlu membuat gambar dalam bentuk a deskripsi struktur telepon. Dalam OOP, deskripsi, gambar, diagram, atau templat seperti itu disebut kelas, tempat objek dibuat saat program dijalankan. Kelas adalah deskripsi suatu objek yang belum dibuat, seperti templat umum yang terdiri dari bidang, metode, dan konstruktor, dan objek adalah turunan dari kelas yang dibuat berdasarkan deskripsi tersebut.

Abstraksi OOP

Sekarang mari kita pikirkan bagaimana kita dapat berpindah dari suatu objek di dunia nyata ke objek dalam suatu program, dengan menggunakan telepon sebagai contoh. Sejarah alat komunikasi ini melebihi 100 tahun dan telepon modern, tidak seperti pendahulunya pada abad ke-19, merupakan perangkat yang jauh lebih kompleks. Saat kita menggunakan telepon, kita tidak memikirkan strukturnya dan proses yang terjadi di dalamnya. Kami cukup menggunakan fungsi yang disediakan oleh pengembang ponsel - tombol atau layar sentuh untuk memilih nomor dan melakukan panggilan. Salah satu antarmuka telepon pertama adalah kenop yang Anda putar untuk melakukan panggilan. Tentu saja ini sangat tidak nyaman. Meskipun demikian, pegangan tersebut menjalankan fungsinya dengan baik. Jika Anda melihat telepon paling modern dan pertama, Anda dapat langsung mengidentifikasi detail terpenting yang penting baik untuk perangkat dari akhir abad ke-19 maupun untuk ponsel cerdas ultra-modern. Ini adalah membuat panggilan (memanggil nomor) dan menerima panggilan. Pada dasarnya, inilah yang menjadikan telepon sebagai telepon dan bukan sesuatu yang lain. Sekarang kami telah menerapkan prinsip dalam OOP - menyoroti karakteristik dan informasi paling penting tentang suatu objek. Prinsip OOP ini disebut abstraksi. Abstraksi dalam OOP juga dapat didefinisikan sebagai cara merepresentasikan elemen masalah dunia nyata sebagai objek dalam suatu program. Abstraksi selalu dikaitkan dengan generalisasi suatu informasi tentang sifat-sifat suatu benda atau benda, sehingga yang utama adalah memisahkan informasi penting dari informasi tidak penting dalam konteks masalah yang dipecahkan. Dalam hal ini, mungkin ada beberapa tingkatan abstraksi. Mari kita coba menerapkan prinsip abstraksi pada ponsel kita. Pertama, mari kita soroti jenis ponsel yang paling umum dari awal hingga saat ini. Misalnya, mereka dapat direpresentasikan dalam bentuk diagram yang ditunjukkan pada Gambar 1. Prinsip OOP - 2

Sekarang, dengan menggunakan abstraksi, kita dapat menyorot informasi umum dalam hierarki objek ini: jenis objek abstrak yang umum - telepon, karakteristik umum dari telepon - tahun pembuatannya, dan antarmuka umum - semua telepon mampu menerima dan mengirim panggilan. Berikut tampilannya di Java:

public abstract class AbstractPhone {
    private int year;

    public AbstractPhone(int year) {
        this.year = year;
    }
    public abstract void call(int outputNumber);
    public abstract void ring (int inputNumber);
}

Berdasarkan kelas abstrak ini, kita akan dapat membuat jenis ponsel baru dalam program ini menggunakan prinsip dasar Java OOP lainnya, yang akan kita bahas di bawah.

Enkapsulasi

Dengan bantuan abstraksi, kami menyoroti kesamaan semua objek. Namun, setiap model ponsel bersifat individual dan agak berbeda dari model lainnya. Bagaimana kita dapat menarik batasan dalam program dan menentukan individualitas ini? Bagaimana kita dapat memastikan bahwa tidak ada pengguna yang secara tidak sengaja atau sengaja merusak ponsel kita, atau mencoba mengubah satu model ke model lainnya? Untuk dunia benda nyata, jawabannya jelas: Anda harus memasukkan semua bagian ke dalam bodi ponsel. Lagi pula, jika kita tidak melakukan ini dan meninggalkan semua bagian dalam ponsel dan kabel yang menghubungkannya di luar, pasti akan ada peneliti yang ingin tahu yang ingin “meningkatkan” pengoperasian ponsel kita. Untuk menghindari campur tangan dalam desain dan pengoperasian suatu objek, OOP menggunakan prinsip enkapsulasi - prinsip dasar OOP lainnya, di mana atribut dan perilaku suatu objek digabungkan dalam satu kelas, implementasi internal objek tersebut disembunyikan dari pengguna, dan antarmuka terbuka disediakan untuk bekerja dengan objek. Tugas pemrogram adalah menentukan atribut dan metode mana yang dapat diakses publik dan mana yang merupakan implementasi internal objek dan tidak boleh diubah.

Enkapsulasi dan Kontrol Akses

Katakanlah selama produksi, informasi tentangnya terukir di bagian belakang ponsel: tahun pembuatannya atau logo perusahaan pembuatnya. Informasi ini secara spesifik mencirikan model ini - kondisinya. Kami dapat mengatakan bahwa pengembang ponsel menjaga kekekalan informasi ini - kecil kemungkinannya ada orang yang berpikir untuk menghapus ukiran tersebut. Di dunia Java, keadaan objek masa depan dijelaskan dalam kelas menggunakan bidang, dan perilakunya dijelaskan menggunakan metode. Kemampuan untuk mengubah keadaan dan perilaku dilakukan dengan menggunakan pengubah akses ke bidang dan metode - private, protected, public, dan default(akses default). Misalnya, kami memutuskan bahwa tahun pembuatan, nama produsen ponsel, dan salah satu metode termasuk dalam implementasi internal kelas dan tidak dapat diubah oleh objek lain dalam program. Dengan menggunakan kode, kelas dapat digambarkan sebagai berikut:

public class SomePhone {

    private int year;
    private String company;
    public SomePhone(int year, String company) {
        this.year = year;
        this.company = company;
    }
private void openConnection(){
    //findComutator
    //openNewConnection...
}
public void call() {
    openConnection();
    System.out.println("I'm calling a number");
}

public void ring() {
    System.out.println("Дзынь-дзынь");
}

 }

Pengubah privatemembuat bidang dan metode suatu kelas hanya tersedia di dalam kelas itu. Ini berarti bahwa privatefield tidak dapat diakses dari luar, dan privatemetode juga tidak dapat dipanggil. Menyembunyikan akses ke suatu metode openConnectionjuga memberi kita kesempatan untuk dengan bebas mengubah implementasi internal metode ini, karena metode ini dijamin tidak akan digunakan oleh objek lain dan tidak akan mengganggu pengoperasiannya. Untuk bekerja dengan objek kami, kami membiarkan metode terbuka callmenggunakan ringpengubah public. Menyediakan metode publik untuk bekerja dengan suatu objek juga merupakan bagian dari mekanisme enkapsulasi, karena jika akses ke suatu objek ditolak sepenuhnya, maka objek tersebut akan menjadi tidak berguna.

Warisan

Mari kita lihat grafik telepon lagi. Anda dapat melihat bahwa ini mewakili hierarki di mana model yang terletak di bawah memiliki semua karakteristik model yang terletak lebih tinggi di cabang, ditambah karakteristiknya sendiri. Misalnya, ponsel cerdas yang menggunakan jaringan seluler untuk komunikasi (memiliki sifat-sifat telepon seluler), bersifat nirkabel dan portabel (memiliki sifat-sifat telepon nirkabel), serta dapat menerima dan melakukan panggilan (memiliki sifat-sifat telepon). Dalam hal ini, kita dapat berbicara tentang pewarisan properti suatu objek. Dalam pemrograman, pewarisan adalah penggunaan kelas yang ada untuk mendefinisikan kelas baru. Mari kita lihat contoh pembuatan kelas smartphone menggunakan pewarisan. Semua telepon nirkabel ditenagai oleh baterai yang dapat diisi ulang, yang memiliki masa pengoperasian tertentu dalam hitungan jam. Jadi mari tambahkan properti ini ke kelas telepon nirkabel:

public abstract class WirelessPhone extends AbstractPhone {

    private int hour;

    public WirelessPhone(int year, int hour) {
        super(year);
        this.hour = hour;
    }
    }

callPonsel mewarisi properti telepon nirkabel, kami juga menambahkan implementasi metode and ke kelas ini ring:

public class CellPhone extends WirelessPhone {
    public CellPhone(int year, int hour) {
        super(year, hour);
    }

    @Override
    public void call(int outputNumber) {
        System.out.println("Calling a number" + outputNumber);
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("A subscriber is calling you" + inputNumber);
    }
}

Dan terakhir, kelas smartphone, yang berbeda dengan ponsel klasik, memiliki sistem operasi yang lengkap. Anda dapat menambahkan program baru yang didukung oleh sistem operasi ini ke ponsel cerdas Anda, sehingga memperluas fungsinya. Dengan menggunakan 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, Smartphonekami membuat sedikit kode baru untuk mendeskripsikan kelas, tetapi kami mendapatkan kelas baru dengan fungsionalitas baru. Penggunaan prinsip pewarisan OOP dapat mengurangi jumlah kode secara signifikan, sehingga mempermudah pekerjaan pemrogram.

Polimorfisme

Jika kita melihat semua model ponsel, meskipun ada perbedaan dalam tampilan dan desain model, kita dapat mengidentifikasi beberapa perilaku umum di dalamnya - semuanya dapat menerima dan melakukan panggilan serta memiliki serangkaian tombol kontrol yang cukup jelas dan sederhana. Menerapkan salah satu prinsip dasar OOP yang sudah kita ketahui, abstraksi dalam istilah pemrograman, kita dapat mengatakan bahwa objek telepon memiliki satu antarmuka yang sama. Oleh karena itu, pengguna ponsel dapat dengan nyaman menggunakan model yang berbeda menggunakan tombol kontrol yang sama (mekanis atau sentuh), tanpa membahas detail teknis perangkat. Jadi, Anda terus-menerus menggunakan telepon seluler, dan Anda dapat dengan mudah melakukan panggilan dari telepon rumah. Prinsip dalam OOP ketika suatu program dapat menggunakan objek dengan antarmuka yang sama tanpa informasi tentang struktur internal objek tersebut disebut polimorfisme . Bayangkan dalam program kita, kita perlu mendeskripsikan pengguna yang dapat menggunakan model telepon apa pun untuk menelepon pengguna lain. Berikut cara melakukannya:

public class User {
    private String name;

    public User(String name) {
        this.name = name;
            }

    public void callAnotherUser(int number, AbstractPhone phone){
// here it is polymorphism - using the abstract type AbstractPhone phone in the code!
        phone.call(number);
    }
}
 }

Sekarang mari kita jelaskan model telepon yang berbeda. Salah satu model telepon pertama:

public class ThomasEdisonPhone extends AbstractPhone {

public ThomasEdisonPhone(int year) {
    super(year);
}
    @Override
    public void call(int outputNumber) {
        System.out.println("Turn the Handle");
        System.out.println("Give me the phone number, sir");
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("Phone calls");
    }
}

Telepon rumah biasa:

public class Phone extends AbstractPhone {

    public Phone(int year) {
        super(year);
    }

    @Override
    public void call(int outputNumber) {
        System.out.println("I'm calling a number" + outputNumber);
    }

    @Override
    public void ring(int inputNumber) {
        System.out.println("Phone calls");
    }
}

Dan terakhir, telepon video keren:

public class VideoPhone extends AbstractPhone {

    public VideoPhone(int year) {
        super(year);
    }
    @Override
    public void call(int outputNumber) {
        System.out.println("I connect a video channel for the subscriber" + outputNumber );
    }
    @Override
    public void ring(int inputNumber) {
        System.out.println("You have an incoming video call..." + inputNumber);
    }
  }

Mari kita membuat objek dalam metode main()dan menguji metode tersebut callAnotherUser:

AbstractPhone firstPhone = new ThomasEdisonPhone(1879);
AbstractPhone phone = new Phone(1984);
AbstractPhone videoPhone=new VideoPhone(2018);
User user = new User("Andrey");
user.callAnotherUser(224466,firstPhone);
// Rotate the knob
// Tell me the number of the subscriber, sir
user.callAnotherUser(224466,phone);
//Call number 224466
user.callAnotherUser(224466,videoPhone);
//I connect the video channel for subscriber 224466

Dengan memanggil metode yang sama pada objek user, kita mendapatkan hasil yang berbeda. Pemilihan implementasi metode tertentu calldalam suatu metode callAnotherUserdilakukan secara dinamis berdasarkan tipe tertentu dari objek pemanggil selama eksekusi program. Inilah keuntungan utama polimorfisme - pilihan implementasi selama eksekusi program. Dalam contoh kelas telepon di atas, kami menggunakan penggantian metode, yaitu teknik yang mengubah implementasi metode yang ditentukan di kelas dasar tanpa mengubah tanda tangan metode. Ini pada dasarnya adalah penggantian metode, dan ini adalah metode baru yang didefinisikan dalam subkelas yang dipanggil saat program dijalankan. Biasanya, saat mengganti suatu metode, anotasi digunakan @Override, yang memberitahu kompiler untuk memeriksa tanda tangan dari metode yang diganti dan diganti. Oleh karena itu , untuk memastikan bahwa gaya program Anda sesuai dengan konsep OOP dan prinsip OOP java, ikuti tips berikut:

soroti ciri-ciri utama objek;
sorot properti dan perilaku umum dan gunakan warisan saat membuat objek;
gunakan tipe abstrak untuk mendeskripsikan objek;
Usahakan untuk selalu menyembunyikan metode dan field yang terkait dengan implementasi internal kelas.

Komentar

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION