Inheritance

ทินภัทร อันอาจงาม 640710518

Inheritance คือ คุณสมบัติการสืบทอดในการเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming / OOP) โดย คลาสรอง/คลาสลูก (Child Class) จะสามารถสืบทอดคุณสมบัติ (Property), ตัวแปร (Variable) และ เมธอด (Method) มาจากคลาสหลัก/คลาสแม่ (Parent Class) ได้

รองรับการจำแนกเป็นลำดับขั้นตอน
การสืบทอดมี 3 แบบคือ สืบทอดครั้งเดียว, สืบทอดหลายครั้ง และสืบทอดหลายระดับ ซึ่งภาษา PHP จะรองรับแค่การสืบทอดครั้งเดียว ซึ่งจะมีแค่คลาสเดียวที่สามารถสืบทอดจากคลาสแม่หนึ่งตัว

เราจะเรียกความสัมพันธ์ของคลาสแม่-ลูกว่า Parent-Child Relationship

เราสามารถดูระดับการเข้าถึงของคลาสรองได้ดังตารางด้านล่าง

ระดับการเข้าถึง

การสืบทอดจาก คลาสหลัก ไปยัง คลาสรอง

public

✔️

protected

✔️

private

❌

constructor

❌

Constructor ใน Inheritance

ในการสร้าง Constructor เพื่อเก็บข้อมูลใน object ที่เราสร้างจากคลาสหลัก มีคีย์เวิร์ดสำคัญคือ "__construct()"

<?php
    class Parentclass{
        public function __construct(){
            echo "This is parent constructor\n";
        }
    }
    $obj = new Parentclass();
?>

public class Parentclass {
    public Parentclass() {
        System.out.println("This is parent constructor");
    }

    public static void main(String[] args) {
        Parentclass obj = new Parentclass();
    }
}

#include <stdio.h>

typedef struct {
} Parentclass;

void parentclass_constructor() {
    printf("This is parent constructor\n");
}

int main() {
    Parentclass obj;
    parentclass_constructor();
    return 0;
}

This is parent class constructor

การสร้างคลาสลูกที่สืบทอดคุณสมบัติจากคลาสแม่ สามารถใช้คีย์เวิร์ด "extends" ได้

คุณสมบัติที่อยู่ใน Constructor ของคลาสหลักนั้น จะไม่สามารถเรียกใช้ได้โดยตรงผ่านคลาสลูก จะต้องใช้คีย์เวิร์ดคือ "parent::__construct()" ใน Constructor ของคลาสลูก

<?php
    class parentclass{
        public function __construct(){
            echo "This is parent constructor\n";
        }
    }
    class childclass extends parentclass {
        public function __construct(){
            parent::__construct();
            echo " This is Child class destructor\n";
        }
    }
    $obj = new childclass();
?>

class parentclass {
    public parentclass() {
        System.out.println("This is parent constructor");
    }
}

class childclass extends parentclass {
    public childclass() {
        super();
        System.out.println("This is Child class destructor");
    }
}
public class Main{
    public static void main(String[] args) {
        childclass obj = new childclass();
    }
}

class parentclass:
    def __init__(self):
        print("This is parent constructor")

class childclass(parentclass):
    def __init__(self):
        super().__init__()
        print("This is Child class destructor")

obj = childclass()

#include <stdio.h>

typedef struct {
} parentclass;

void parentclass_constructor() {
    printf("This is parent constructor\n");
}

typedef struct {
    parentclass base;
} childclass;

void childclass_constructor() {
    parentclass_constructor();
    printf("This is Child class destructor\n");
}

int main() {
    childclass obj;
    childclass_constructor();
    return 0;
}

This is parent constructor
This is Child class destructor

จากตัวอย่างโค้ดด้านบน จะแสดงให้เห็นถึงการสืบทอด parentclass โดยคลาสลูกชื่อ childclass จะใช้คำสั่ง extends เพื่อสืบทอดคลาส parentclass

