สวัสดี! ในบทเรียนวันนี้ เราจะพูดถึงหลักการของการเขียนโปรแกรมเชิงวัตถุ คุณเคยสงสัยหรือไม่ว่าเหตุใด Java จึงได้รับการออกแบบตรงตามที่เป็นอยู่ ฉันหมายถึง คุณประกาศคลาสและสร้างออบเจกต์ตามคลาส คลาสมีเมธอด ฯลฯ แต่ทำไมโครงสร้างภาษาจึงให้โปรแกรมประกอบด้วยคลาสและออบเจกต์ ไม่ใช่อย่างอื่น เหตุใดแนวคิดของ "วัตถุ" จึงถูกคิดค้นและวางไว้ในระดับแนวหน้า ทุกภาษาได้รับการออกแบบด้วยวิธีนี้หรือไม่? ถ้าไม่ใช่ Java ให้ประโยชน์อะไรบ้าง อย่างที่คุณเห็นมีคำถามมากมาย :) ลองตอบคำถามแต่ละข้อในบทเรียนวันนี้

การเขียนโปรแกรมเชิงวัตถุ (OOP) คืออะไร?

แน่นอน Java ไม่ได้ประกอบด้วยวัตถุและคลาสเพียงเพื่อความสนุกสนาน พวกเขาไม่ใช่ความตั้งใจของผู้สร้าง Java และไม่ใช่สิ่งประดิษฐ์ของพวกเขาด้วยซ้ำ มีภาษาอื่น ๆ อีกมากมายตามวัตถุ ภาษาดังกล่าวภาษาแรกเรียกว่า "Simula" มันถูกคิดค้นขึ้นในปี 1960 ในประเทศนอร์เวย์ ยิ่งไปกว่านั้น แนวคิดของ "คลาส" และ "วิธีการ" ยังปรากฏใน Simula ตามมาตรฐานของการพัฒนาซอฟต์แวร์ "Simula" ดูเหมือนเป็นภาษาโบราณ แต่ทุกคนสามารถเห็น "ความคล้ายคลึงของตระกูล" กับ Java ได้ หลักการเขียนโปรแกรมเชิงวัตถุ--1คุณอาจจะอ่านโค้ดที่เขียนด้วยภาษานี้ได้ง่ายๆ และอธิบายคร่าวๆ ว่ามันทำอะไรได้บ้าง :) 

Begin
	Class Rectangle (Width, Height); Real Width, Height;
			           
	 Begin
	    Real Area, Perimeter;  
	 
	    Procedure Update;      
	    Begin
	      Area := Width * Height;
              OutText("Rectangle is updating, Area = "); OutFix(Area,2,8); OutImage;
	      Perimeter := 2*(Width + Height);
              OutText("Rectangle is updating, Perimeter = "); OutFix(Perimeter,2,8); OutImage;
	    End of Update;
	 
	    Update;               
	    OutText("Rectangle created: "); OutFix(Width,2,6);
	    OutFix(Height,2,6); OutImage;
	 End of Rectangle;

       Rectangle Class ColouredRectangle (Color); Text Color;
			           
	Begin   	  
	    OutText("ColouredRectangle created, color = "); OutText(Color);
	    OutImage;
        End of ColouredRectangle;

 
      	 Ref(Rectangle) Cr;            
	 Cr :- New ColouredRectangle(10, 20, "Green"); 
