พื้นฐานPHP ตอนที่ 6 — PHP OOP

5 min readApr 22, 2017

PHP เขียนแบบ OOP (Object-Oriented Programming)

คือ การเขียนโปรแกรมในระบบเชิงวัตถุ และ แตกต่างจาก (Structure Programming) อยู่มาก

“Structure Programming = คือกลุ่มโครงสร้าง การทำงานแบบตามลำดับ(Sequence), การเลือกกระทำตามเงื่อนไข(Decision), การทำซ้ำ(Repeation or Loop)”

ออบเจ็กต์ (Objects)คืออะไร

ความหมายก็คือ วัตถุ สิ่งของที่มีข้อมูลรายละเอียด(object Properties)ที่เปลี่ยนแปลงแก้ไขได้และมีวิธีทางในการทำงานหรือเมธอด(method)ของตัวมันเอง

รถคันหนึ่งในโรงรถ คือ ออบเจ็คหนึ่งๆ ซึ่งมีข้อมูลเช่น ยี่ห้อ สีรถ รุ่นที่ ขนาดหรือนำหนัก เป็นต้น จากนั้น มีการเคลื่อนของรถ การเปิดประตู นั้นคือ เมธอด(method)

ออบเจ็คมีองค์ประกอบ 2 ตัว คือ ข้อมูลรายละเอียด(Object Properties) และเมธอด(Method)

สร้างออบเจ็กต์

ลำดับแรกเราต้องทำการออกแบบ Template หรือที่เรียกว่าคลาส(Class)ซึ่งภายในคลาสจะประกอบไปด้วย ฟังก์ชั่นย่อยๆ และรายละเอียดของออบเจ็กต์แต่ล่ะตัวที่สามารถกำหนดได้ตามเงื่อนไขของผู้สร้าง class

รูปแบบ

Class Name_Class
{
   //กำหนดชุดคำสั่งฟังก์ชั่น
}

ตัวอย่าง

<?php
class test //สร้างคลาสว่า test
{
}
$obj=new test();  // สร้างออบเจ็กต์ขึ้นมาใหม่เก็บไว้ในตัวแปร $obj
echo "\$obj is a ". gettype($obj)."<br>";//พิมพ์ว่าตัวแปร$obj เป็นข้อมูลชนิดใด
?>

รายละเอียด ของออบเจ็กต์ (Object Properties)

ออบเจ็ตแต่ล่ะตัวมีรายละเอียดของมันเอง เราสามารถประกาศตัวแปรเพื่อกำหนด Properties ไว้ในส่วนใดก็ได้

<?php
class test  //สร้างคลาสว่า test
{
    var $name ="Kitisak";//ประกาศตัวแปร $name ของคลาส ด้วยคำสั่ง var
}
$obj1 =new test();
$obj2 = new test();
$obj1->name="pangskon";// กำหนดรายละเอียด  ของ $obj1
$obj2->name="Suriyan";// กำหนดรายละเอียด  ของ $obj2
echo "$obj1->name";//แสดลผลรายละเอียด  ของ $obj1คือ pangskon
echo "$obj2->name";// แสดงรายละเอียด  ของ $obj2 คือ Suriyan
?>

เราจะเห็นได้ว่าเราสามารถสร้าง ออบเจ็คได้มากกว่า 1 ขึ้นไป ซึ่งแต่ละตัวจะมีอิสระต่อกันและกำหนดรายละเอียด ออบเจ็ค คือ $obj->name =“pangskan”;

ตัวดำเนินการ -> ใช้ในการอ้างอิงถึงตัวแปร หรือ ฟังชั่นภายในคลาสนั้นและตัวแปรที่อ้างอิงไม่จำเป็นต้องมี เครื่องหมาย $ ในรูปแบบ $obj->name ก็ได้

ออบเจ็คเมธอด (Object Method )

คือ ระเบียบการทำงานของออบเจ็คนั้นโดยเราต้องสร้างฟังชั่นขึ้นมาไว้ภายในclass นั้นเพื่อกำหนดตัวเมธอด ดังนั้นทุกๆออบเจ็คจำเป็นจะต้องมีเมธอดของตัวมันเอง

ตัวอย่าง สร้าออบเจ็คเมธอด