Output ที่ได้จะมีทั้งของคลาส parentclass และ childclass แต่หาก childclass ไม่ได้มีการเพิ่มคำสั่งอะไรไป จะแสดงคำสั่งของคลาสแม่ได้ตามปกติ

ต่อไปจะเป็นตัวอย่างการสืบทอด โดยมีคลาส Vehicle เก็บข้อมูลแบรนด์และราคาของยานพาหนะนั้นๆ

Inheritance และระดับการเข้าถึงแบบ Protected

คุณสมบัติแบบ protected จะสามารถเรียกใช้ภายในคลาสตัวมันเองและคลาสที่สืบทอดไป จะไม่สามารถถูกเรียกจากข้างนอกได้

ตัวอย่างการเรียกใช้ protected method จากภายนอกด้วย object ของคลาส Car

<?php
    class Vehicle{
        public $brand;
        public $price;
        public function __construct($brand, $price){
            $this->brand = $brand;
            $this->price = $price;
        }
        protected function print(){
             echo "Brand : {$this->brand}, Price : {$this->price}";
        }
    }
    class Car extends Vehicle {
        public function type(){
            echo " is a Car\n";
        }
    }
    $Car = new Car("Tesla",200);
    $Car->print();
    $Car->type(); #เกิด error ขึ้นเพราะ print() มีระดับการเข้าถึงแบบ protected
?>

public class Vehicle {
    public String brand;
    public int price;

    public Vehicle(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }
    protected void print() {
        System.out.print("Brand : " + this.brand + ", Price : " + this.price);
    }
}
public class Car extends Vehicle {
    public Car(String brand, int price) {
        super(brand, price);
    }
    public void type() {
        System.out.println(" is a Car");
    }
}
public class Main {
    public static void main(String[] args) {
        Car car = new Car("Tesla", 200);
        car.print();
        car.type();
    }
}

class Vehicle:
    def __init__(self, brand, price):
        self.brand = brand
        self.price = price

    def print(self):
        print(f"Brand : {self.brand}, Price : {self.price}", end='')

class Car(Vehicle):
    def __init__(self, brand, price):
        super().__init__(brand, price)

    def type(self):
        print(" is a Car")

car = Car("Tesla", 200)
car.print()
car.type()

#include <stdio.h>

typedef struct {
    char* brand;
    int price;
} Vehicle;

void print(Vehicle* vehicle) {
    printf("Brand : %s, Price : %d", vehicle->brand, vehicle->price);
}

typedef struct {
    Vehicle vehicle;
} Car;

void type(Car* car) {
    printf(" is a Car\n");
}

int main() {
    Car car;
    car.vehicle.brand = "Tesla";
    car.vehicle.price = 200;
    print(&car.vehicle);
    type(&car);
    return 0;
}

เกิด error ขึ้นเนื่องจากอ็อบเจค Car ไม่สามารถเข้าถึงเมธอด print() ซึ่งอยู่ภายในคลาส Vehicle ได้

จากตัวอย่างข้างต้นจะเห็นได้ว่า เราไม่สามารถเรียกใช้เมธอด print() ซึ่งถูกประกาศแบบ protected ภายในคลาส Vehicle ได้ ซึ่งเราสามารถเรียกใช้ protect method ได้โดยอีกวิธีนึงตามตัวอย่างถัดไปได้

<?php
    class Vehicle{
        public $brand;
        public $price;
        public function __construct($brand, $price){
            $this->brand = $brand;
            $this->price = $price;
        }
        protected function print(){
             echo "Brand : {$this->brand}, Price : {$this->price}";
        }
    }
    class Car extends Vehicle {
        public function type(){
            $this->print();
            echo " is a Car\n";
        }
    }
    $Car = new Car("Tesla",200);
    $Car->type();
?>

class Vehicle {
    public String brand;
    public int price;

    public Vehicle(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }
    protected void print() {
        System.out.print("Brand : " + this.brand + ", Price : " + this.price);
    }
}
class Car extends Vehicle {
    public Car(String brand, int price) {
        super(brand, price);
    }
    public void type() {
        print();
        System.out.println(" is a Car");
    }
}
public class Main {
    public static void main(String[] args) {
        Car car = new Car("Tesla", 200);
        car.type();
    }
}

