البرمجة الشيئية (OOP) في جافا: الفئات، الوراثة، والتعددية الشكلية

ما هي البرمجة الشيئية (OOP)؟

البرمجة الشيئية (Object-Oriented Programming) هي نموذج برمجي يعتمد على الكائنات (Objects) لتصميم البرامج. يتم تمثيل الكائنات باستخدام فئات (Classes)، وتوفر OOP أربع مفاهيم رئيسية: التغليف (Encapsulation)، الوراثة (Inheritance)، التعددية الشكلية (Polymorphism)، والتجريد (Abstraction). يهدف هذا النموذج إلى تنظيم الكود بشكل يسهل صيانته وإعادة استخدامه.

المفاهيم الأساسية في البرمجة الشيئية

تشمل البرمجة الشيئية في جافا أربعة مفاهيم رئيسية:

• التغليف (Encapsulation): هو عملية تجميع البيانات والدوال التي تعمل عليها في كائن واحد، مع إخفاء تفاصيل التنفيذ. يتم ذلك باستخدام المحددات private و public.
• الوراثة (Inheritance): هي عملية إنشاء فئة جديدة ترث خصائص ودوال فئة أخرى. يتم استخدام الكلمة المفتاحية extends لتحقيق الوراثة.
• التعددية الشكلية (Polymorphism): هي القدرة على استخدام كائنات مختلفة من فئات متعددة بنفس الطريقة. يتم تحقيق ذلك باستخدام الدوال التي يتم تجاوزها (Overriding) والدوال التي يتم تحميلها الزائد (Overloading).
• التجريد (Abstraction): هو عملية إخفاء تفاصيل التنفيذ والتركيز على الوظيفة الأساسية فقط. يتم تحقيق التجريد باستخدام الفئات المجردة (Abstract Classes) والواجهات (Interfaces).

إنشاء الفئات والكائنات في جافا

في البرمجة الشيئية، الفئة (Class) هي قالب يُستخدم لإنشاء كائنات. تحتوي الفئة على الخصائص (Attributes) والدوال (Methods) التي تُعرف سلوك الكائن. الصيغة العامة لإنشاء فئة في جافا هي:

class ClassName {
   // خصائص الفئة
   String name;
   int age;

   // دالة مُنشئة (Constructor)
   ClassName(String name, int age) {
      this.name = name;
      this.age = age;
   }

   // دالة لطباعة معلومات الكائن
   void display() {
      System.out.println("الاسم: " + name + ", العمر: " + age);
   }
}

public class Main {
   public static void main(String[] args) {
      // إنشاء كائن جديد من الفئة
      ClassName person = new ClassName("أحمد", 25);
      person.display();
   }
}

في هذا المثال، قمنا بإنشاء فئة باسم ClassName تحتوي على خصائص name و age، ودالة منشئة (Constructor) لتعيين هذه الخصائص. ثم قمنا بإنشاء كائن من هذه الفئة واستخدامه لطباعة المعلومات.

مفهوم الوراثة (Inheritance) في جافا

الوراثة تُستخدم لإنشاء فئات جديدة تعتمد على فئات موجودة. الفئة الفرعية (Subclass) ترث جميع الخصائص والدوال من الفئة الأب (Superclass)، ويمكنها إضافة خصائص ودوال جديدة أو تجاوز (Override) الدوال الموجودة. الصيغة العامة هي:

class ParentClass {
   void display() {
      System.out.println("هذه دالة من الفئة الأب.");
   }
}

class ChildClass extends ParentClass {
   void display() {
      System.out.println("هذه دالة من الفئة الفرعية.");
   }
}

public class Main {
   public static void main(String[] args) {
      ChildClass child = new ChildClass();
      child.display();  // استدعاء الدالة من الفئة الفرعية
   }
}

في هذا المثال، الفئة ChildClass ترث من الفئة ParentClass وتقوم بتجاوز الدالة display لتقديم تنفيذ مختلف.

مفهوم التعددية الشكلية (Polymorphism) في جافا

التعددية الشكلية (Polymorphism) تسمح باستخدام كائنات من فئات متعددة بنفس الطريقة، ويمكن تحقيقها بطريقتين:

• التجاوز (Method Overriding): الفئة الفرعية تقوم بإعادة تعريف دالة موجودة في الفئة الأب.
• التحميل الزائد (Method Overloading): وجود عدة دوال بنفس الاسم في نفس الفئة، ولكن مع معلمات (Parameters) مختلفة.

مثال على التجاوز:

class Animal {
   void makeSound() {
      System.out.println("صوت الحيوان.");
   }
}

class Dog extends Animal {
   void makeSound() {
      System.out.println("الكلب ينبح.");
   }
}

public class Main {
   public static void main(String[] args) {
      Animal myAnimal = new Dog();
      myAnimal.makeSound();  // استدعاء الدالة من الفئة Dog
   }
}

في هذا المثال، الفئة Dog تقوم بتجاوز الدالة makeSound من الفئة Animal، وعند استدعاء الدالة باستخدام كائن من الفئة الأب، يتم تنفيذ الدالة من الفئة الفرعية.

مفهوم التجريد (Abstraction) في جافا