<?php
class  ObjMetch//สร้างคลาสว่า ObjMetch
{
    var $name ="Kitisak";//ประกาศตัวแปร $name ของคลาส ด้วยคำสั่ง var
     function Hello()// สร้าง เมธอด ชื่อว่า Hello()
         {
           echo "Hello";
         }}
$obj = new ObjMetch();
$obj-> Hello(); // พิมพ์ คำว่า Hello 
?>

จากการสร้าง ฟังชั่น Hello() ไว้ภายในชั่นคลาส ObjMetch เป็นออบเจ็คโดยเก็บไว้ที่ตัวแปร $obj แล้วทำการเรียกใช้เมธอดด้วยคำสั่ง $obj->Hello();

สรุปคือ เราจะเรียกใช้งานเมธอดได้เราต้องทำการสร้างออบเจ็คขึ้นมาก่อน

ตัวอย่าง การเข้าถึง Object Property ในเมธอด

<?php
class  ObjMetch//สร้างคลาสว่า ObjMetch
{
    var $name ="Kitisak";//ประกาศตัวแปร $name ของคลาส ด้วยคำสั่ง var
     function Hello()
         {
           echo "Hello$this->name<br>\n";
            // เราจะเรียกใช้งาน Object Property หรือ Object Method ที่อยู่ใน
                 คลาสเราจะใช้ตัวพิเศษ คือ $this ตามด้วย -> 
         }
         function setname($n)
          {
           $this->name=$n;
           // เราเปลี่ยนค่า Properties โดยใช้เมธอด 
           setname($n)เรียกใช้เมธอด setname เพื่อเปลี่ยนค่า Properties ก่อนจึง
           เรียกใช้ เมธอด Hello()
        }}
$obj = new ObjMetch();
$obj-> Hello(); // พิมพ์ คำว่า Hello Kitisak$obj = new ObjMetch();
$obj->setname("Rechar");
$obj->hello();// พิมพ์ Hello Rechar  อ้างอิงโดย Method
$obj->name;// อ้างอิงถึง Properties
?>

สถานะของเมธอด และออบเจ็ค (visibility)

โดยเราสามารถกำหนดได้อยู่ 3 แบบคือ

public คือ สามารถเรียกได้ทุกที่ ทั้งภายในและภายนอกคลาส
private คือ สามารถเรียกได้เฉพาะในคลาส
protected คือ สามารถเรียกได้เฉพาะในคลาส และคลาสที่ขยายคลาสนี้

ตัวอย่าง

<?php
/**
 * test visibity public private protected
 */
class human
{public function say()
  {
  return "SAY : Hello I am human";
  }
  private function body()
  {
   return " My body : my nude ,arm , head, figer";
  }
  protected  function walk()
  {
    return "Walk : walk on the road";
  }
  public function Output()
  {
    echo "Public function : ". $this->say()."<br>";
    echo "Private function : ". $this->body()."<br>";
    echo "Protected function : ". $this->walk()."<br>";
  }
}
$obj = new  human;
$obj->Output();
 ?>

method แบบรับค่า Parameter

<?php
/**
 * เขียน method รับค่า parameter
 */
class MYClass {
  private $name;//กำหนด popertirce ของ class  ไม่ให้ เข้าถึงจากภายนอก
  private $Nickname;  public function SetValus($name="",$Nickname="")//สร้าง เมธอด มีการกำหนดตัวรับค่า parameter คือ $name $Nickname
  {
    echo $name." ".$Nickname;// ให้แสดงผล ค่่า ใน เมธอด// ส่วน ของ GetValus
    $this->name=$name ;
    $this->Nickname=$Nickname;
  }
  public function GetValus()// รับค่า $name , $Nickname มาเพื่อ ส่งค่าออกมา
  {
    return  $this->name." ".$this->Nickname;
  }
}
  $obj = new MYClass;
  echo $obj ->SetValus("Deluky","Unoin");//คือ กำหนดค่า parameter
  echo $obj->GetValus();//// ส่วน ของ GetValus
 ?>

คอนสตักเตอร์ (Constructor)

คอนสตักเตอร์ คือ สิ่งที่มีไว้สำหรับกำหนดค่าเริ่มต้นให้กับตัวแปรคลาสของอ็อปเจ็ค คอนสตรัคเตอร์จะทำงานอัตโนมัติเมื่อมีการ new อ็อปเจ็คขึ้น เช่นการติดต่อฐานข้อมูล (เขียนให้เหมือน class ของมัน)

