-->
Beranda  ›  CPP  ›  Pemrograman

Pemrograman #5 - Pewarisan



Pewarisan (Inheritance)

Salah satu konsep yang paling penting dalam pemrograman berorientasi objek adalah pewarisan. Pewarisan memungkinkan untuk mendefinisikan aturan kelas dalam kelas yang lain, yang membuatnya lebih mudah untuk menciptakan dan memelihara aplikasi. Pewarisan juga memberikan kesempatan untuk menggunakan kembali kode fungsi dan waktu yang cepat dalam mengimplementasikannya.

Konsep pewarisan juga bisa diartikan dimana suatu kelas dapat mempunyai kelas turunan. Ketika membuat sebuah kelas, ketika berhasil membuat data member dan fungsi member, maka kelas tersebut bisa dinyatakan bahwa semua data member dan fungsi membernya dapat diwariskan ke kelas yang lain.
Kelas yang mewarisi data member dan fungsi membernya biasa disebut sebagai Base Class. sedangkan kelas yang diwarisi oleh kelas yang lain dapat juga disebut Derived Class.

Base Class dan Derived Class

Kelas dapat menurunkan lebih dari satu kelas, yang berarti bahwa kelas (base class) tersebut dapat menurunkan data dan fungsi membernya ke beberapa kelas turunan (derived class). Untuk dapat mendefinisikan kelas yang diturunkan, maka harus menspesifikasikan daftar dari kelas dasarnya. Berikut bentuk dasar dalam melakukan teknik pewarisan pada C++:
class <derived-class>: <access-specifier> <base-class>

Perhatikan contoh kasus berikut : 
class Student {
  protected:
    string nim;
    string name;
    string gender;
  public : 
    Student() {}
    Student(string cNim, string cName, string cGender): 
      nim{cNim}, 
        name{cName},
      gender{cGender} {}
    void showName() {
      cout << name;
    }
    ~Student() {}
};
Pada contoh diatas terdapat sebuah kelas dengan nama “Student” dalam kasus ini kelas tersebut akan dijadikan sebagai kelas dasar (base class). berikutnya akan dibuat sebuah kelas yang akan mewarisi data dan fungsi member dari kelas “Student”. kelas tersebut diberi nama “AcadResults”.
class AcadResults: public Student { // Pendefinisian inheritance
  private:
    // Attribute Member
    float ipk;
    int sks;
  public:
    // Constructor
    AcadResults(float cIpk, int cSks):
      ipk{cIpk},
      sks{cSks} {}
  AcadResults(string cNim, string cName, 
          string cGender, float cIpk, 
          int cSks):
      Student(cNim, cName, cGender), 
      ipk{cIpk},
      sks{cSks} {}
    // Method Member
    void printOutput();                 // Overloading
    void printOutput(string prename);   // Overloading
    // Destructor
    ~AcadResults() {}
};
Pada kasus diatas dapat dilihat bahwa kelas “AcadStudent” dapat dikatakan sebagai kelas yang diwarisi (derived class). Maka dari itu setiap kali kelas “AcadStudent” diakses (proses instansiasi dimana konstruktor pada kelas tersebut dipanggil). maka secara otomatis konstruktor yang ada pada kelas “Student” juga akan terpanggil walaupun tidak tertuliskan didalam konstruktor kelas “AcadStudent”.

Kontrol Akses dalam pewarisan

Setiap kelas yang terwariskan, maka kelas tersebut dapat mengakses semua member pada kelas dasar yang tidak kerkena akses private. Dengan demikian jika ada fungsi atau data member yang tidak boleh diakses oleh kelas turunan. maka member tersebut harus dinyatakan sebagai akses private.

Berikut tabel jenis akses yang boleh diakses maupun yang tidak boleh diakses dalam sistem pewarisan:
Kontrol Aksesprivatepublicprotected
Kelas yang samaBisaBisaBisa
Kelas turunanDitolakBisaBisa
Kelas yang diluarDitolakBisaDitolak

Kelas yang diturunkan mewarisi semua metode dari kelas dasar dengan beberapa pengecualian sebagai berikut:
  • Konstruktor dan Destruktor dari kelas dasar.
  • Overloading operator dari kelas dasar.
  • Fungsi yang dinyatakan sebagai “friend function” dari kelas dasar

Tipe-tipe dalam pewarisan

Ketika kelas diwariskan dari kelas dasar, maka kelas dasar dapat diwariskan melalui beberapa tipe pewarisan antara lain: private inheritance, public inheritance, dan protected inheritance. tipe dari pewarisan tersebut ditentukan oleh kontrol akses seperti yang dijelaskan pada tabel kontrol akses diatas.

Pewarisan dengan tipe private inheritance dan protected inheritance sangat jarang dijumpai. karena umumnya pewarisan pada C++ menggunakan tipe pewarisan public inheritance. Dan ketika menggunakan berbagai jenis pewarisan. Maka pewarisan tersebut akan mengikuti beberapa aturan-aturan yang diterapkan:
  • Public Inheritance, ketika kelas diwariskan dari kelas dasar dengan akses public, maka public member yang ada pada kelas dasar akan menjadi public member bagi kelas turunannya, protected member yang ada pada kelas dasar akan menjadi protected member bagi kelas turunannya, dan private member yang ada kelas dasar tetap tidak akan bisa diakses oleh kelas turunan. dan jika tetap ingin diakses maka private member tersebut hanya bisa diakses melewati proses enkapsulasi.
  • Private Inheritance, ketika kelas diwariskan dari kelas dasar dengan akses private, maka public dan protected member yang ada pada kelas dasar akan menjadi private member bagi kelas turunannya.
  • Protected Inheritance, ketika kelas diwariskan dari kelas dasar dengan akses protected, maka public dan protected member yang ada pada kelas dasar akan menjadi protected member bagi kelas turunannya.