class Vehicle:
    def __init__(self, brand, price):
        self.brand = brand
        self.price = price

    def print(self):
        print("Brand : {}, Price : {}".format(self.brand, self.price), end='')

class Car(Vehicle):
    def __init__(self, brand, price):
        super().__init__(brand, price)

    def type(self):
        self.print()
        print(" is a Car")

car = Car("Tesla", 200)
car.type()

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Vehicle {
    char* brand;
    int price;
    void (*print)(struct Vehicle*);
} Vehicle;

void vehicle_print(Vehicle* vehicle) {
    printf("Brand : %s, Price : %d", vehicle->brand, vehicle->price);
}

Vehicle* vehicle_new(char* brand, int price) {
    Vehicle* vehicle = malloc(sizeof(Vehicle));
    vehicle->brand = strdup(brand);
    vehicle->price = price;
    vehicle->print = vehicle_print;
    return vehicle;
}

typedef struct Car {
    Vehicle vehicle;
} Car;

void car_type(Car* car) {
    car->vehicle.print(&car->vehicle);
    printf(" is a Car\n");
}

Car* car_new(char* brand, int price) {
    Car* car = malloc(sizeof(Car));
    car->vehicle = *(vehicle_new(brand, price));
    return car;
}

int main() {
    Car* car = car_new("Tesla", 200);
    car_type(car);
    free(car->vehicle.brand);
    free(car);
    return 0;
}

Brand : Tesla, Price : 200 is a Car

โดยเราจะเรียกใช้เมธอด print() ภายในเมธอด type() ของคลาส Car ซึ่งสืบทอดมาจากคลาส Vehicle ด้วยวิธีนี้เราจะสามารถแสดงผลลัพธ์ที่เราต้องการได้อย่างถูกต้อง

จากโค้ดที่เปรียบเทียบ จะเห็นได้ชัดว่า ในภาษา C และ python จะไม่สามารถสร้างเมธอดหรือคลาสแบบมีระดับการเข้าถึงได้

การใช้งานเมธอด __toString()

โดยปกติแล้ว เมื่อมีการอ้างอิงถึงตัวแปร object โปรแกรมจะเรียกใช้เมธอดที่ชื่อ __toString() ซึ่งใช้สำหรับอธิบายเกี่ยวกับ object และส่งค่าเป็น String กลับมา ในภาษาอื่นๆเมธอดนี้จะถูกสร้างขึ้นโดยอัตโนมัติ แต่ในภาษา PHP เราจะต้องสร้างเมธอด __toString() ขึ้นมาเพื่อ Override และแสดงเกี่ยวกับ object นั้นๆ

<?php
    class Vehicle{
        public $brand;
        public $price;
        public function __construct($brand, $price){
            $this->brand = $brand;
            $this->price = $price;
        }
        public function __toString(){
             return "Brand : {$this->brand}, Price : {$this->price}";
        }
    }
    $Vehicle = new Vehicle("Tesla",200);
    echo $Vehicle;
?>

public class Vehicle {
    public String brand;
    public int price;

    public Vehicle(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Brand : " + this.brand + ", Price : " + this.price;
    }
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle("Tesla", 200);
        System.out.println(vehicle);
    }
}

class Vehicle:
    def __init__(self, brand, price):
        self.brand = brand
        self.price = price

    def __str__(self):
        return f"Brand: {self.brand}, Price: {self.price}"

vehicle = Vehicle("Tesla", 200)
print(vehicle)

#include <stdio.h>
#include <string.h>

typedef struct {
    char brand[20];
    int price;
} Vehicle;

void print_vehicle(Vehicle vehicle) {
    printf("Brand: %s, Price: %d\n", vehicle.brand, vehicle.price);
}

int main() {
    Vehicle vehicle;
    strcpy(vehicle.brand, "Tesla");
    vehicle.price = 200;
    print_vehicle(vehicle);
    return 0;
}

