เชิงวัตถุ Perl

มีการใช้งานที่แตกต่างกันสองประการของการเขียนโปรแกรมเชิงวัตถุใน Perl:

วิธีหนึ่งจะขึ้นอยู่กับวิธีตารางแฮชที่ไม่ระบุตัวตน สาระสำคัญของแต่ละอินสแตนซ์ของวัตถุคือการอ้างอิงที่ชี้ไปยังตารางแฮชที่ไม่ระบุชื่อ ในตารางแฮชที่ไม่ระบุชื่อนี้ คุณลักษณะของอินสแตนซ์ทั้งหมดจะถูกจัดเก็บไว้

วิธีที่สองคือวิธีการแบบอาร์เรย์ เมื่อกำหนดคลาส เราจะสร้างอาร์เรย์สำหรับแต่ละแอตทริบิวต์อินสแตนซ์ และสาระสำคัญของแต่ละอินสแตนซ์ของวัตถุคือการอ้างอิงที่ชี้ไปยังดัชนีแถวในอาร์เรย์เหล่านี้ ในอาร์เรย์เหล่านี้ คุณสมบัติอินสแตนซ์ทั้งหมดจะถูกจัดเก็บไว้

แนวคิดพื้นฐานเชิงวัตถุ

มีแนวคิดพื้นฐานมากมายในเชิงวัตถุ ที่นี่เรายอมรับสามแนวคิด: อ็อบเจ็กต์ คลาส และเมธอด

Object : อ็อบเจ็กต์คือการอ้างอิงถึงรายการข้อมูลในคลาส -

คลาส : คลาสคือแพ็คเกจ Perl ที่มีคลาสที่ให้วิธีการของวัตถุ

วิธีการ : วิธีการคือรูทีนย่อย Perl และชื่อคลาสเป็นพารามิเตอร์แรก

Perl จัดเตรียมฟังก์ชัน bless() Bless ใช้เพื่อสร้างวัตถุที่เชื่อมโยงการอ้างอิงกับชื่อคลาสและสร้างวัตถุโดยการส่งคืนการอ้างอิง

คำจำกัดความของชั้นเรียน

คลาสเป็นเพียงแพ็คเกจง่ายๆ

คุณสามารถใช้แพ็คเกจเป็นคลาส และใช้ฟังก์ชันในแพ็คเกจเป็นวิธีการของคลาสได้

แพ็คเกจของ Perl มีเนมสเปซแยกกัน ดังนั้นชื่อเมธอดและตัวแปรในแพ็คเกจที่แตกต่างกันจะไม่ขัดแย้งกัน

นามสกุลไฟล์สำหรับคลาส Perl คือ .pm

ต่อไปเราจะสร้างคลาส Person:

 แพ็คเกจบุคคล;

ช่วงโค้ดของคลาสไปถึงบรรทัดสุดท้ายของไฟล์สคริปต์ หรือก่อนคีย์เวิร์ดของแพ็คเกจถัดไป

สร้างและใช้วัตถุ

ในการสร้างอินสแตนซ์ (อ็อบเจ็กต์) ของคลาส เราจำเป็นต้องกำหนดคอนสตรัคเตอร์ โปรแกรมส่วนใหญ่ใช้ชื่อคลาสเป็นตัวสร้าง แต่ในภาษา Perl คุณสามารถใช้ชื่อใดก็ได้

คุณสามารถใช้ตัวแปร Perl ต่างๆ เป็นวัตถุ Perl ได้ โดยส่วนใหญ่เราจะใช้อาร์เรย์อ้างอิงหรือแฮช

ต่อไปเราจะสร้าง Constructor สำหรับคลาส Person โดยใช้การอ้างอิงแฮชของ Perl

เมื่อสร้างวัตถุ คุณต้องจัดเตรียม Constructor ซึ่งเป็นรูทีนย่อยที่ส่งคืนการอ้างอิงไปยังวัตถุ

ตัวอย่างมีดังนี้:

ตัวอย่าง

บรรจุุภัณฑ์ บุคคล ;​ ใหม่ - ของฉัน $ class = กะ ; $ตนเอง = { _firstName => shift , _lastName => shift , _ssn => shift , } ; # ส่งออกข้อมูลผู้ใช้ พิมพ์ " ชื่อ: $self ->{_firstName} n " ; " นามสกุล: $self ->{_lastName} n " ; " หมายเลข: $self ->{_ssn} n " ; $ตนเอง $ คลาส ; กลับ $ตัว เอง ;

ต่อไปเราจะสร้างวัตถุ:

 $object = บุคคลใหม่( "Xiao Ming", "王", 23234345);

กำหนดวิธีการ

วิธีการของคลาส Perl เป็นเพียงรูทีนย่อย Perl ซึ่งรู้จักกันทั่วไปว่าเป็นฟังก์ชันสมาชิก

คำจำกัดความวิธีการของ Perl ใน Perl เชิงวัตถุไม่ได้จัดเตรียมไวยากรณ์พิเศษใดๆ แต่กำหนดว่าพารามิเตอร์แรกของวิธีการนั้นเป็นวัตถุหรือแพ็คเกจที่อ้างอิงถึง

Perl ไม่ได้จัดเตรียมตัวแปรส่วนตัวไว้ แต่เราสามารถจัดการข้อมูลอ็อบเจ็กต์ผ่านวิธีการเสริมได้

ต่อไปเราจะกำหนดวิธีการรับชื่อ:

 ย่อย getFirstName { กลับ $self->{_firstName};}

คุณยังสามารถเขียนดังนี้:

 setFirstName ย่อย { my ( $self, $firstName ) = @_; $self->{_firstName} = $firstName ถ้ากำหนดไว้($firstName); return $self->{_firstName};}

ต่อไปเราจะแก้ไขโค้ดของไฟล์ Person.pm ดังนี้:

ตัวอย่าง

#!/usr/bin/perl บรรจุุภัณฑ์ บุคคล ;​ ใหม่ - ของฉัน $ class = กะ ; $ตนเอง = { _firstName => shift , _lastName => shift , _ssn => shift , } ; # ส่งออกข้อมูลผู้ใช้ พิมพ์ " ชื่อ: $self ->{_firstName} n " ; " นามสกุล: $self ->{_lastName} n " ; " หมายเลข: $self ->{_ssn} n " ; $ตนเอง $ คลาส ; กลับ $ตัว เอง ; ย่อย setFirstName - ของฉัน - $ตนเอง , $firstName ) = @_ ; $self -> { _firstName } = $firstName ถ้า กำหนดไว้ ( $ firstName ) ; $ ตนเอง -> { _firstName } ; ย่อย getFirstName - ของฉัน ( $ตนเอง ) = @_ ; กลับ $ ตนเอง -> { _firstName } ; 1 ;

รหัสสคริปต์ Employee.pl เป็นดังนี้:

ตัวอย่าง

#!/usr/bin/perl ใช้บุคคล ; $object = ใหม่ บุคคล ( " เสี่ยวหมิง " , "王" , 23234345 ) ; # รับชื่อ $firstName = $object -> getFirstName ( ) ; พิมพ์ " ตั้งชื่อก่อนหน้าเป็น: $firstName n " ; # ใช้ฟังก์ชันเสริมในการตั้งชื่อ $ object -> setFirstName ( “ เสี่ยวเฉิง ” ) ; # รับชื่อผ่านฟังก์ชันตัวช่วย $firstName = $object - > getFirstName ( ) ; " ชื่อหลังจากการตั้งค่าคือ: $firstName n " ;

หลังจากรันโปรแกรมข้างต้นแล้ว ผลลัพธ์ที่ได้คือ:

 $ perl Employee.pl ชื่อ: เซียวหมิง นามสกุล: วัง หมายเลข: 23234345 ชื่อก่อนการตั้งค่าคือ: เซียวหมิง ชื่อหลังการตั้งค่า: เซียวเฉียง