Berikut contoh lengkap dari pewarisan yang dilakukan dengan tipe public inheritance. dimana kelas “Student” sebagai kelas dasar dan “AcadResults” sebagai kelas turunannya.
/* Berkas inheritance.cpp */

#include <iostream>
using namespace std;

class Student {
protected:
  string nim;
  string name;
  string gender;
public:
  Student() {}
  Student(string cNim, string cName, string cGender):
    nim{cNim},
    name{cName},
    gender{cGender} {}
      void showName() {
        cout << name;
      }
  ~Student() {}
};

class AcadResults: public Student {
private:
  float ipk;
  int sks;
public:
  AcadResults(float cIpk, int cSks):
    ipk{cIpk},
    sks{cSks} {}
  AcadResults(string cNim, string cName, string cGender, float cIpk, int cSks) :
    Student(cNim, cName, cGender),
    ipk{cIpk},
    sks{cSks} {}
  void printOutput();
  void printOutput(string prename);
  ~AcadResults() {}
};

void AcadResults::printOutput() {
  showName();
  cout << " : " << ipk << endl;
}

void AcadResults::printOutput(string prename) {
  cout << prename << " ";
  showname(); 
  cout << " : " << ipk << endl;
}

int main() {
  AcadResults result("16.11.0035", "CatetanInformatika", "M", "3.5", "3.6");
  result.printOutput("Mr.");

  return 0;
}

Pewarisan Berlapis (Multiple Inheritance)

Sebuah kelas sangat memungkinkan diwarisi oleh lebih dari satu kelas dasar, proses ini pada C++ dikenal dengan nama Multiple Inheritance. pada Multiple Inheritance, kelas yang diturunkan akan mampu mewarisi semua member dari kelas-kelas dasarnya dengan ketentuan pewarisan yang telah dibahas sebelumnya. berikut contoh lengkap untuk Multiple Inheritance.
/* Berkas MultipleInheritance.cpp */
#include <iostream>
using namespace std;

class PrintData {
  public:
    PrintData() {}
    void printOutput(string data) {
      cout << data << endl;
    }
    void printOutput(float data) {
      cout << data << endl;
    } 
    void printOutput(int data) {
      cout << data << endl;
    }         
    ~PrintData() {}
};

class Student {
  protected:
    string nim;
    string name;
    string gender;
  public : 
    Student() {}
    Student(string cNim, string cName, string cGender): 
      nim{cNim}, 
        name{cName},
      gender{cGender} {}
    string getName() {return name;}
    void setName(string cName) {name = cName;}
    ~Student() {}
};

class Staff: public PrintData {
  private:
    string name;
  public:
    Staff() {}
    string getName() {return name;}
    void setName(string cName) {name = cName;}
    ~Staff() {}
};

class AcadResults: public Student, public PrintData {
  private:
    float ipk;
    int sks;
  public:
    AcadResults() {}
    AcadResults(float cIpk, int cSks):
      ipk{cIpk},
      sks{cSks} {}

    AcadResults(string cNim, string cName, 
            string cGender, float cIpk, int cSks):
      Student(cNim, cName, cGender),
      ipk{cIpk},
      sks{cSks} {}
    float getIpk() {return ipk;}
    void setIpk(float cIpk) {ipk = cIpk;}
    ~AcadResults() {}
};

int main() {
  AcadResults result("09.51.0045", 
                     "Fai Filza",
                     "M", 3.25, 36);
  result.printOutput(result.getName());
  result.printOutput(result.getIpk());
  
  Staff staff;
  staff.printOutput("Another Name");
  return 0;
}
Pada contoh kasus diatas Multiple Inheritance melibatkan empat buah kelas yaitu “PrintData”, “Student”, “Staff”, “AcadResults”. yang dihubungkan dengan rangkaian pewarisan. jika digambarkan akan menjadi seperti gambar dibawah ini.


Pada gambar skema kelas diatas dapat dilihat ada sebuah kelas yang diwarisi oleh dua buah kelas. Pemrogramman berorientasi objek pada C++ memang mengijinkan hal itu terjadi. oleh sebab itu kelas “AcadResults” dapat mengakses member yang ada pada kelas “PrintData” dan “Student”. sedangkan kelas “PrintData” memiliki dua buah kelas turunan yaitu “AcadResults” dan “Staff”.


Upcasting

Upcasting menggunakan referensi atau pointer dari kelas dasar yang merujuk kepada objek dari kelas turunan. Atau dapat dikatakan bahwa aksi yang merubah referensi atau pointer dari kelas turunan ke referensi atau pointer dari kelas dasar itulah yang disebut upcasting.


Berikut potongan kode yang menunjukan proses upcasting pada konsep pewarisan.
/* Berkas Upcasting.cpp */
#include <iostream>
using namespace std;

class Student {
  protected:
    string nim;
  public : 
    Student() {}
    void printOutput() {
      cout << "Welcome...";
    }
    ~Student() {}
};

class AcadResults: public Student {
  private:
    float ipk;
  public:
    AcadResults(float cIpk) : ipk{cIpk} {}
    void printOutput() {
      cout << ipk;
    }
    ~AcadResults() {}
};

int main() {
  Student* ptr;  // Base class pointer
  AcadResults academy(3.25);
  ptr = &academy;   // Upcasting
  ptr->printOutput();
  return 0;
}
Load Comments

Iklan Atas Artikel

Iklan Tengah Artikel 1

Iklan Tengah Artikel 2

Iklan Bawah Artikel