End;
โค้ดตัวอย่างโค้ดนี้นำมาจาก "Simula - 50 years of OOP" โดย Weekly-geekly อย่างที่คุณเห็น Java นั้นไม่แตกต่างจากรุ่นปู่ของมันมากนัก :) นี่เป็นเพราะความจริงที่ว่าการปรากฏตัวของ Simula ถือเป็นการกำเนิดของแนวคิดใหม่: การเขียนโปรแกรมเชิงวัตถุ Wikipedia กำหนด OOP ดังนี้: "การเขียนโปรแกรมเชิงวัตถุ (OOP) เป็นกระบวนทัศน์การเขียนโปรแกรมตามแนวคิดของ "วัตถุ" ซึ่งสามารถมีข้อมูลในรูปแบบของฟิลด์ (มักเรียกว่าแอตทริบิวต์) และรหัสในรูปแบบ ของขั้นตอน (มักเรียกว่าวิธีการ)" ในความคิดของฉันนี่เป็นคำจำกัดความที่ดีจริงๆ ไม่นานมานี้คุณเริ่มเรียนรู้ Java แต่คำจำกัดความนี้อาจไม่มีคำที่คุณไม่รู้จัก :) วันนี้ OOP เป็นวิธีการเขียนโปรแกรมที่ใช้กันมากที่สุด นอกจากจาวาแล้ว หลักการ OOP ใช้ในภาษายอดนิยมหลายภาษาที่คุณอาจเคยได้ยิน ตัวอย่างเช่น C++ (ใช้อย่างแข็งขันในการพัฒนาเกม), Objective-C และ Swift (ใช้เขียนโปรแกรมสำหรับอุปกรณ์ Apple), Python (นิยมมากที่สุดในการเรียนรู้ของเครื่อง), PHP (หนึ่งในภาษาพัฒนาเว็บที่ได้รับความนิยมมากที่สุด), JavaScript ( มันง่ายกว่าที่จะบอกว่ามันไม่ได้ใช้สำหรับอะไร) และอื่นๆ อีกมากมาย ดังนั้นหลักการของ OOP คืออะไร? เราจะบอกคุณในรายละเอียด หลักการของ OOP คืออะไร? เราจะบอกคุณในรายละเอียด หลักการของ OOP คืออะไร? เราจะบอกคุณในรายละเอียด

หลักการ OOP

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

หลักการ 1. การสืบทอด

ข่าวดี: คุณรู้หลักการบางอย่างของ OOP แล้ว! :) เราพบการสืบทอดมาแล้วสองสามครั้งในบทเรียน และเราสามารถใช้มันได้ การสืบทอดเป็นกลไกที่ให้คุณอธิบายคลาสใหม่ตามคลาส (พาเรนต์) ที่มีอยู่ ในการทำเช่นนั้น คลาสใหม่จะยืมคุณสมบัติและฟังก์ชันการทำงานของคลาสพาเรนต์ มรดกมีไว้เพื่ออะไรและมีข้อดีอย่างไร? เหนือสิ่งอื่นใด การใช้โค้ดซ้ำ ฟิลด์และเมธอดที่ประกาศในคลาสพาเรนต์สามารถใช้ในคลาสที่สืบทอดมา หากรถยนต์ทุกประเภทมี 10 ฟิลด์ทั่วไปและ 5 วิธีการที่เหมือนกัน คุณเพียงแค่ย้ายพวกมันไปที่รถยนต์ชั้นเรียนผู้ปกครอง คุณสามารถใช้มันในคลาสที่สืบทอดมาได้โดยไม่มีปัญหา ข้อได้เปรียบที่มั่นคง: ทั้งเชิงปริมาณ (โค้ดน้อย) และเป็นผลให้เชิงคุณภาพ (คลาสง่ายขึ้นมาก) ยิ่งไปกว่านั้น การสืบทอดยังมีความยืดหยุ่นมาก — คุณสามารถเพิ่มฟังก์ชันการเขียนแยกต่างหากที่ลูกหลานขาดหายไป (บางฟิลด์หรือลักษณะการทำงานเฉพาะสำหรับคลาสเฉพาะ) โดยทั่วไปแล้วในชีวิตจริงเราทุกคนค่อนข้างคล้ายกับพ่อแม่ แต่ก็แตกต่างจากพวกเขาด้วย :)

หลักการที่ 2. สิ่งที่เป็นนามธรรม

