Masukkan Password
58 6.7 What is Inheritance in OOP | Inheritance in Dart Programming | Learn OOP in Dart | Dart Course
Materi kali ini membahas Inheritance (pewarisan) dalam OOP Dart. Ini adalah konsep yang sangat penting karena mulai dari sini kita akan melihat bagaimana satu class bisa mewarisi property dan method dari class lain.
Caption-nya cukup panjang, jadi saya akan pecah menjadi bagian-bagian kecil agar mudah dipahami.
Catatan: caption beberapa kali menulis “DOT programming language”. Maksudnya adalah Dart programming language.
1. Apa itu Inheritance?
Inheritance berarti pewarisan.
Dalam OOP, inheritance adalah mekanisme yang memungkinkan sebuah class mendapatkan atau mewarisi property dan method dari class lain.
Contoh sederhana:
Person
↑
│ mewarisi
│
Student
Kita punya:
Person→ parent classStudent→ child class
Karena Student mewarisi Person, maka Student bisa menggunakan hal-hal yang dimiliki Person.
2. Analogi Kehidupan Nyata
Bayangkan:
Person
│
┌──────┴──────┐
↓ ↓
Student Teacher
Person mungkin mempunyai:
- nama
- umur
- berbicara
- berjalan
Student juga merupakan Person.
Maka Student bisa mendapatkan:
Student
├── name ← dari Person
├── age ← dari Person
├── talk() ← dari Person
├── roleNumber ← milik Student
└── marks ← milik Student
Jadi Student memiliki kemampuan miliknya sendiri ditambah kemampuan dari Person.
3. Parent Class dan Child Class
Dalam inheritance ada beberapa istilah yang perlu kamu kenal.
Misalnya:
class Person {
}
dan:
class Student extends Person {
}
Maka:
Person
Disebut:
- Parent class
- Superclass
- Base class
Student
Disebut:
- Child class
- Subclass
- Derived class
Untuk pemula, cukup ingat:
Person = Parent
Student = Child
4. Keyword extends
Inheritance di Dart menggunakan keyword:
extends
Contohnya:
class Person {
void sayHello() {
print("Hello");
}
}
class Student extends Person {
}
Artinya:
StudentmewarisiPerson.
Secara visual:
Person
│
│ extends
↓
Student
Karena Student extends Person, object Student dapat menggunakan member yang diwarisi dari Person.
5. Contoh Paling Sederhana
class Person {
void sayHello() {
print("Hello, I am a person");
}
}
class Student extends Person {
}
Kemudian:
void main() {
Student student = Student();
student.sayHello();
}
Output:
Hello, I am a person
Padahal kita tidak membuat sayHello() di Student.
Kenapa bisa?
Karena Student mewarisi Person.
Person
└── sayHello()
↓ diwariskan
Student
└── sayHello()
6. Student Bisa Memiliki Property Sendiri
Inheritance bukan berarti Student hanya memiliki property dari Person.
Student bisa memiliki property tambahan.
Contoh:
class Person {
String name = "";
int age = 0;
}
class Student extends Person {
int roleNumber = 0;
int marks = 0;
}
Sekarang Student mempunyai:
Student
├── name ← diwarisi dari Person
├── age ← diwarisi dari Person
├── roleNumber ← milik Student
└── marks ← milik Student
Jadi:
void main() {
Student student = Student();
student.name = "Budi";
student.age = 20;
student.roleNumber = 10;
student.marks = 90;
}
Semuanya bisa digunakan.
7. Kenapa student.name Bisa Digunakan?
Ini bagian penting dari video.
Kita punya:
class Person {
String name = "";
int age = 0;
}
name dan age adalah milik Person.
Kemudian:
class Student extends Person {
int roleNumber = 0;
int marks = 0;
}
Karena:
Student extends Person
maka Student mendapatkan member yang diwariskan dari Person.
Sehingga:
Student student = Student();
student.name;
student.age;
student.roleNumber;
student.marks;
semuanya tersedia sesuai aturan akses Dart.
8. Inheritance Tidak Meng-copy Class Secara Sederhana
Jangan membayangkan seperti:
Person
↓
copy semua kode
↓
Student
Lebih baik bayangkan:
Student
│
└── merupakan Person
│
├── name
├── age
└── method
Student memperoleh akses terhadap behavior/member yang diwariskan dari Person.
9. Child Bisa Memanggil Method Parent
Misalnya:
class Person {
void sayHello() {
print("Hello from Person");
}
}
class Student extends Person {
void study() {
print("Student is studying");
}
}
Kemudian:
void main() {
Student student = Student();
student.sayHello();
student.study();
}
Output:
Hello from Person
Student is studying
Perhatikan:
Student
├── sayHello() ← dari Person
└── study() ← milik Student
Ini inti inheritance.
10. Constructor dan Inheritance
Bagian video berikutnya membahas sesuatu yang sangat penting:
Bagaimana kalau Parent mempunyai constructor yang membutuhkan parameter?
Misalnya:
class Person {
String name;
int age;
Person(this.name, this.age);
}
Constructor Person membutuhkan:
name
age
Kemudian kita membuat:
class Student extends Person {
int roleNumber;
int marks;
Student(this.roleNumber, this.marks);
}
Ini akan bermasalah karena constructor parent membutuhkan name dan age.
Bagaimana cara memberikannya?
Gunakan:
super
11. Apa itu super?
super digunakan untuk mengakses atau berhubungan dengan parent class.
Kalau:
this
berarti:
object/class saat ini
maka:
super
berarti:
parent class
Gampangnya:
this
↓
saya / object sekarang
super
↓
orang tua / parent class
12. super() untuk Memanggil Constructor Parent
Contoh:
class Person {
String name;
int age;
Person(this.name, this.age);
}
class Student extends Person {
int roleNumber;
int marks;
Student(
this.roleNumber,
this.marks,
String name,
int age,
) : super(name, age);
}
Perhatikan:
: super(name, age)
Ini berarti:
Panggil constructor
Persondan berikannamesertaage.
13. Mari Bedah Constructor Student
Bagian ini:
Student(
this.roleNumber,
this.marks,
String name,
int age,
) : super(name, age);
memiliki dua kelompok data.
Untuk Student
this.roleNumber
this.marks
langsung mengisi property milik Student.
Untuk Person
String name
int age
diteruskan ke:
super(name, age)
yang kemudian masuk ke constructor Person.
14. Alur Data
Misalnya:
Student student = Student(
23,
90,
"Budi",
20,
);
Alurnya:
Student(
23,
90,
"Budi",
20
)
│
├── 23 → roleNumber
├── 90 → marks
│
└── super("Budi", 20)
│
↓
Person constructor
│
┌──────┴──────┐
↓ ↓
name age
"Budi" 20
Akhirnya object Student mempunyai:
Student
├── name = Budi
├── age = 20
├── roleNumber = 23
└── marks = 90
15. Contoh Lengkap
Mari kita buat versi yang mudah dibaca:
class Person {
String name;
int age;
Person(this.name, this.age);
}
class Student extends Person {
int roleNumber;
int marks;
Student(
this.roleNumber,
this.marks,
String name,
int age,
) : super(name, age);
void display() {
print("Name: $name");
print("Age: $age");
print("Role Number: $roleNumber");
print("Marks: $marks");
}
}
void main() {
Student student = Student(
23,
90,
"Budi",
20,
);
student.display();
}
Output:
Name: Budi
Age: 20
Role Number: 23
Marks: 90
Perhatikan display() berada di Student, tetapi di dalamnya kita bisa menggunakan:
$name
$age
padahal name dan age didefinisikan di Person.
Kenapa?
Karena Student extends Person.
16. Kenapa super Harus Sesuai dengan Constructor Parent?
Misalnya Parent:
class Person {
String name;
int age;
Person(this.name, this.age);
}
Berarti constructor parent membutuhkan 2 argument:
Person(name, age)
Maka:
super(name, age);
✅ benar.
Tetapi:
super(name);
❌ salah.
Karena parent membutuhkan dua argument.
Dan:
super(name, age, address);
❌ juga salah.
Karena parent hanya menerima dua argument.
Jadi:
Person(this.name, this.age)
↓
membutuhkan 2
super(name, age)
↓
memberikan 2
↓
✅
17. Urutan Constructor pada Inheritance
Ini juga sangat penting.
Ketika kita membuat:
Student student = Student(...);
constructor parent akan dijalankan terlebih dahulu sebelum constructor child selesai dijalankan.
Secara konsep:
Student dibuat
↓
Constructor Person
↓
Constructor Student
↓
Object Student selesai dibuat
Misalnya:
class Person {
Person() {
print("Person constructor");
}
}
class Student extends Person {
Student() {
print("Student constructor");
}
}
Kemudian:
void main() {
Student student = Student();
}
Output:
Person constructor
Student constructor
Kenapa Person dulu?
Karena Student merupakan turunan dari Person.
18. Kalau Constructor Parent Tidak Memiliki Parameter
Misalnya:
class Person {
Person() {
print("I am a person");
}
}
class Student extends Person {
Student() {
print("I am a student");
}
}
Kita tidak perlu menulis:
super();
secara eksplisit dalam kasus sederhana ini.
Dart akan memanggil unnamed no-argument superclass constructor jika tersedia.
Jadi:
Student student = Student();
akan menjalankan:
I am a person
I am a student
Ini menjelaskan kenapa di bagian awal video, ketika hanya membuat:
Student student = Student();
constructor Person juga dijalankan.
19. Inheritance dengan File Terpisah
Video juga menunjukkan bahwa class bisa disimpan dalam file berbeda.
Misalnya struktur project:
project/
│
├── main.dart
├── person.dart
└── student.dart
person.dart
class Person {
String name;
int age;
Person(this.name, this.age);
}
student.dart
Karena Student ingin extends Person, kita import dulu:
import 'person.dart';
class Student extends Person {
int roleNumber;
int marks;
Student(
this.roleNumber,
this.marks,
String name,
int age,
) : super(name, age);
}
main.dart
Kita import Student:
import 'student.dart';
void main() {
Student student = Student(
23,
90,
"Budi",
20,
);
}
Jadi:
main.dart
│
│ import
↓
student.dart
│
│ import
↓
person.dart
20. Kenapa Memisahkan File?
Bayangkan project kecil:
main.dart
person.dart
student.dart
teacher.dart
car.dart
bank_account.dart
Daripada semua class ditaruh di main.dart, lebih rapi jika dipisahkan berdasarkan tanggung jawab.
Misalnya:
person.dart
↓
Person
student.dart
↓
Student
teacher.dart
↓
Teacher
Kemudian main.dart hanya menggunakan class tersebut.
Ini membuat project lebih:
- rapi
- mudah dicari
- mudah dirawat
- mudah dikembangkan
21. Inheritance Memberikan “IS-A Relationship”
Ada konsep penting dalam OOP:
Student is a Person.
Artinya:
Student IS-A Person
Karena Student memang merupakan jenis Person.
Begitu juga:
Dog IS-A Animal
Cat IS-A Animal
Teacher IS-A Person
Manager IS-A Employee
Contoh yang cocok:
class Animal {}
class Dog extends Animal {}
Dog adalah Animal.
Tetapi hati-hati dengan hubungan yang tidak cocok.
Misalnya:
Car IS-A Engine
❌ Tidak tepat.
Car memiliki Engine, bukan Car adalah Engine.
Ini lebih cocok dengan konsep composition yang akan dipelajari kemudian.
22. Apa yang Didapat Child dari Parent?
Secara sederhana, child bisa mendapatkan:
Property/field
String name;
int age;
Method
void walk() {}
void talk() {}
Jadi:
Person
├── name
├── age
├── walk()
└── talk()
↓ diwariskan
Student
├── name
├── age
├── walk()
├── talk()
├── roleNumber
└── marks
Namun jangan mengartikan inheritance sebagai “child selalu boleh mengakses semua hal parent”. Private member memiliki aturan library privacy dan tidak otomatis dapat diakses langsung dari subclass jika berada di library berbeda.
23. Parent Juga Bisa Memiliki Method yang Digunakan Child
Contoh:
class Person {
void walk() {
print("Person is walking");
}
}
class Student extends Person {
void study() {
print("Student is studying");
}
}
Kemudian:
Student student = Student();
student.walk();
student.study();
Output:
Person is walking
Student is studying
Jadi Student memiliki behavior:
Inherited:
walk()
Own:
study()
24. Jangan Salah Memahami extends
Kalau kita menulis:
class Student extends Person
bukan berarti:
Person menjadi Student.
Justru:
Student menjadi turunan dari Person.
Jadi arah inheritance:
Person
↑
│
Student
atau bisa dibaca:
Student
└── adalah Person
25. Hubungannya dengan OOP yang Sudah Kita Pelajari
Sebelumnya kita sudah belajar:
Class
class Person {}
Class = blueprint.
Object
Person person = Person();
Object = instance dari class.
Encapsulation
String _name;
Data dilindungi.
Getter/Setter
String get name => _name;
set name(String value) => _name = value;
Mengontrol akses data.
Sekarang:
Inheritance
class Student extends Person {}
Student mendapatkan kemampuan dari Person.
26. Gambaran Besar
Kalau digabung:
OOP
│
┌─────────┼─────────┐
↓ ↓ ↓
Class Object Encapsulation
│
↓
Getter/Setter
+
↓
Inheritance
│
↓
Parent Class
│
extends
↓
Child Class
27. Contoh Dunia Nyata: Person → Student
Mari buat desain yang lebih realistis.
class Person {
String name;
int age;
Person(this.name, this.age);
void introduce() {
print("My name is $name");
print("I am $age years old");
}
}
class Student extends Person {
int studentId;
double marks;
Student(
this.studentId,
this.marks,
String name,
int age,
) : super(name, age);
void study() {
print("$name is studying");
}
}
Penggunaan:
void main() {
Student student = Student(
101,
90,
"Budi",
20,
);
student.introduce();
student.study();
}
Output:
My name is Budi
I am 20 years old
Budi is studying
Student bisa menggunakan:
Dari Person:
├── name
├── age
└── introduce()
Dari Student:
├── studentId
├── marks
└── study()
28. Hal yang Perlu Kamu Hafalkan
Ada beberapa keyword yang sangat penting:
| Keyword | Arti |
|---|---|
class | membuat class |
extends | melakukan inheritance |
super | mengacu pada parent |
this | mengacu pada object saat ini |
import | menggunakan library/file lain |
Contoh:
class Student extends Person {
Student(
this.roleNumber,
String name,
int age,
) : super(name, age);
}
Di sini:
class
↓
membuat class
extends Person
↓
Student mewarisi Person
this.roleNumber
↓
property milik Student
super(name, age)
↓
kirim data ke constructor Person
29. Kesalahan yang Sering Dilakukan Pemula
❌ Salah 1: Mengira extends berarti copy-paste
Bukan sekadar copy-paste kode.
Inheritance membuat hubungan parent-child dan memungkinkan child mewarisi behavior/member sesuai aturan akses.
❌ Salah 2: Lupa super
Kalau constructor parent membutuhkan parameter:
Person(this.name, this.age);
child perlu meneruskannya:
Student(...) : super(name, age);
❌ Salah 3: Jumlah argument super salah
Parent:
Person(String name, int age)
Maka:
super(name, age)
✅
Bukan:
super(name)
❌
❌ Salah 4: Mengira child hanya memiliki property-nya sendiri
Tidak.
Student memiliki member miliknya sendiri dan member yang diwariskan dari Person yang dapat diakses sesuai aturan.
30. Inti Materi Hari Ini
Kalau disederhanakan sekali:
PERSON
│
│ extends
↓
STUDENT
Person adalah parent.
Student adalah child.
Student mendapatkan kemampuan dari Person.
Contoh:
class Person {
String name = "";
int age = 0;
void sayHello() {
print("Hello");
}
}
class Student extends Person {
int marks = 0;
}
Sekarang:
Student student = Student();
student.name; // dari Person
student.age; // dari Person
student.sayHello(); // dari Person
student.marks; // dari Student
31. Dan super…
Kalau parent memiliki constructor:
class Person {
String name;
int age;
Person(this.name, this.age);
}
Child:
class Student extends Person {
int marks;
Student(
this.marks,
String name,
int age,
) : super(name, age);
}
Maka:
Student("Budi", 20, 90)
│
├── data Student
│
└── super(...)
↓
Person constructor
extends = mewarisi class parent.
super = berkomunikasi/memanggil bagian parent, termasuk constructor parent.
🧠 Kalimat yang paling penting untuk diingat
Inheritance adalah kemampuan sebuah class untuk mewarisi behavior dan member dari class lain. Di Dart, inheritance dilakukan menggunakan
extends. Class yang diwarisi disebut parent/superclass, sedangkan class yang mewarisi disebut child/subclass. Jika child perlu memanggil constructor parent, kita dapat menggunakansuper(...).
Dan pola utamanya:
class Parent {
// data + method
}
class Child extends Parent {
// data + method milik Child
// + member yang diwarisi dari Parent
}
Sedangkan jika constructor parent membutuhkan data:
class Child extends Parent {
Child(...) : super(...);
}
Jadi setelah materi ini, kamu sudah punya gambaran yang cukup lengkap tentang hubungan:
Class → Object → Constructor → Encapsulation → Getter/Setter → Inheritance → extends → super.