ต่อไป »

[workshop]

พอดีผมไปเจอคำถามน่าสนใจมาคำถามหนึ่ง
ผมอก็อยากรู้ด้วย
ท่านใดตอบ +thanks ครับ

ผมขอพ่วงอีกคำถามหนึ่ง :: กับ -> ต่างกันอย่างไรครับ
ปกติผมใช้แต่ -> ไม่เคยใช้ :: เลย
ขอบคุณทุกความคิดเห็นครับ

โค๊ด:

http://www.pantip.com/tech/developer/topic/DW3068294/DW3068294.html

เพิ่งหัดใช้ PHP มีพื้นฐาน concept ของ OOP แต่ไม่เคย design ระบบแบบ OOP เลยมองไม่ออกจิงๆ ว่า ถ้าจะทำระบบแบบ OOP จาออกแบบยังไงคับ

ยกตัวอย่างเช่น เขียนระบบ shopping cart ขอแบ่งเป็น 2 ภาคแบบคร่าวๆ นะคับ 1.การแสดงสินค้า 2.การจัดการตัวรถเข็น

1. การแสดงสินค้า ถ้าเราออกแบบระบบแบบ OOP เราควรจะมี class อย่างไรบ้าง ขอตัวอย่างซักนิดได้ไม๊

class product {
function listProduct {
}

function searchProduct {
}
...
}

เช่น function listProduct() ซึ่งไป select จากฐานข้อมูล แล้วได้ สินค้าหลายรายการ function นี้ควรจะทำหน้าที่ echo ข้อมูลเลยหรือว่า return array ของสินค้ากลับไปเพื่อแสดงใน main คับ
2. การจัดการตัวรถเข็น มีหน้าตาของ class ประมาณไหนคับ

class shoppingCart {
function addToCart {
}

function deleteFromCart {
}

function calculateCart {
}
}

function อย่าง addToCart() เราควรมี parameter เป็น object product หรือ เป็น string ID ของ product

ช่วยให้แนวคิดคร่าวๆ นะคับ

ขอบคุณคับ

** แ้ก้ไข ขอลบ tag Code ออกนะครับ จะได้ตัวใหญ่ และใส่สีได้ด้วย

[Queue]

ผมเข้าใจว่า

-> เรียกภายใน Class ของตัวเอง

:: เรียกข้าม Class

[workshop]

ผมเข้าใจว่า

-> เรียกภายใน Class ของตัวเอง

:: เรียกข้าม Class

+thanks ครับ

[Twenty-One]

ไปเจอ video มาครับ น่าจะเป็นประโยชน์

http://www.thaicreate.com/comm...p-oop-tutorial-vdo-online.html

[Positron]

ผมเข้าใจว่า

-> เรียกภายใน Class ของตัวเอง

:: เรียกข้าม Class

+thanks ครับ

ไม่ใช่นะครับ

-> ใช้เรียกฟังก์ชั้นภายในคลาส แบบทั่วๆไป โดยอ้างอิงตาม object ที่ถูกสร้างมา
 - ภายนอกก็อยู่ในรูปแบบ {$ชื่อตัวแปร}->{ฟังก์ชั่น()/$ตัวแปร}
 - ภายในก็อยู่ในรูปแบบ $this->{ฟังก์ชั่น()/$ตัวแปร}

แต่

:: ใช้สำหรับ static ฟังก์ชั่นหรือตะวแปร ก็คือ ฟังก์ชั่นหรือตัวแปรที่ใช้งานซ้ำกันในตัวเดียว ถึงแม้ object จะคนละตัวกันก็ตาม
- ภายนอก {ชื่อคลาส}::{ฟังก์ชั่น()/$ตัวแปร}
- ภายใน {self}::{ฟังก์ชั้น()/$ตัวแปร}

เช่น
class a
{
 public static b()
 {

 }
}
เราสามารถเรียกฟงก์ชั่น b() ได้เลยโดยไม่ต้องสร้าง object จากคลาส a โดยเรียกตรงๆว่า a::b()

[sabyo]

ขอตอบตามการออกแบบระบบแบบคร่าวๆแล้วกันครับ

ปกติถ้าจะออกแบบเป็น OOP จะต้องมองแยกออกเป็นส่วนประกอบของระบบก่อน ค่อยมาคิดถึงการทำงาน

อย่างตัวอย่างที่ยกมา ระบบ Shopping Cart เราก็มานั่งคิดก่อนเลยว่าระบบ Shopping Cart มันน่าจะประกอบไปด้วยอะไรบ้าง (Class) มีคุณลักษณะอะไรบ้าง (Attribute) และมันสามารถทำอะไรได้มั่ง (Method)

สมมุติได้ Class ออกมาดัีงนี้

Class  Product{
name
price

   Method addProduct (){
     โค้ดการเพิ่มสินค้า
   }

   Method listProduct(){
     โค้ดการแสดงรายชื่อสินค้า
   }

   Method searchProduct(){
     โค้ดการค้นหาสินค้า
   }

}

Class  Cart{
cartID
pricesum

   Method addToCart (){
     โค้ดการเพิ่มสินค้าที่จะซื้อ
   }

   Method deleteFromCart(){
     โค้ดการลบสินค้าที่จะซื้อ
   }

   Method calculateCart(){
     โค้ดการคิดเงิน
   }
}