นี่เป็นหลักการง่ายๆ สิ่งที่เป็นนามธรรมหมายถึงการระบุลักษณะสำคัญและสำคัญที่สุดของบางสิ่ง ในขณะเดียวกันก็ละทิ้งสิ่งเล็กน้อยและไม่มีนัยสำคัญไปพร้อม ๆ กัน ไม่จำเป็นต้องคิดค้นล้อใหม่ ลองนึกถึงตัวอย่างจากบทเรียนเก่าเกี่ยวกับชั้นเรียน สมมติว่าเรากำลังสร้างระบบการยื่นเอกสารสำหรับพนักงานบริษัท ในการสร้างวัตถุ "พนักงาน" เราได้เขียนคลาสพนักงาน คุณลักษณะใดมีความสำคัญในการอธิบายไว้ในระบบการจัดเก็บเอกสารของบริษัท ชื่อ วันเกิด SSN และ ID พนักงาน แต่ไม่น่าเป็นไปได้ที่เราจะต้องการส่วนสูง สีตา หรือสีผมของพนักงานสำหรับเรกคอร์ดประเภทนี้ บริษัทไม่ต้องการข้อมูลดังกล่าวเกี่ยวกับพนักงาน ดังนั้นใน คลาส Employeeเราจึงประกาศตัวแปรดังต่อไปนี้:, int age , int socialSecurityNumberและint EmployeeId และเราลบข้อมูลที่ไม่จำเป็นออกไป เช่น สีตา อย่างไรก็ตาม หากเรากำลังสร้างระบบการจัดเก็บสำหรับเอเจนซี่โมเดล สถานการณ์จะเปลี่ยนไปอย่างมาก ความสูงของนางแบบ สีตา และสีผมเป็นคุณลักษณะที่สำคัญ แต่ SSN ของเธอไม่เกี่ยวข้องกับเราเลย ดังนั้นใน คลาส Modelเราสร้างตัวแปรต่อไปนี้: ความสูงของสตริง , ขนของสตริง , ตาของสตริง

หลักการที่ 3 การห่อหุ้ม

เราได้พบเจอสิ่งนี้แล้ว ใน Java การห่อหุ้มหมายถึงการจำกัดความสามารถในการอ่านและเปลี่ยนแปลงข้อมูล อย่างที่คุณเห็น คำนี้มาจากคำว่า "แคปซูล" เราจะใช้ "แคปซูล" เพื่อซ่อนข้อมูลสำคัญบางอย่างที่เราไม่ต้องการให้ผู้อื่นเปลี่ยนแปลง นี่คือตัวอย่างง่ายๆ จากชีวิตจริง คุณมีชื่อและนามสกุล เพื่อนของคุณทุกคนรู้จักพวกเขา แต่พวกเขาไม่มีความสามารถในการเปลี่ยนชื่อหรือนามสกุลของคุณ เราอาจกล่าวได้ว่ากระบวนการในการดำเนินการนั้น "ถูกห่อหุ้ม" โดยระบบศาล: คุณสามารถเปลี่ยนนามสกุลได้ผ่านทางเสมียนศาลเท่านั้น และมีเพียงคุณเท่านั้นที่สามารถทำได้ "ผู้ใช้" รายอื่นมีสิทธิ์เข้าถึงชื่อและนามสกุลของคุณแบบ "อ่านอย่างเดียว" :) อีกตัวอย่างหนึ่งคือเงินสดที่เก็บไว้ที่บ้าน การวางทิ้งไว้กลางห้องของคุณไม่ใช่ความคิดที่ดี "ผู้ใช้" ใดๆ (ผู้ที่มาที่บ้านของคุณ) จะสามารถเปลี่ยนจำนวนเงินของคุณได้ กล่าวคือ พวกเขาสามารถรับเงินของคุณได้ มันจะดีกว่าที่จะห่อหุ้มไว้ในที่ปลอดภัย จากนั้นการเข้าถึงจะมีให้สำหรับคุณเท่านั้นและใช้รหัสพิเศษเท่านั้น ตัวอย่างที่เห็นได้ชัดเจนของการห่อหุ้มที่คุณเคยใช้คือตัวแก้ไขการเข้าถึง (ส่วนตัว สาธารณะ ฯลฯ) รวมถึงตัวตั้งและตัวรับ หากคุณไม่สรุปฟิลด์ อายุของคลาสแมวใครๆ ก็เขียนได้: 