Brand : Tesla, Price : 200

จะเห็นได้ว่า เราสามารถแสดงข้อมูลของ object Vehicle ด้วยการพิมพ์คำสั่ง echo และตัวแปรออกมาได้เลย ผลลัพธ์ที่ได้จะตรงตามที่เรา Override ในเมธอด __toString()

การ Overriding เมธอด

เมธอดที่ถูกสืบทอดมาจากคลาสแม่สามารถถูกแทนด้วยเมธอดของคลาสลูกด้วยการสร้างเมธอดชื่อเดียวกัน

เราจะยกตัวอย่างการ Overriding ด้วยเมธอด print() ในคลาส Vehicle ที่จะแสดงข้อมูลแบรนด์และราคาของยานพาหนะที่เก็บไว้

<?php
    class Vehicle{
        public $brand;
        public $price;
        public function __construct($brand, $price){
            $this->brand = $brand;
            $this->price = $price;
        }
        public function print(){
             echo "Brand : {$this->brand}, Price : {$this->price}\n";
        }
    }
    class Car extends Vehicle {
        public function print(){
            echo "Brand : {$this->brand}, Price : {$this->price} is a Car\n";
        }
    }
    class Bike extends Vehicle {
        public function print(){
            echo "Brand : {$this->brand}, Price : {$this->price} is a Bike\n";
        }
    }
    class Truck extends Vehicle {
        public function print(){
            echo "Brand : {$this->brand}, Price : {$this->price} is a Truck\n";
        }
    }
    $Car = new Car("Tesla",200);
    $Car->print();
    $Bike = new Bike("Yamaha",50);
    $Bike->print();
    $Truck = new Truck("Ford",350);
    $Truck->print();
?>

class Vehicle{
    public String brand;
    public double price;
    public Vehicle(String brand,double price){
        this.brand=brand;
        this.price=price;
    }
    public void print(){
        System.out.println("Brand : "+this.brand+", Price : "+this.price);
    }
}
class Car extends Vehicle{
    public Car(String brand, double price) {
        super(brand, price);
    }
    public void print(){
        System.out.println("Brand : "+this.brand+", Price : "+this.price+" is a Car");
    }
}
class Bike extends Vehicle{
    public Bike(String brand, double price) {
        super(brand, price);
    }
    public void print(){
        System.out.println("Brand : "+this.brand+", Price : "+this.price+" is a Bike");
    }
}
class Truck extends Vehicle{
    public Truck(String brand, double price) {
        super(brand, price);
    }
    public void print(){
        System.out.println("Brand : "+this.brand+", Price : "+this.price+" is a Truck");
    }
}
public class Inheritance{
    public static void main(String[] args){
        Car car = new Car("Tesla",200);
        Bike bike = new Bike("Yamaha",50);
        Truck truck = new Truck("Ford",350);
        car.print();
        bike.print();
        truck.print();
    }
}

class Vehicle:
    def __init__(self,brand,price):
        self.brand = brand
        self.price = price
        
    def print(self):
        print("Brand : "+self.brand+", Price : "+self.price)

class Car(Vehicle):
    def __init__(self,brand,price):
        super().__init__(brand,price)
    
    def print(self):
        print("Brand : ",self.brand,", Price : ",self.price," is a Car")
        
class Bike(Vehicle):
    def __init__(self,brand,price):
        super().__init__(brand,price)
    
    def print(self):
        print("Brand : ",self.brand,", Price : ",self.price," is a Bike")

class Truck(Vehicle):
    def __init__(self,brand,price):
        super().__init__(brand,price)
    
    def print(self):
        print("Brand : ",self.brand,", Price : ",self.price," is a Truck")
        
car = Car("Tesla",100)
car.print()

bike = Bike("Yamaha",50)
bike.print()

truck = Truck("Ford",350)
truck.print()

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Vehicle {
    char* brand;
    double price;
    void (*print)(struct Vehicle*);
} Vehicle;