<?php
class  myClass{   //แบบที่ 1
   public function myClass(){    }   // แบบที่ 2 
  public function __construct(){
    }}

ตัวอย่าง constructor

<?php
class  myClass{
       private $name="sak";
       private $surname ="fangky";
   public function __construct($name,$surname){ //สร้าง contructor บรรทัดนี้ จะ ค่าเริ่มต้น ของ $name และ $surname
      $this->name=$name;
      $this->surname=$surname;
    }
    public function getValus(){// รับค่า มาเพื่อ ส่งค่าออกมา
         return $this->name." ".$this->surname;
       }
}
$obj= new myClass("dakon");// ใส่ ค่า contructor คือ dakon
echo $obj->getValus();
?>

deconstruct

คือ จะใช้ในกรณีที่ คลาสใช้งานเสร็จสิ้น เรียบร้อย (ปิดท้าย class )ส่วน construct จะเริ่มเมื่อclass เริ่มทำงาน

ข้อดี : จะปิด ทำงาน class ให้ทุกครั้ง

ข้อเสีย : จะต้องมาประกาศ new class ทุกครั้งเมื่อเรียกใช้งาน

ตัวอย่าง deconstruct

<?php
class  myClass{
       private $name="sak";
       private $surname ="fangky";
   public function __construct($name,$surname){ //สร้าง contructor บรรทัดนี้ จะ ค่าเริ่มต้น ของ $name และ $surname
      $this->name=$name;
      $this->surname=$surname;
    }
    public function getValus(){// รับค่า มาเพื่อ ส่งค่าออกมา
         return $this->name." ".$this->surname;
       }
  public function __destruct(){// ส่วนปิดท้าย class 
    echo "END<br>";
  }
} 
$obj= new myClass("dakon");// ใส่ ค่า contructor คือ dakon
echo $obj->getValus();
?>

การสืบทอด (inheritance)

inheritance คือ การสืบทอด class โดยใช้ คำสั่ง extend ในการสืบทอด เช่น class A และ class b

> class b ต้องการใช้ Property และ method ใน class Aที่มีอยู่แล้ว
> class b จึงได้ทำการ อ้างอิงแม่แบบ จาก class A

ตัวอย่าง การสืบทอด

// ไฟล์ Class_A.php 
<?php
/**
 * class แม่แบบ 
 */
  class family{
    public $name;public function MyMon()
    {
      return $this->name="Fafa";
    }
    public function Myfather()
    {
      return  $this->name="deky";
    }
  }?>//ไฟล์ Class_B.php
<?php
require_once "Class_A.php";//เรียกใช้งาน ไฟล์ class family อยู่
/**
 * การสืบทอด คุณสมบัติ คลาส ลูก 
 */
class male extends family
{
  public function showtext()
  {
    echo"Father Name : ". $this->Myfather()."<br>";
    echo"Monther Name : ". $this->MyMon()."<br>";
  }
}
$obj=new male;
$obj->showtext();
 ?>

ความแตกต่าง constructor กับ inheritance

constructor คือ จะ กำหนดให้กับตัวแปร หรือ property ภายในคลาส เปลี่ยรค่าเริ่มต้นของคลาสด้วย

inheritance คือ การคัดลอกมา ทั้ง คลาส มาเป็นของคลาสตัวเองใหม่

Static Method and non Static

function statics คือ เรียกใช้ class Method ได้เลย โดย

static method
- เพราะว่า สามารถเรียกใช้งานได้โดยไม่ต้องประกาศ object ก่อน
- static method สามารถทำงานได้เร็วกว่า
- ไม่มีผลกระทบกับ ตัวแปรอื่นๆ ทำให้ debug ได้ง่ายและมั่นใจในความถูกต้องได้ง่ายกว่า

จึงทำให้ static method ดีกว่า object Method แต่ ก็มีข้อเสียอยู่ คือ

static function ไม่สามารถทำได้ ได้แก่
- จำเป็นต้องใช้ตัวแปรของ object เพื่อเก็บสถานะของการเรียกคำสั่ง
- จำเป็นต้องเรียกใช้ method ของ object เพื่อให้การทำงานเสร็จสมบูรณ์

ตัวอย่าง รูปแบบ การใช้งาน static