สืบทอด

วิธีการเรียนใน Perl ได้รับการสืบทอดผ่านอาร์เรย์ @ISA อาร์เรย์นี้ประกอบด้วยชื่อของแพ็คเกจอื่น ๆ (คลาส) จะต้องตั้งค่าการสืบทอดอย่างชัดเจน

การสืบทอดหลายรายการหมายความว่าอาร์เรย์ @ISA มีชื่อคลาส (แพ็คเกจ) หลายชื่อ

เฉพาะวิธีการเท่านั้นที่สามารถสืบทอดผ่าน @ISA ไม่ใช่ข้อมูล

ต่อไปเราจะสร้างคลาส Employee ที่สืบทอดคลาส Person

รหัสไฟล์ Employee.pm มีลักษณะดังนี้:

ตัวอย่าง

#!/usr/bin/perl บรรจุุภัณฑ์ พนักงาน ; ใช้บุคคล ; ใช้ ของเรา อย่างเข้มงวด ; @ISA = qw( Person ) ; #สืบทอดมาจาก Person

ตอนนี้คลาส Employee มีวิธีการและคุณสมบัติทั้งหมดของคลาส Person เราป้อนโค้ดต่อไปนี้ในไฟล์ main.pl และดำเนินการ:

ตัวอย่าง

#!/usr/bin/perl ใช้พนักงาน ; $object = ใหม่ พนักงาน ( " เสี่ยวหมิง " , "王" , 23234345 ) ; # รับชื่อ $firstName = $object -> getFirstName ( ) ; พิมพ์ " ตั้งชื่อก่อนหน้าเป็น: $firstName n " ; # ใช้ฟังก์ชันเสริมในการตั้งชื่อ $ object -> setFirstName ( “ เสี่ยวเฉิง ” ) ; # รับชื่อผ่านฟังก์ชันตัวช่วย $firstName = $object - > getFirstName ( ) ; " ชื่อหลังจากการตั้งค่าคือ: $firstName n " ;

หลังจากรันโปรแกรมข้างต้นแล้ว ผลลัพธ์ที่ได้คือ:

 $ perl main.pl ชื่อ: เซียวหมิง นามสกุล: วัง หมายเลข: 23234345 ชื่อก่อนการตั้งค่าคือ: เซียวหมิง ชื่อหลังการตั้งค่า: เซียวเฉียง

วิธีการเอาชนะ

ในตัวอย่างข้างต้น คลาส Employee จะสืบทอดคลาส Person แต่หากเมธอดของคลาส Person ไม่สามารถตอบสนองความต้องการได้ ก็จำเป็นต้องเขียนเมธอดใหม่

ต่อไปเราจะเพิ่มวิธีการใหม่ให้กับคลาส Employee และแทนที่วิธีการของคลาส Person:

ตัวอย่าง

#!/usr/bin/perl บรรจุุภัณฑ์ พนักงาน ; ใช้บุคคล ; ใช้ ของเรา อย่างเข้มงวด ; @ISA = qw( Person ) ; #สืบทอดมาจาก Person # แทนที่ตัวสร้าง ย่อย ใหม่ - ของฉัน ( $class ) = @_ ; # เรียกตัวสร้างของคลาสหลัก ของฉัน $self = $class -> SUPER :: ใหม่ ( $_ [ 1 ] , $_ [ 2 ] , $_ [ 3 ] ) ; # เพิ่มคุณสมบัติเพิ่มเติม $self -> { _id } = undef ; $ self -> { _title } = undef ; $ตนเอง $ คลาส ; กลับ $ตัว เอง ; #วิธีการแทนที่ ย่อย getFirstName - ของฉัน ( $ตนเอง ) = @_ ; # นี่คือฟังก์ชันคลาสย่อย พิมพ์ " นี่คือฟังก์ชันคลาสย่อย n " ; $ ตนเอง -> { _firstName } ; #เพิ่มวิธีการ ย่อย นามสกุล { ของฉัน - $ตนเอง , $นามสกุล ) = @_ ; $self -> { _lastName } = $lastName ถ้า กำหนดไว้ ( $ lastName ) ; $ ตนเอง -> { _lastName } ; ย่อย รับนามสกุล - ของฉัน ( $ตนเอง ) = @_ ; กลับ $ ตนเอง -> { _lastName } ; 1 ;

เราป้อนรหัสต่อไปนี้ในไฟล์ main.pl และดำเนินการ:

ตัวอย่าง

#!/usr/bin/perl ใช้พนักงาน ; $object = ใหม่ พนักงาน ( " Xiao Ming " , " Wang " , 23234345 ) ; # รับชื่อ ใช้ตัวสร้างที่แก้ไขแล้ว $firstName = $object - > getFirstName ( ) ; " ตั้งชื่อก่อนหน้าเป็น: $firstName n " ; # ใช้ฟังก์ชันเสริมในการตั้งชื่อ $ object -> setFirstName ( “ เสี่ยวเฉิง ” ) ; # รับชื่อผ่านฟังก์ชันตัวช่วย $firstName = $object - > getFirstName ( ) ; " ชื่อหลังจากการตั้งค่าคือ: $firstName n " ;

หลังจากรันโปรแกรมข้างต้นแล้ว ผลลัพธ์ที่ได้คือ:

 $ perl main.pl ชื่อ: Xiao Ming นามสกุล: Wang Number: 23234345 นี่คือชื่อของฟังก์ชันคลาสย่อยก่อนการตั้งค่า: Xiao Ming นี่คือชื่อของฟังก์ชันคลาสย่อยหลังจากการตั้งค่า: Xiaoqiang

โหลดโดยค่าเริ่มต้น

หากไม่พบวิธีการที่ร้องขอในคลาสปัจจุบัน คลาสพื้นฐานทั้งหมดของคลาสปัจจุบัน และคลาส UNIVERSAL วิธีการชื่อ AUTOLOAD() จะถูกค้นหาอีกครั้ง หากพบ AUTOLOAD ระบบจะเรียกใช้และตัวแปรโกลบอล $AUTOLOAD จะถูกตั้งค่าเป็นชื่อแบบเต็มของเมธอดที่ขาดหายไป

หากไม่ได้ผล Perl จะล้มเหลวโดยมีข้อผิดพลาด

หากคุณไม่ต้องการสืบทอด AUTOLOAD ของคลาสพื้นฐาน ง่ายมาก เพียงประโยคเดียว:

 โหลดอัตโนมัติย่อย;

ตัวทำลายล้างและการเก็บขยะ

วัตถุจะถูกทำลายโดยอัตโนมัติเมื่อมีการปล่อยการอ้างอิงล่าสุดไปยังวัตถุ

หากคุณต้องการทำอะไรบางอย่างระหว่างการทำลาย คุณสามารถกำหนดวิธีการชื่อ "DESTROY" ในคลาสได้ มันจะถูกเรียกโดยอัตโนมัติในเวลาที่เหมาะสมและดำเนินการล้างข้อมูลเพิ่มเติมตามที่คุณต้องการ

 แพ็คเกจ MyClass;...sub DESTROY{ พิมพ์ "MyClass::DESTROY เรียกว่าn";}

Perl จะส่งการอ้างอิงวัตถุเป็นพารามิเตอร์เดียวไปยัง DESTROY โปรดทราบว่าข้อมูลอ้างอิงนี้เป็นแบบอ่านอย่างเดียว ซึ่งหมายความว่าคุณไม่สามารถแก้ไขได้โดยการเข้าถึง $_[0] (หมายเหตุผู้แปล: ดู perlsub) แต่ตัววัตถุเอง (เช่น "${$_[0]" หรือ "@{$_[0]}" และ "%{$_[0]}" ฯลฯ ) สามารถ ยังคงเขียนอยู่

หากคุณ rebless การอ้างอิงวัตถุก่อนที่ destructor จะส่งกลับ Perl จะเรียกเมธอด DESTROY ของวัตถุที่คุณ reblessed หลังจากที่ destructor ส่งคืน สิ่งนี้ให้โอกาสคุณในการเรียก destructor ของคลาสพื้นฐานหรือคลาสอื่น ๆ ที่คุณระบุ ควรสังเกตว่า DESTROY สามารถเรียกด้วยตนเองได้ แต่โดยปกติแล้วไม่จำเป็นต้องทำเช่นนั้น

หลังจากที่วัตถุปัจจุบันถูกปล่อยออกมา วัตถุอื่นๆ ที่มีอยู่ในวัตถุปัจจุบันจะถูกปล่อยออกมาโดยอัตโนมัติ

ตัวอย่างเชิงวัตถุ Perl

เราสามารถเข้าใจเพิ่มเติมเกี่ยวกับการประยุกต์ใช้เชิงวัตถุของ Perl ได้จากตัวอย่างต่อไปนี้:

ตัวอย่าง

#!/usr/bin/perl #ต่อไปนี้เป็นการใช้งานคลาสอย่างง่าย บรรจุุภัณฑ์ มา ยคลาส ; ใหม่ - พิมพ์ " MyClass ::new เรียกว่า n " ; $type = shift ; # ชื่อแพ็คเกจ ของฉัน $self = { } ; # อ้างอิงถึงแฮชว่าง กลับ อวยพร $ตนเอง , $ประเภท ; } ย่อย ทำลาย - พิมพ์ " MyClass::DESTROY เรียกว่า n " ; ย่อย วิธีการของฉัน - พิมพ์ " MyClass::MyMethod เรียกว่า! n " ; #การดำเนินการสืบทอด บรรจุุภัณฑ์ MySubClass ; @ISA = qw ( MyClass ) ; ใหม่ - พิมพ์ " MySubClass ::new เรียกว่า n " ; $type = shift ; # ชื่อแพ็คเกจ ของฉัน $self = MyClass -> ใหม่ ; # อ้างอิงแฮชว่าง กลับ อวยพร $ตนเอง , $ประเภท ; } ย่อย ทำลาย - พิมพ์ " MySubClass::DESTROY เรียกว่า n " ; ย่อย วิธีการของฉัน - ของฉัน $self = shift ; $self - > SUPER :: MyMethod ( ) ; " MySubClass::MyMethod เรียกว่า! n " ; #เรียกโปรแกรมหลักของคลาสข้างต้น บรรจุุภัณฑ์ หลัก ; พิมพ์ " เรียกวิธี MyClass n " ; $myObject = MyClass -> new ( ) ; $ myObject -> MyMethod ( ) ; " เรียกวิธี MySubClass n " ; $myObject2 = MySubClass -> new ( ) ; $ myObject2 -> MyMethod ( ) ; " สร้างวัตถุขอบเขต n " ; ของฉัน $ myObject2 = MyClass -> ใหม่ ( ) ; # เรียกผู้ทำลายโดยอัตโนมัติ พิมพ์ " สร้างวัตถุ n " ; $myObject3 = MyClass - > new ( ) ; $myObject3 ; พิมพ์ " การดำเนินการสคริปต์สิ้นสุดลง... n " ; # ดำเนินการตัวทำลายโดยอัตโนมัติ

เมื่อรันโปรแกรมข้างต้น ผลลัพธ์ที่ได้คือ:

 เรียกเมธอด MyClass::newเรียกว่าMyClass::MyMethod เรียกว่า! เรียกเมธอด MySubClass MySubClass::new เรียกว่าMyClass::MyMethod เรียกว่า! เรียกว่าสร้างวัตถุ MyClass::newเรียกว่าMyClass::DESTROY เรียกว่าการเรียกใช้สคริปต์สิ้นสุด...MyClass::DESTROY เรียกว่าMySubClass::DESTROY เรียกว่า