void vehicle_print(Vehicle* vehicle) {
    printf("Brand : %s, Price : %.2f\n", vehicle->brand, vehicle->price);
}

Vehicle* vehicle_new(char* brand, double price) {
    Vehicle* vehicle = malloc(sizeof(Vehicle));
    vehicle->brand = malloc(strlen(brand) + 1);
    strcpy(vehicle->brand, brand);
    vehicle->price = price;
    vehicle->print = vehicle_print;
    return vehicle;
}

typedef struct Car {
    Vehicle vehicle;
} Car;

void car_print(Vehicle* vehicle) {
    printf("Brand : %s, Price : %.2f is a Car\n", vehicle->brand, vehicle->price);
}

Car* car_new(char* brand, double price) {
    Car* car = malloc(sizeof(Car));
    car->vehicle = *(vehicle_new(brand, price));
    car->vehicle.print = car_print;
    return car;
}

typedef struct Bike {
    Vehicle vehicle;
} Bike;

void bike_print(Vehicle* vehicle) {
    printf("Brand : %s, Price : %.2f is a Bike\n", vehicle->brand, vehicle->price);
}

Bike* bike_new(char* brand, double price) {
    Bike* bike = malloc(sizeof(Bike));
    bike->vehicle = *(vehicle_new(brand, price));
    bike->vehicle.print = bike_print;
    return bike;
}

typedef struct Truck {
    Vehicle vehicle;
} Truck;

void truck_print(Vehicle* vehicle) {
    printf("Brand : %s, Price : %.2f is a Truck\n", vehicle->brand, vehicle->price);
}

Truck* truck_new(char* brand, double price) {
    Truck* truck = malloc(sizeof(Truck));
    truck->vehicle = *(vehicle_new(brand, price));
    truck->vehicle.print = truck_print;
    return truck;
}

int main() {
    Car* car = car_new("Tesla", 200.0);
    Bike* bike = bike_new("Yamaha", 50.0);
    Truck* truck = truck_new("Ford", 350.0);

    car->vehicle.print(&car->vehicle);
    bike->vehicle.print(&bike->vehicle);
    truck->vehicle.print(&truck->vehicle);

    free(car->vehicle.brand);
    free(car);
    free(bike->vehicle.brand);
    free(bike);
    free(truck->vehicle.brand);
    free(truck);

    return 0;
}

Brand : Tesla, Price : 200 is a Car
Brand : Yamaha, Price : 50 is a Bike
Brand : Ford, Price : 350 is a Truck

การใช้คีย์เวิร์ด final เพื่อป้องกันการสืบทอดคลาส

เมื่อมีการใช้คีย์เวิร์ด final หน้าการประกาศคลาส คลาสอื่นๆจะไม่สามารถประกาศตัวเองเพื่อสืบทอดคลาสหลักได้

<?php
  final class Vehicle{
        public function __construct(){
            echo " This is parent class constructor\n";
        }
    }
    class Car extends Vehicle {
        public function __construct(){
            parent::__construct();
            echo " This is Child class destructor\n";
        }
    }
?>

final class Vehicle {
    public Vehicle() {
        System.out.println("This is parent class constructor");
    }
}

class Car extends Vehicle {
    public Car() {
        super();
        System.out.println("This is Child class constructor");
    }
}
public class Main{
    public static void main(String[] args) {
        Car car = new Car();
    }
}

public class Vehicle {
    public Vehicle() {
        System.out.println("This is parent class constructor");
    }
}

public class Car extends Vehicle {
    public Car() {
        super();
        System.out.println("This is Child class constructor");
    }

    public static void main(String[] args) {
        Car car = new Car();
    }
}

#include <stdio.h>

typedef struct {
    void (*constructor)(struct Vehicle*);
} Vehicle;

void vehicle_constructor(Vehicle* self) {
    printf("This is parent class constructor\n");
}

typedef struct {
    Vehicle base;
} Car;

void car_constructor(Car* self) {
    vehicle_constructor(&self->base);
    printf("This is Child class constructor\n");
}