<?php
  /**
   * Static function
   */
  class staClass {
    //ส่วน properties
    public static $age="13";
    public static $name="titty";// method
    public function boy($name)
    {
      echo $name;// แสดงผล parameter// หากเรียกในคลาส
      echo StaClass::$age;// แสดง ผลออก 13
    }}
  //ตัวเดิม ต้องสร้าง ออบเจ็คขึ้นมา
# $obj= new staClass();// แบบ static ไม่ต้องสร้าง ออเจ็ค ขึ้นมา
# echo staClass::$age;// แสดงผล 13 echo staClass::boy("Hi Boy");// ค่า parameter คือ Hi Boy  ?>

อ้างอิง method ,constructor , properties ของคลาส แบบ statics โดยใช้ self

<?php
  /**
   * Static function
   */
  class staClass {
    //ส่วน properties
    public static $age="13";
    public static $name="titty";
// method
    public function boy($name)
    {
      echo $name;// แสดงผล parameter// หากเรียกในคลาส
      echo self::$age;// แสดง ผลออก 13
    }}
  //ตัวเดิม ต้องสร้าง ออบเจ็คขึ้นมา
# $obj= new staClass();// แบบ static โดยใช้ self ไม่ต้องสร้าง ออเจ็ค ขึ้นมา
# echo staClass::$age;// แสดงผล 13echo staClass::boy("Hi Boy");// ค่า parameter คือ Hi Boy?>

การอ้างอิง method ,constructor , properties แบบ statics โดยมีการสืบทอด มา ให้ใช้ parent

<?php
  /**
   * Static function
   */
  class mon{
   protected static $name ="";
   protected static $age ="";   public function __construct(){

   echo "Class MON ";
   }
 class Child extends mon {
    public function __construct(){
      parent__construct();
   }
}
$obj = new Child();
?>

Abstract Class

คลาสในรูปแบบหนึ่ง ที่ เมื่อไรที่สร้างคลาส abstract class ขึ้นมาแต่ไม่มีส่วนหน้าที่การทำงาน แล้ว ทำการสืบทอดคุณสมบัติ เมธอด ที่เหมือน คลาสที่สืบทอดมา เหมือนทุกอย่างเลย แล้ว มีหน้าที่การทำงานภายใน และ Abstract Class ใช้คำสั่ง extends ในการเรียกใช้งานเท่านั้น

ตัวอย่าง Abstract class

<?php
//สร้างคลาส Abstract  class ชื่อ A
 abstract class A{
//สร้างส่วน method ชื่อว่า SayHi
    abstract function sayHi();
}//สร้างคลาส ที่ สืบทอด Abstract class A ชื่อ Class C
 class C extends A {
  //  ทำการสร้าง method เหมือน class A
     public function sayHi(){//  ส่วนการทำงาน
      echo "sayhi"; //ที่แสดงผลว่า sayhi
    }
 }
$obj= new C();// สร้าง ออบเจ็คเพื่อเรียกใช้งาน คลาส C
$obj->sayHi(); // เรียกใช้งาน method ในคลาส C?>

interface Class

คือ ก็จะคล้าย กับ Abstract Class แต่มีข้อแต่ต่าง คือ

1 interface ไม่จำเป็น ต้องเขียน class นำหน้า

2 interface ประกาศเมธอดคือ public function

3 Interface Class ใช้คำสั่ง implements ในการเรียกใช้งาน

4 Class ลูก สามารถ implements Interface Class ได้มากกว่า 1 Class

ตัวอย่าง interface class

<?php
  interface A {
    public function sayhi();//สร้าง public function
    public function head();
    public function look();
  }
  interface B {
    public function name();
    public function walk();
  }
   class D{ // สร้างคลาสธรรมดา
    public function G(){
      return "function G";
    }
}//impaments เพื่อเรียกใช้งาน และ และเรียกคลาส ธรรมดามาโดย extends ก็ได้
  class C extends D implements A,B {// สามารถ implements Interface Class ได้มากกว่า 1 Class
    public function sayhi(){
}
    public function head(){
}
    public function look(){
      echo "function look<br>";
}
// method function class B
    public function name(){
}
    public function walk(){
}
   public function see(){ //extends คลาส ธรรมดา 
     return $this->G();
}
  }
  $obj=new C();
  $obj->look();//แสดง impaments look() class C
echo $obj->see();// แสดง function see() ธรรมดา
?>

พื้นฐานPHP ตอนที่ 6 — PHP OOP

Written by Maji Pornmasa Namtirach