التجريد (Abstraction) هو عملية إخفاء تفاصيل التنفيذ والتركيز على الوظائف الأساسية فقط. يمكن تحقيق التجريد باستخدام الفئات المجردة (Abstract Classes) والواجهات (Interfaces). الفئة المجردة تحتوي على دوال مجردة (بدون تنفيذ) يمكن أن ترثها الفئات الأخرى وتوفر تنفيذًا لها.

abstract class Animal {
   abstract void makeSound();  // دالة مجردة

   void sleep() {
      System.out.println("الحيوان ينام.");
   }
}

class Dog extends Animal {
   void makeSound() {
      System.out.println("الكلب ينبح.");
   }
}

public class Main {
   public static void main(String[] args) {
      Dog myDog = new Dog();
      myDog.makeSound();  // استدعاء الدالة من الفئة Dog
      myDog.sleep();  // استدعاء الدالة العادية من الفئة الأب
   }
}

في هذا المثال، الفئة Animal تحتوي على دالة مجردة makeSound بدون تنفيذ. الفئة Dog تقوم بتوفير تنفيذ لهذه الدالة.

استخدام الواجهات (Interfaces) في جافا

الواجهات (Interfaces) هي نوع خاص من التجريد، تحتوي فقط على دوال مجردة (بدون تنفيذ) وخصائص ثابتة (Constants). يمكن للفئات أن تطبق أكثر من واجهة واحدة، مما يوفر مرونة أكبر مقارنةً بالوراثة العادية.

interface Animal {
   void makeSound();
}

interface Pet {
   void play();
}

class Dog implements Animal, Pet {
   public void makeSound() {
      System.out.println("الكلب ينبح.");
   }

   public void play() {
      System.out.println("الكلب يلعب.");
   }
}

public class Main {
   public static void main(String[] args) {
      Dog myDog = new Dog();
      myDog.makeSound();
      myDog.play();
   }
}

في هذا المثال، الفئة Dog تطبق الواجهتين Animal و Pet، وتوفر تنفيذًا للدوال المجردة في كل واجهة.

تمرين (مستوى متوسط): إنشاء برنامج لإدارة السيارات باستخدام البرمجة الشيئية

في هذا التمرين، سنقوم بإنشاء برنامج لإدارة بيانات السيارات باستخدام مفاهيم البرمجة الشيئية.

المتطلبات:

• إنشاء فئة رئيسية Vehicle تحتوي على الخصائص brand و speed، ودالة displayInfo.
• إنشاء فئة فرعية Car ترث من الفئة Vehicle، وتحتوي على خاصية numberOfDoors.
• إنشاء فئة فرعية Truck ترث من الفئة Vehicle، وتحتوي على خاصية loadCapacity.
• إنشاء كائنات من الفئات الفرعية، واستدعاء الدوال لعرض معلومات كل كائن.

الكود:

class Vehicle {
   String brand;
   int speed;

   Vehicle(String brand, int speed) {
      this.brand = brand;
      this.speed = speed;
   }

   void displayInfo() {
      System.out.println("العلامة التجارية: " + brand + ", السرعة: " + speed + " كم/ساعة");
   }
}

class Car extends Vehicle {
   int numberOfDoors;

   Car(String brand, int speed, int numberOfDoors) {
      super(brand, speed);
      this.numberOfDoors = numberOfDoors;
   }

   void displayInfo() {
      super.displayInfo();
      System.out.println("عدد الأبواب: " + numberOfDoors);
   }
}

class Truck extends Vehicle {
   int loadCapacity;

   Truck(String brand, int speed, int loadCapacity) {
      super(brand, speed);
      this.loadCapacity = loadCapacity;
   }

   void displayInfo() {
      super.displayInfo();
      System.out.println("سعة الحمولة: " + loadCapacity + " كجم");
   }
}

public class Main {
   public static void main(String[] args) {
      Car myCar = new Car("Toyota", 180, 4);
      Truck myTruck = new Truck("Volvo", 120, 2000);

      System.out.println("معلومات السيارة:");
      myCar.displayInfo();

      System.out.println("\nمعلومات الشاحنة:");
      myTruck.displayInfo();
   }
}

شرح الكود:

• قمنا بإنشاء فئة رئيسية Vehicle تحتوي على الخصائص brand و speed، ودالة displayInfo.
• قمنا بإنشاء فئتين فرعيتين Car و Truck، تحتوي كل منهما على خصائص إضافية ودالة displayInfo لتوفير معلومات إضافية.
• أنشأنا كائنات من الفئات الفرعية وعرضنا معلوماتها.

جرّب تنفيذ هذا البرنامج بنفسك، وشارك نتيجتك معنا في التعليقات! إذا واجهتك أي مشكلة أو كان لديك سؤال، لا تتردد في طرحه.

خاتمة

في هذا الدرس، تعرفنا على مفاهيم البرمجة الشيئية (OOP) في جافا، مثل الفئات، الوراثة، التعددية الشكلية، والتجريد. نوصي بممارسة التمرين المقدم لاكتساب المزيد من الخبرة في تطبيق هذه المفاهيم في برامج جافا. لا تنسَ ترك تعليق أو مشاركة هذا الدرس مع أصدقائك على وسائل التواصل الاجتماعي إذا وجدته مفيدًا!