หลักการของ OOP

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

หลักการของ OOP:

1. มรดก
2. นามธรรม
3. การห่อหุ้ม
4. ความแตกต่าง

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

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

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 ปีของ OOP อย่างที่คุณเห็น Java และบรรพบุรุษไม่ได้แตกต่างกันมากนัก :) นี่เป็นเพราะความจริงที่ว่าการปรากฏตัวของ Simula ถือเป็นการกำเนิดของแนวคิดใหม่ - การเขียนโปรแกรมเชิงวัตถุ วิกิพีเดียให้คำจำกัดความของ OOP ดังต่อไปนี้: การเขียนโปรแกรมเชิงวัตถุ (OOP)เป็นวิธีการเขียนโปรแกรมโดยแสดงโปรแกรมเป็นชุดของอ็อบเจ็กต์ ซึ่งแต่ละอันเป็นอินสแตนซ์ของคลาสเฉพาะ และคลาสต่างๆ จะสร้างลำดับชั้นการสืบทอด ในความคิดของฉันถือว่าประสบความสำเร็จอย่างมาก คุณเพิ่งเริ่มเรียนรู้ Java แต่แทบจะไม่มีคำใด ๆ ในนั้นที่ไม่คุ้นเคยสำหรับคุณ :) วันนี้ OOP เป็นวิธีการเขียนโปรแกรมที่ใช้บ่อยที่สุด นอกจาก Java แล้ว หลักการ OOP ยังใช้ในภาษายอดนิยมมากมายที่คุณอาจเคยได้ยิน เหล่านี้คือ C++ (มีการใช้งานโดยนักพัฒนาเกมคอมพิวเตอร์), Objective-C และ Swift (เขียนโปรแกรมสำหรับอุปกรณ์ Apple), Python (เป็นที่ต้องการมากที่สุดในการเรียนรู้ของเครื่อง), PHP (หนึ่งในภาษาการพัฒนาเว็บที่ได้รับความนิยมมากที่สุด) JavaScript (ง่ายกว่าพูดในสิ่งที่พวกเขาไม่ได้ทำ) และอื่นๆ อีกมากมาย จริงๆ แล้ว “หลักการ” ของ OOP เหล่านี้คืออะไร? มาบอกรายละเอียดเพิ่มเติมกันดีกว่า

หลักการของ OOP

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

หลักการที่ 1 การรับมรดก

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

หลักการที่ 2 นามธรรม

นี่เป็นหลักการที่ง่ายมาก สิ่งที่เป็นนามธรรมหมายถึงการเน้นคุณลักษณะหลักที่สำคัญที่สุดของวัตถุและในทางกลับกัน - ละทิ้งสิ่งรองที่ไม่มีนัยสำคัญ อย่าสร้างวงล้อขึ้นมาใหม่และจำตัวอย่างจากการบรรยายเก่าเกี่ยวกับชั้นเรียน สมมติว่าเรากำลังสร้างตู้เก็บเอกสารของพนักงานบริษัท Employeeในการสร้าง วัตถุพนักงาน เราได้เขียนคลาส คุณลักษณะใดที่สำคัญสำหรับคำอธิบายในไฟล์บริษัท ชื่อนามสกุล วันเกิด หมายเลขประกันสังคม หมายเลขประจำตัวผู้เสียภาษี แต่ไม่น่าเป็นไปได้ที่ในการ์ดประเภทนี้เราต้องการความสูงตาและสีผมของเขา บริษัทไม่ต้องการข้อมูลนี้เกี่ยวกับพนักงาน ดังนั้นสำหรับคลาสนี้Employeeเราจะตั้งค่าตัวแปรString name, int age, int socialInsuranceNumberและint taxNumberและเราจะละทิ้งข้อมูลที่ไม่จำเป็นสำหรับเรา เช่น สีตา และนามธรรม แต่ถ้าเราสร้างแคตตาล็อกภาพถ่ายนางแบบให้กับเอเจนซี่ สถานการณ์จะเปลี่ยนไปอย่างมาก ในการอธิบายนางแบบแฟชั่น ความสูง สีตา และสีผมมีความสำคัญมากสำหรับเรา แต่ไม่จำเป็นต้องใช้หมายเลข TIN ดังนั้นในคลาสModelเราจึงสร้างตัวแปรString height, String hair, String eyes.

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

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

Cat.age = -1000;

และกลไกการห่อหุ้มช่วยให้เราสามารถปกป้องสนามageด้วยวิธีเซ็ตเตอร์ ซึ่งเราสามารถตรวจสอบได้ว่าอายุไม่สามารถเป็นจำนวนลบได้

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

Polymorphismคือความสามารถในการปฏิบัติต่อหลายประเภทราวกับว่าเป็นประเภทเดียวกัน ในกรณีนี้ ลักษณะการทำงานของออบเจ็กต์จะแตกต่างกันขึ้นอยู่กับประเภทของวัตถุนั้น ฟังดูซับซ้อนนิดหน่อยใช่ไหม? ลองคิดดูตอนนี้ ลองใช้ตัวอย่างที่ง่ายที่สุด - สัตว์ มาสร้างคลาสAnimalด้วยเมธอดเดียว - และ voice()คลาสลูกหลานอีกสองตัว - CatและDog

public class Animal {

   public void voice() {

       System.out.println("Voice!");
   }
}

public class Dog extends Animal {


   @Override
   public void voice() {
       System.out.println("Bow-wow!");
   }
}

public class Cat extends Animal {

   @Override
   public void voice() {
       System.out.println("Meow!");
   }
}

ตอนนี้เรามาลองสร้างลิงก์Animalและกำหนดวัตถุให้กับDogมัน

public class Main {

   public static void main(String[] args) {

       Animal dog = new Dog();
       dog.voice();
   }
}

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

public static void main(String[] args) {

   Animal cat = new Cat();
   cat.voice();
}

วิธีการvoice()จะส่งออก "Meow!" “ความสามารถในการทำงานหลายประเภทเสมือนเป็นประเภทเดียวกัน” หมายความว่าอย่างไร? นี่ก็ค่อนข้างง่ายเช่นกัน ลองจินตนาการว่าเรากำลังสร้างร้านทำผมสำหรับสัตว์ ร้านทำผมของเราต้องสามารถตัดสัตว์ได้ทั้งหมด ดังนั้นเราจะสร้างวิธีการshear()(“ตัด”) โดยมีพารามิเตอร์Animal- สัตว์ที่เราจะตัด

public class AnimalBarbershop {

   public void shear(Animal animal) {

       System.out.println("The haircut is ready!");
   }
}

และตอนนี้เราสามารถส่งผ่านshearทั้ง object Catและ object ไปยัง method ได้แล้ว Dog!

public static void main(String[] args) {

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

   AnimalBarbershop barbershop = new AnimalBarbershop();

   barbershop.shear(cat);
   barbershop.shear(dog);
}

นี่คือตัวอย่างที่ชัดเจน: คลาสAnimalBarbershopทำงานกับประเภทCatราวกับDogว่าเป็นประเภทเดียวกัน ในขณะเดียวกันก็มี พฤติกรรม Catที่แตกต่างกันDog: พวกเขาใช้เสียงต่างกัน

สาเหตุของการเกิด OOP

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