int main() {
    Car car;
    car_constructor(&car);
    return 0;
}

โค้ดดังกล่าวจะ error เนื่องจากมีข้อผิดพลาดตั้งแต่การสร้างคลาสลูก

เมื่อเทียบ PHP กับภาษา Java,Python และ C

Inheritance : PHP และ Java จะใช้คีย์เวิร์ด extends เหมือนกันเพื่อสืบทอดคลาสหลัก, Python จะใช้คีย์เวิร์ด class และคำสั่ง () เพื่อระบุคลาสที่จะสืบทอด ส่วนภาษา C จะไม่มีคำสั่งสำหรับสร้างคลาสในตัว จะต้องใช้ struct ซ้อนกันเพื่อสืบทอด
Constructor : PHP จะเรียกใช้ constructor ของคลาสหลักโดยอัตโนมัติหากคลาสลูกไม่มี ใน Java และ Python จะมีการใช้คำสั่ง super()
protect method : ในภาษา Python และ C จะไม่มีการกำหนดระดับการเข้าถึง ซึ่งต่างจาก PHP และ Java
toString function : PHP จะใช้ฟังก์ชั่น __toString(), ใน Java จะใช้ toString(), Python จะใช้ __str__(), ใน C จะไม่มีฟังก์ชั่นนี้ในตัวเพราะไม่ได้ออกแบบมาให้รองรับการเขียนโปรแกรมเชิงวัตถุ
Overriding method : ทุกภาษาจะสามารถทำการ override เมธอดได้เหมือนกันหมด แต่ใน Java จะต้องมีคำสั่ง @Override เพื่อบอกว่าเมธอดนี้เป็นการ override เมธอด
final keyword : PHP และ Java จะใช้คำว่า final เพื่อไม่ให้เมธอดหรือคลาสนั้นถูก override ได้

สรุปคือ ทั้งภาษา Php,Java,Python จะมีความแตกต่างกันในเรื่องของคีย์เวิร์ดในการใช้คำสั่ง แต่ C เป็นภาษาที่ไม่ได้ถูกออกแบบมาเพื่อการเขียนโปรแกรมเชิงวัตถุ ทำให้มีความซับซ้อนในการเขียนโปรแกรมมากขึ้นกว่าการเขียนในภาษาอื่นๆที่รองรับ

Presentation Slide

3MB

PHP Inheritance.pdf

PDF

Open

Presentation Video

https://youtu.be/UIfgkjgruew

References

What is Inheritance, Parent-Child Relationship, Constructor, __toString() function : MarcusCode. (2017, January 11). Inheritance in PHP. MarcusCode. https://marcuscode.com/lang/php/inheritance
Constructor, Inheritance, final keyword, Overriding inherited method, Inheritance and the Protected Access Modifier : W3Schools. (n.d.). PHP OOP Inheritance. W3Schools. https://www.w3schools.com/php/php_oop_inheritance.asp
__toString() function: GeeksforGeeks. (n.d.). PHP ReflectionParameter::__toString() function. GeeksforGeeks. https://www.geeksforgeeks.org/php-reflectionparameter-__tostring-function/
What is Inheritance : Javatpoint. (n.d.). PHP OOPs inheritance. Javatpoint. https://www.javatpoint.com/php-oops-inheritance
Vehicle class diagram, Constructor in Inheritance : Tutorialspoint. (n.d.). PHP - Inheritance. Tutorialspoint. https://www.tutorialspoint.com/php/php_inheritance.htm

PreviousPython NextConstants

Last updated 1 year ago

hashtagConstructor ใน Inheritance

hashtagInheritance และระดับการเข้าถึงแบบ Protected

hashtagการใช้งานเมธอด __toString()

hashtagการ Overriding เมธอด

hashtagการใช้คีย์เวิร์ด final เพื่อป้องกันการสืบทอดคลาส

hashtagเมื่อเทียบ PHP กับภาษา Java,Python และ C

hashtagPresentation Slide

hashtagPresentation Video

hashtagReferences