F # - Warisan

Salah satu konsep terpenting dalam pemrograman berorientasi objek adalah konsep inheritance. Inheritance memungkinkan kita untuk mendefinisikan kelas dalam istilah kelas lain, yang membuatnya lebih mudah untuk membuat dan memelihara aplikasi. Ini juga memberikan kesempatan untuk menggunakan kembali fungsionalitas kode dan waktu implementasi yang cepat.

Saat membuat kelas, alih-alih menulis anggota data dan fungsi anggota yang benar-benar baru, pemrogram dapat menetapkan bahwa kelas baru harus mewarisi anggota kelas yang sudah ada. Kelas yang sudah ada ini disebut kelas dasar, dan kelas baru disebut sebagai kelas turunan.

Ide pewarisan mengimplementasikan hubungan IS-A. Misal, mamalia IS A binatang, anjing IS-A mamalia maka anjing IS-A binatang begitu juga dan seterusnya.

Kelas Dasar dan Sub Kelas

Subclass diturunkan dari kelas dasar, yang sudah ditentukan. Subkelas mewarisi anggota kelas dasar, serta memiliki anggota sendiri.

Sebuah subclass didefinisikan menggunakan inherit kata kunci seperti yang ditunjukkan di bawah ini -

type MyDerived(...) =
   inherit MyBase(...)

Dalam F #, sebuah kelas dapat memiliki paling banyak satu kelas dasar langsung. Jika Anda tidak menentukan kelas dasar dengan menggunakaninherit kata kunci, kelas secara implisit mewarisi dari Object.

Harap diperhatikan -

Metode dan anggota kelas dasar tersedia untuk pengguna kelas turunan seperti anggota langsung dari kelas turunan.
Biarkan binding dan parameter konstruktor bersifat privat ke kelas dan, oleh karena itu, tidak dapat diakses dari kelas turunan.
Kata kunci basemengacu pada instance kelas dasar. Ini digunakan seperti pengenal diri.

Contoh

type Person(name) =
   member x.Name = name
   member x.Greet() = printfn "Hi, I'm %s" x.Name

type Student(name, studentID : int) =
   inherit Person(name)
   let mutable _GPA = 0.0
   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value

type Teacher(name, expertise : string) =
   inherit Person(name)

   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value
   member x.Expertise = expertise

//using the subclasses
let p = new Person("Mohan")
let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

p.Greet()
st.Greet()
tr.Greet()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Hi, I'm Mohan
Hi, I'm Zara
Hi, I'm Mariam

Metode Utama

Anda dapat mengganti perilaku default metode kelas dasar dan menerapkannya secara berbeda di subkelas atau kelas turunan.

Metode di F # tidak dapat diganti secara default.

Untuk mengganti metode dalam kelas turunan, Anda harus mendeklarasikan metode Anda sebagai dapat diganti menggunakan abstract dan default kata kunci sebagai berikut -

type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit
   default x.Greet() = printfn "Hi, I'm %s" x.Name

Sekarang, Greet metode kelas Person dapat diganti dalam kelas turunan. Contoh berikut menunjukkan ini -

Contoh

type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit
   default x.Greet() = printfn "Hi, I'm %s" x.Name

type Student(name, studentID : int) =
   inherit Person(name)

   let mutable _GPA = 0.0

   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value
   override x.Greet() = printfn "Student %s" x.Name

type Teacher(name, expertise : string) =
   inherit Person(name)
   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value

   member x.Expertise = expertise
   override x.Greet() = printfn "Teacher %s." x.Name

//using the subclasses
let p = new Person("Mohan")
let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

//default Greet
p.Greet()

//Overriden Greet
st.Greet()
tr.Greet()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Hi, I'm Mohan
Student Zara
Teacher Mariam.

Kelas Abstrak

Terkadang Anda perlu memberikan implementasi objek yang tidak lengkap, yang seharusnya tidak diimplementasikan dalam kenyataan. Kemudian, beberapa programmer lain harus membuat subclass dari kelas abstrak untuk implementasi lengkap.

Misalnya, kelas Person tidak diperlukan dalam Sistem Manajemen Sekolah. Namun, kelas Murid atau Guru akan dibutuhkan. Dalam kasus seperti itu, Anda dapat mendeklarasikan kelas Person sebagai kelas abstrak.

Itu AbstractClass atribut memberi tahu kompiler bahwa kelas tersebut memiliki beberapa anggota abstrak.

Anda tidak dapat membuat instance dari kelas abstrak karena kelas tersebut tidak diimplementasikan sepenuhnya.

Contoh berikut menunjukkan ini -

Contoh

[<AbstractClass>]
type Person(name) =
   member x.Name = name
   abstract Greet : unit -> unit

type Student(name, studentID : int) =
   inherit Person(name)
   let mutable _GPA = 0.0
   member x.StudentID = studentID
   member x.GPA
      with get() = _GPA
      and set value = _GPA <- value
   override x.Greet() = printfn "Student %s" x.Name

type Teacher(name, expertise : string) =
   inherit Person(name)
   let mutable _salary = 0.0
   member x.Salary
      with get() = _salary
      and set value = _salary <- value
   member x.Expertise = expertise
   override x.Greet() = printfn "Teacher %s." x.Name

let st = new Student("Zara", 1234)
let tr = new Teacher("Mariam", "Java")

//Overriden Greet
st.Greet()
tr.Greet()

Ketika Anda mengkompilasi dan menjalankan program, itu menghasilkan output berikut -

Student Zara
Teacher Mariam.