Cat.age = -1000;
กลไกการห่อหุ้มช่วยให้เราปกป้อง ฟิลด์ อายุด้วยวิธีตัวตั้งค่า ซึ่งเรามั่นใจได้ว่าอายุจะไม่สามารถตั้งค่าเป็นจำนวนลบได้

หลักการที่ 4 ความหลากหลาย

ความแตกต่างคือความสามารถในการทำงานกับหลายประเภทราวกับว่าเป็นประเภทเดียวกัน นอกจากนี้ พฤติกรรมของวัตถุจะแตกต่างกันไปตามประเภทของวัตถุ ฟังดูซับซ้อนไหม? มาทำความเข้าใจกันตอนนี้ ยกตัวอย่างที่ง่ายที่สุด: สัตว์ สร้าง คลาส Animal ด้วยเมธอด speak()เดียว และคลาสย่อย 2 คลาส ได้แก่Cat and Dog 

public class Animal {

   public void speak() {
      
       System.out.println("Hello!");
   }
}

public class Dog extends Animal {
  
   @Override
   public void speak() {
       System.out.println ("Woof-woof!");
   }
}

public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}
ตอนนี้เราจะพยายามประกาศ ตัวแปรอ้างอิง AnimalและกำหนดDog object ให้กับตัวแปรนั้น 

public class Main {

   public static void main(String[] args) {

       Animal dog = new Dog();
       dog.speak();
   }
}
ท่านคิดว่าจะเรียกวิธีใด? Animal.speak()หรือDog.speak() ? เมธอดใน คลาส Dogจะถูกเรียกว่า: Woof-woof! เราสร้าง การอ้างอิง สัตว์แต่วัตถุมีพฤติกรรมเหมือนสุนัข ถ้าจำเป็น มันอาจทำตัวเหมือนแมว ม้า หรือสัตว์อื่นๆ สิ่งสำคัญคือการกำหนดคลาสย่อยเฉพาะให้กับตัวแปรอ้างอิงAnimal ทั่วไป สิ่งนี้สมเหตุสมผลเพราะสุนัขทุกตัวเป็นสัตว์ นั่นคือสิ่งที่เราคิดไว้เมื่อเราพูดว่า "พฤติกรรมของวัตถุจะแตกต่างกันไปตามประเภทของวัตถุ" ถ้าเราสร้างCat object... 

public static void main(String[] args) {

   Animal cat = new Cat();
   cat.speak();
}
วิธี การพูด ()จะแสดง "Meow!" แต่เราหมายถึงอะไรโดย 'ความสามารถในการทำงานกับหลายประเภทราวกับว่าเป็นประเภทเดียวกัน' นี่ค่อนข้างตรงไปตรงมา ลองจินตนาการว่าเรากำลังสร้างร้านตัดผมสำหรับสัตว์ ร้านตัดผมของเราควรสามารถเล็มขนสัตว์ตัวใดก็ได้ ดังนั้นเราจึงสร้างเมธอดtrim()ด้วย พารามิเตอร์ Animal (สัตว์กำลังตัดผม) 

public class AnimalBarbershop {

   public void trim(Animal animal) {

       System.out.println("The haircut is done!"); 
   }
}
และตอนนี้เราสามารถส่งวัตถุCat and Dog ไปยังวิธีการ trim() ได้แล้ว ! 

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   AnimalBarbershop barbershop = new AnimalBarbershop();

   barbershop.trim(cat);
   barbershop.trim(dog);
}
และนี่คือตัวอย่างที่ชัดเจน: คลาส AnimalBarbershopทำงานกับ ประเภท CatและDogราวกับว่าเป็นประเภทเดียวกัน ในขณะเดียวกันแมวและสุนัขก็มีพฤติกรรมที่แตกต่างกัน พวกมันต่างก็พูดไม่เหมือนกัน

