Rehat kopi #90. 4 Tunjang Pengaturcaraan Berorientasikan Objek

Sumber: The Geek Asian Mari kita lihat empat asas pengaturcaraan berorientasikan objek dan cuba memahami cara ia berfungsi. Pengaturcaraan berorientasikan objek (OOP) adalah salah satu paradigma pengaturcaraan utama. Ia boleh menjadi mudah dan ringkas atau, sebaliknya, sangat kompleks. Semuanya bergantung pada cara anda membuat keputusan untuk membangunkan aplikasi anda. Terdapat 4 tiang OOP:

1. Enkapsulasi.
2. Warisan.
3. Abstraksi.
4. Polimorfisme.

Kami kini akan membincangkan setiap daripada mereka dengan penjelasan ringkas dan contoh kod sebenar.

1. Enkapsulasi

Kami semua telah mengkaji enkapsulasi sebagai menyembunyikan elemen data dan membenarkan pengguna mengakses data menggunakan kaedah awam. Kami memanggil getter dan setter ini. Sekarang mari kita lupakan perkara ini dan cari definisi yang lebih mudah. Enkapsulasi ialah kaedah menyekat pengguna daripada menukar secara langsung ahli data atau pembolehubah kelas untuk mengekalkan integriti data. Bagaimana kita melakukan ini? Kami mengehadkan akses kepada pembolehubah dengan menukar pengubah akses kepada peribadi dan mendedahkan kaedah awam yang boleh digunakan untuk mengakses data. Mari lihat contoh khusus di bawah. Ini akan membantu kami memahami cara kami boleh menggunakan enkapsulasi untuk mengekalkan integriti data. Tanpa enkapsulasi:

/**
 * @author thegeekyasian.com
 */
public class Account {

  public double balance;

  public static void main(String[] args) {

  	Account theGeekyAsianAccount = new Account();

  	theGeekyAsianAccount.balance = -54;
  }
}

Dalam coretan kod di atas, kaedah main() mengakses pembolehubah baki secara langsung. Ini membolehkan pengguna menetapkan sebarang nilai berganda kepada pembolehubah baki kelas Akaun . Kami boleh kehilangan integriti data dengan membenarkan sesiapa sahaja menetapkan baki kepada mana-mana nombor yang tidak sah, seperti -54 dalam kes ini. Dengan enkapsulasi:

/**
 * @author thegeekyasian.com
 */
public class Account {

  private double balance;

  public void setBalance(double balance) {

    if(balance >= 0) { // Validating input data in order to maintain data integrity
	  this.balance = balance;
    }

    throw new IllegalArgumentException("Balance cannot be less than zero (0)");
  }

  public static void main(String[] args) {

  	Account theGeekyAsianAccount = new Account();

  	theGeekyAsianAccount.setBalance(1); // Valid input - Allowed
  	theGeekyAsianAccount.setBalance(-55); // Stops user and throws exception
  }
}

Dalam kod ini, kami telah mengehadkan akses kepada pembolehubah baki dan menambah kaedah setBalance() yang membolehkan pengguna menetapkan nilai baki untuk Akaun . Penetap menyemak nilai yang disediakan sebelum memberikannya kepada pembolehubah. Jika nilainya kurang daripada sifar, pengecualian akan dilemparkan. Ini memastikan bahawa integriti data tidak terjejas. Selepas menerangkan contoh di atas, saya berharap nilai enkapsulasi sebagai salah satu daripada empat tiang OOP adalah jelas.

2. Pewarisan

Warisan ialah kaedah mendapatkan sifat kelas lain yang berkongsi ciri biasa. Ini membolehkan kami meningkatkan kebolehgunaan semula dan mengurangkan pertindihan kod. Kaedah ini juga mempunyai prinsip interaksi anak-ibu bapa, apabila unsur anak mewarisi sifat induknya. Mari kita selami dua contoh pantas dan lihat cara warisan menjadikan kod lebih mudah dan lebih boleh digunakan semula. Tanpa warisan:

/**
 * @author thegeekyasian
 */
public class Rectangle {

  private int width;
  private int height;

  public Rectangle(int width, int height) {
	this.width = width;
	this.height = height;
  }

  public int getArea() {
	return width * height;
  }
}

public class Square {

  private int width; // Duplicate property, also used in class Rectangle

  public Square(int width) {
	this.width = width;
  }

  public int getArea() { // Duplicate method, similar to the class Rectangle
	return this.width * this.width;
  }
}

Kedua-dua kelas yang serupa berkongsi sifat lebar dan kaedah getArea() . Kita boleh meningkatkan penggunaan semula kod dengan melakukan sedikit pemfaktoran semula di mana kelas Square akhirnya mewarisi daripada kelas Rectangle . Dengan warisan:

/**
 * @author thegeekyasian
 */
public class Rectangle {

  private int width;
  private int height;

  public Rectangle(int width, int height) {
	this.width = width;
	this.height = height;
  }

  public int getArea() {
	return width * height;
  }
}

public class Square extends Rectangle {

  public Square(int width) {
	super(width, width); // A rectangle with the same height as width is a square
  }
}

Dengan hanya memanjangkan kelas Rectangle , kita mendapat kelas Square sebagai jenis Rectangle . Ini bermakna ia mewarisi semua sifat yang biasa bagi Segiempat dan Segi Empat . Dalam contoh di atas, kita melihat bagaimana warisan memainkan peranan penting dalam menjadikan kod boleh digunakan semula. Ia juga membenarkan kelas untuk mewarisi tingkah laku kelas induknya.

3. Abstraksi

Abstraksi ialah teknik mempersembahkan butiran penting sahaja kepada pengguna dengan menyembunyikan butiran objek yang tidak perlu atau tidak relevan. Ia membantu mengurangkan kerumitan operasi di sisi pengguna. Abstraksi membolehkan kami menyediakan antara muka yang mudah kepada pengguna tanpa meminta butiran rumit untuk melakukan sesuatu tindakan. Ringkasnya, ia memberi pengguna keupayaan untuk memandu kereta tanpa memerlukan mereka memahami dengan tepat bagaimana enjin berfungsi. Mari kita lihat contoh dahulu dan kemudian bincangkan bagaimana abstraksi membantu kita.

/**
* @author thegeekyasian.com
*/
public class Car {

  public void lock() {}
  public void unlock() {}

  public void startCar() {

	checkFuel();
	checkBattery();
	whatHappensWhenTheCarStarts();
  }

  private void checkFuel() {
	// Check fuel level
  }

  private void checkBattery() {
	// Check car battery
  }

  private void whatHappensWhenTheCarStarts() {
	// Magic happens here
  }
}

Dalam kod di atas, kaedah lock() , unlock() dan startCar() adalah awam dan selebihnya adalah peribadi kepada kelas. Kami telah memudahkan pengguna untuk "memandu kereta." Sudah tentu, dia boleh menyemak checkFuel() dan checkBattery() secara manual sebelum memulakan kereta dengan startCar() , tetapi itu hanya akan merumitkan proses. Dengan kod di atas, semua pengguna perlu lakukan ialah menggunakan startCar() dan kelas akan menguruskan yang lain. Inilah yang kita panggil abstraksi.

4. Polimorfisme

Yang terakhir dan paling penting daripada empat tiang OOP ialah polimorfisme. Polimorfisme bermaksud "banyak bentuk." Seperti namanya, ia adalah fungsi yang membolehkan anda melakukan tindakan dalam pelbagai cara atau berbeza. Apabila kita bercakap tentang polimorfisme, tidak banyak yang perlu dibincangkan melainkan kita bercakap tentang jenisnya. Terdapat dua jenis polimorfisme:

1. Kaedah terlebih beban - polimorfisme statik (Pengikat Statik).
2. Kaedah mengatasi - polimorfisme dinamik (Pengikatan Dinamik).

Mari kita bincangkan setiap jenis ini dan lihat apa perbezaan antara mereka.

Kaedah terlebih beban - polimorfisme statik:

Pembebanan kaedah atau polimorfisme statik, juga dikenali sebagai Pengikatan Statik atau pengikatan masa kompilasi, ialah jenis di mana panggilan kaedah ditentukan pada masa penyusunan. Kaedah terlebih beban membolehkan kami mempunyai berbilang kaedah dengan nama yang sama, mempunyai jenis data parameter yang berbeza, atau nombor parameter yang berbeza, atau kedua-duanya. Tetapi persoalannya ialah, mengapa kaedah lebihan beban (atau polimorfisme statik) berguna? Mari lihat contoh di bawah untuk lebih memahami kaedah lebih muatan. Tanpa kelebihan kaedah:

/**
* @author thegeekyasian.com
*/
public class Number {

  public void sumInt(int a, int b) {
	System.out.println("Sum: " + (a + b));
  }

  public void sumDouble(double a, double b) {
	System.out.println("Sum: " + (a + b));
  }

  public static void main(String[] args) {

	Number number = new Number();

	number.sumInt(1, 2);
	number.sumDouble(1.8, 2.5);
  }
}

Dalam contoh di atas, kami mencipta dua kaedah dengan nama yang berbeza, hanya untuk menambah dua jenis nombor yang berbeza. Jika kami meneruskan pelaksanaan yang serupa, kami akan mempunyai berbilang kaedah dengan nama yang berbeza. Ini akan mengurangkan kualiti dan ketersediaan kod. Untuk menambah baik ini, kita boleh menggunakan kaedah terlebih beban dengan menggunakan nama yang sama untuk kaedah yang berbeza. Ini akan membolehkan pengguna mempunyai satu pilihan sebagai titik masuk untuk menjumlahkan pelbagai jenis nombor. Kaedah terlebih beban berfungsi apabila dua atau lebih kaedah mempunyai nama yang sama tetapi parameter berbeza. Jenis pulangan boleh sama atau berbeza. Tetapi jika dua kaedah mempunyai nama yang sama, parameter yang sama, tetapi jenis pulangan yang berbeza, maka ini akan menyebabkan beban berlebihan dan ralat kompilasi! Dengan kaedah lebihan beban:

/**
* @author thegeekyasian.com
*/
public class Number {

  public void sum(int a, int b) {
	System.out.println("Sum: " + (a + b));
  }

  public void sum(double a, double b) {
	System.out.println("Sum: " + (a + b));
  }

  public static void main(String[] args) {

	Number number = new Number();

	number.sum(1, 2);
	number.sum(1.8, 2.5);
  }
}

Dalam kod yang sama, dengan beberapa perubahan kecil, kami dapat membebankan kedua-dua kaedah, menjadikan nama yang sama untuk kedua-duanya. Pengguna kini boleh menentukan jenis data khusus mereka sebagai parameter kaedah. Ia kemudian akan melakukan tindakan berdasarkan jenis data yang disediakan. Pengikatan kaedah ini dilakukan pada masa penyusunan kerana pengkompil mengetahui kaedah mana yang akan dipanggil dengan jenis parameter yang ditentukan. Itulah sebabnya kami memanggilnya mengikat masa kompilasi.

Kaedah mengatasi - polimorfisme dinamik:

Tidak seperti kaedah overloading, kaedah overriding membolehkan anda mempunyai tandatangan yang sama seperti berbilang kaedah, tetapi ia mesti berada dalam beberapa kelas yang berbeza. Persoalannya, apakah keistimewaannya? Kelas ini mempunyai hubungan IS-A, iaitu, mereka mesti mewarisi antara satu sama lain. Dalam erti kata lain, dalam kaedah mengatasi atau polimorfisme dinamik, kaedah diproses secara dinamik pada masa jalan apabila kaedah dipanggil. Ini dilakukan berdasarkan rujukan kepada objek yang dimulakan. Berikut ialah contoh kecil kaedah mengatasi:

/**
* @author thegeekyasian.com
*/
public class Animal {

  public void walk() {
	System.out.println("Animal walks");
  }
}

public class Cat extends Animal {

  @Override
  public void walk() {
	System.out.println("Cat walks");
  }
}

public class Dog extends Animal {

  @Override
  public void walk() {
	System.out.println("Dog walks");
  }
}

public class Main {

  public static void main(String[] args) {

	Animal animal = new Animal();
	animal.walk(); // Animal walks

	Cat cat = new Cat();
	cat.walk(); // Cat walks

	Dog dog = new Dog();
	dog.walk(); // Dog walks

	Animal animalCat = new Cat(); // Dynamic Polymorphism
	animalCat.walk(); // Cat walks

	Animal animalDog = new Dog(); // Dynamic Polymorphism
	animalDog.walk(); //Dog walks
  }
}

Dalam contoh utama ini, kami memperuntukkan objek jenis "Anjing" dan "Kucing" secara dinamik untuk menaip "Haiwan". Ini membolehkan kami memanggil kaedah walk() pada contoh yang dirujuk secara dinamik semasa masa jalan. Kita boleh melakukan ini menggunakan kaedah mengatasi (atau polimorfisme dinamik). Ini menyimpulkan perbincangan ringkas kami tentang empat tunjang OOP dan saya harap anda mendapati ia berguna.