คือให้เราเขียนส่วนประกอบของระบบขึ้นมาก่อนนะครับ ซึุ่งมันจะยากตรงนี้แหละคือแต่ละคนก็มีมุมมองไม่เหมือนกัน ซึ่งก็ไม่ผิดอยู่ที่ใครจะมองระบบแบบไหน
ซึ่งก็จะมีรูปแบบที่มักจะเจอกันบ่อยๆ ก็เลยมีการรวบรวมไว้เป็น Design Pattern หรือถ้าจะมองระบบแยกส่วนกันแบบ MVC ก็ได้
(ในตัวอย่างอาจจะงงๆหน่อยนะครับ เพราะผมก็ยกเอาตัวอย่างมาวางให้ดูว่าอันไหนเป็นอะไรเฉยๆ ไม่ได้มานั่งคิดแบบละเอียด)

หลังจากที่เราเขียนส่วนประกอบเสร็จที่นี้เราก็มาเขียนส่วนผูกการทำงานของโปรแกรม ซึ่งก็คืิอ Main Class นั่นเอง (การเขียนโปรแกรมตรงนี้จะคล้ายๆกับการเขียนแบบ procedure)
Main Classจะไม่มีการเขียนกระบวนการทำงาน จะมีแต่การเรียกใช้อย่างเดียว โดยมีการสร้าง Object ขึ้นมาจาก Class ที่เขียนไว้นั่นเอง

Main Class {
 A1 = new Product;   (ให้ A1 เป็นสินค้า)
A2 = new Product;   (ให้ A2 เป็นสินค้า)
 A1.Addproduct();     (เพิ่มสินค้า A1)
 A2.Addproduct();     (เพิ่มสินค้า A2)
 ...
  จะให้โปรแกรมทำอะไรก็ทำไป
}

อย่างตัวอย่างข้างบนผมยกตัวอย่างให้ A1,A2 เป็น Object จาก Class Product ซึ่งก็คือสินค้า 2 ชิ้นขึ้นมานั่นเอง
A1,A2 สามารถกระทำได้อย่างอิสระโดยไม่กระทบต่อกัน

ซึ่งจะเห็นว่าการเขียนโปรแกรมแบบ OOP จะลดความซ้ำซ้อนของการเขียนโปรแกรมลง การกระทำใดที่เหมือนกันก็จะมีการเขียนโค้ดแค่ครั้งเดียว
ถ้าจะมีการแก้ไข ก็แก้ไขแค่ที่เดียว อย่างจากตัวอย่าง ถ้าเราจะมีการแก้ไขกระบวนการเพิ่มสินค้า เราก็ไปแก้ไขที่ตรง Class Product Method addProduct() แค่ที่เดียว
กระบวนการเพิ่มสินค้าทั้งหมดในโปรแกรมก็จะเปลี่ยนตามไปด้วย ซึ่งจะแตกต่างจากการเขียนโปรแกรมแบบ procedure ที่เราต้องก้อปปี้ฟังชั่นการทำงานมาใช้
ถ้าจะทำการแก้ไขโปรแกรม ก็จะต้องไปไล่ดูว่าตรงไหนที่ใช้โค้ดส่วนนี้บ้าง มีผลกระทบอะไรยังไง การเขียนโปรแกรมแบบ OOP มีจุดเด่นตรงที่การบำรุงรักษา
การแก้ไขโปรแกรม สามารถทำได้ง่ายครับ

[workshop]

+ Thanks
ท่าน Positron
และท่าน sabyo
นะครับ ใครมีอะไรเสริม เสริมเข้ามาได้เลยนะครับ
ถือว่าแลกเปลี่ยนความรู้กัน

[gilbert]

ลองลำดับ Sequence การทำงานดูคับ แล้วค่อยเอามาเขียน class

เช่น

หน้าจอค้นหาสินค้า

1. ผู้ใช้งานกดปุ่มค้นหา     
2  เพิ่มสินค้าลงในตะกร้าสินค้า


ก็จะได้ class สินค้า กับ class ตะกร้าสินค้า
โดยมี method ใน class สินค้าคือ ค้นหา
และมี method ใน class ตะกล้าสินค้าคือ เพิ่มสิ้นค้า  (อาจจะรับ parameter เป็น product id)
เขียนเป็น class ได้ดังนี้

class product {
     function search() {...}
}

class cart {
     function add($product_id) {...}
}

[workshop]

ลองลำดับ Sequence การทำงานดูคับ แล้วค่อยเอามาเขียน class

เช่น

หน้าจอค้นหาสินค้า

1. ผู้ใช้งานกดปุ่มค้นหา     
2  เพิ่มสินค้าลงในตะกร้าสินค้า


ก็จะได้ class สินค้า กับ class ตะกร้าสินค้า
โดยมี method ใน class สินค้าคือ ค้นหา
และมี method ใน class ตะกล้าสินค้าคือ เพิ่มสิ้นค้า  (อาจจะรับ parameter เป็น product id)
เขียนเป็น class ได้ดังนี้

class product {
     function search() {...}
}

class cart {
     function add($product_id) {...}
}

+1 ครับท่าน gibert