ทำไมเราถึงต้องการ OOP?

เหตุใด OOP จึงเกิดขึ้นเป็นแนวคิดการเขียนโปรแกรมใหม่ โปรแกรมเมอร์มีเครื่องมือที่ใช้งานได้ เช่น ภาษาขั้นตอน อะไรกระตุ้นให้พวกเขาคิดค้นสิ่งใหม่โดยพื้นฐาน เหนือสิ่งอื่นใดคือความซับซ้อนของงานที่ต้องเผชิญ หากเมื่อ 60 ปีที่แล้ว งานของโปรแกรมเมอร์คือ "ประเมินนิพจน์ทางคณิตศาสตร์" ตอนนี้อาจเป็น "ใช้ตอนจบที่แตกต่างกัน 7 แบบสำหรับเกม STALKER โดยขึ้นอยู่กับการรวมกันของการตัดสินใจของผู้เล่นที่จุด A, B, C, DE , และ F ในเกม" อย่างที่คุณเห็น เห็นได้ชัดว่างานมีความซับซ้อนมากขึ้นในช่วงหลายทศวรรษที่ผ่านมา และเป็นผลให้ประเภทข้อมูลมีความซับซ้อนมากขึ้น นี่เป็นอีกสาเหตุหนึ่งที่ทำให้ OOP ปรากฏขึ้น นิพจน์ทางคณิตศาสตร์สามารถประเมินได้อย่างง่ายดายโดยใช้พื้นฐานทั่วไป ไม่จำเป็นต้องใช้วัตถุที่นี่ แต่งานที่มีการจบเกมนั้นยากที่จะอธิบายโดยไม่ต้องใช้คลาสที่กำหนดเอง ที่กล่าวว่ามันค่อนข้างง่ายที่จะอธิบายโดยใช้คลาสและวัตถุ แน่นอนว่าเราต้องการหลายคลาส: Game, Stalker, Ending, PlayerDecision, GameEvent และอื่นๆ กล่าวอีกนัยหนึ่งแม้ไม่ได้เริ่มแก้ปัญหา เราก็สามารถ "ร่าง" วิธีแก้ปัญหาในหัวได้อย่างง่ายดาย ความซับซ้อนที่เพิ่มขึ้นของงานทำให้โปรแกรมเมอร์ต้องแบ่งงานออกเป็นส่วนๆ แต่สิ่งนี้ไม่ง่ายเลยที่จะทำในการเขียนโปรแกรมเชิงขั้นตอน และบ่อยครั้งมากที่โปรแกรมก็เหมือนต้นไม้ที่มีกิ่งก้านจำนวนมากซึ่งแสดงถึงเส้นทางการดำเนินการที่เป็นไปได้ทั้งหมด สาขาหนึ่งของโปรแกรมหรืออีกสาขาหนึ่งถูกดำเนินการขึ้นอยู่กับเงื่อนไขบางประการ สำหรับโปรแกรมขนาดเล็ก วิธีนี้สะดวก แต่การแบ่งปัญหาใหญ่ออกเป็นส่วนๆ เป็นเรื่องยากมาก นี่เป็นอีกสาเหตุหนึ่งที่ทำให้ OOP ถือกำเนิดขึ้น กระบวนทัศน์นี้ทำให้โปรแกรมเมอร์สามารถแบ่งโปรแกรมออกเป็น "โมดูล" (คลาส) ซึ่งแต่ละโมดูลทำหน้าที่ของตัวเอง โดยการโต้ตอบซึ่งกันและกัน วัตถุทั้งหมดทำงานของโปรแกรมของเราได้สำเร็จ นอกจากนี้ เราสามารถนำโค้ดของเราไปใช้ซ้ำที่อื่นในโปรแกรมได้ ซึ่งช่วยประหยัดเวลาได้มาก

อ่านเพิ่มเติม: