Subclass

عند استخدام كور داتا في تطبيقك، يقوم إكس كود بإنشاء مجموعة من الأكواد التي تسهل عليك الوصول إلى البيانات المخزنة. واحدة من هذه الأكواد هي الاستعلام عن البيانات من قاعدة البيانات باستخدام fetchRequest(). ومع ذلك، قد تواجه بعض الصعوبات في بعض الأحيان عند استخدام هذه الأكواد.

في الشفرة التي قمت بتقديمها، تستخدم fetchRequest() لاسترجاع طلب لاستعلام البيانات من قاعدة البيانات. ومن المتوقع أن يكون نوع البيانات المُرجعة من هذا الاستعلام هو NSFetchRequest، حيث يُمثل Person نموذج البيانات الذي تعمل عليه.

لكن، يبدو أنك تواجه مشكلة تتعلق بالغموض في استخدام الدالة fetchRequest()، حيث تظهر رسالة خطأ تقول “Ambiguous use of ‘fetchRequest'”، وهذا يعني أن هناك تضارب في استخدام الدالة، مما يجعل الكمبايلر غير قادر على تحديد الدالة التي يجب استخدامها.

لحل هذه المشكلة، قمت بتحديد نوع المتغير fr على أنه NSFetchRequest، مما يساعد الكمبايلر على تحديد الدالة المناسبة التي يجب استخدامها. وبالتالي، تعمل هذه الخطوة كحلاً مؤقتًا للمشكلة.

لكن، تبقى السؤال هو لماذا تحتاج إلى تحديد نوع المتغير fr بنفس الطريقة التي تحدد بها نوع البيانات المُرجعة من fetchRequest()؟ السبب يعود إلى استخدام توقيع الدالة fetchRequest()، حيث يُعتبر النوع المُرجع من الدالة فقط مكونًا جزئيًا من توقيع الدالة، ولا يؤخذ بعين الاعتبار عند تحديد نوع المتغير.

لحل هذه المشكلة بشكل أفضل، يمكنك استخدام نوع البيانات المُرجع من fetchRequest() كجزء من توقيع المتغير، مما يجعل الكمبايلر يتمكن من فهم التوقيع بشكل صحيح وتجنب الاشتباكات في استخدام الدالة. وبالتالي، يمكنك استبدال الخط:

swiftCopy code
let fr: NSFetchRequest<Person> = Person.fetchRequest()

بالخط:

swiftCopy code
let fr = Person.fetchRequest() as! NSFetchRequest<Person>

باستخدام عبارة التحويل as! للتأكد من أن نوع المتغير يُفهم بشكل صحيح كنوع NSFetchRequest.

باختصار، على الرغم من أن نوع البيانات المُرجع من fetchRequest() يُعتبر جزءًا من توقيع الدالة، إلا أنه لا يُعتبر عنصرًا مؤثرًا في تحديد نوع المتغير عند استخدام الدالة.

بمجرد فهمك لهذه النقطة، يمكنك البحث عن حلول أفضل لهذه المشكلة وتجنب الحاجة إلى تحديد نوع المتغير بنفس الطريقة التي تحدد بها نوع البيانات المُرجعة من fetchRequest().

إحدى الطرق البسيطة لتجنب هذه المشكلة هي استخدام توجيه الكود (Type Inference) الذي يوفره لك لغة Swift. يمكنك ببساطة ترك المتغير fr بدون تحديد نوعه، ودع Swift يتحدد نوع المتغير تلقائياً استناداً إلى نوع البيانات المُرجعة من fetchRequest().

باستخدام هذا النهج، يمكن تبسيط الشفرة إلى الشكل التالي:

swiftCopy code
let fr = Person.fetchRequest()

وبهذا الشكل، يتولى Swift مهمة تحديد نوع المتغير fr تلقائياً، مما يسهل عليك الكتابة ويزيد من وضوح الشفرة.

علاوة على ذلك، يمكنك أيضاً استخدام تحويل النوع (Type Casting) في Swift للتأكد من نوع المتغير fr بشكل صحيح دون الحاجة إلى تحديد نوعه يدوياً. يمكنك استخدام as! للتأكد من أن نوع المتغير هو NSFetchRequest كما هو موضح في الشفرة التالية:

swiftCopy code
let fr = Person.fetchRequest() as! NSFetchRequest<Person>

عند استخدام هذا النهج، يتم التحقق من أن نوع المتغير fr هو النوع المناسب NSFetchRequest بشكل صحيح.

باختصار، تتيح لك لغة Swift عدة طرق للتعامل مع هذه المشكلة، مما يجعل عملية كتابة الشفرة أكثر سهولة ووضوحاً. باستخدام التوجيه الكودي وتحويل النوع، يمكنك تجنب الحاجة إلى تحديد نوع المتغير يدوياً، وبالتالي تحسين كفاءة واضحة وسهولة قراءة الشفرة.

عند استخدام super() في TypeScript لاستدعاء ال constructor من الفئة الأساسية، يجب عليك تمرير المعلمات المطلوبة لل constructor الأساسي. في هذه الحالة، constructor في فئة Artist يتطلب أربع معاملات: name و age و style و location. لذلك، عند استخدام super() في فئة StreetArtist، يجب عليك تمرير هذه المعاملات.

هناك عدة طرق للقيام بذلك. يمكنك إما تعديل constructor في StreetArtist لتمرير المعاملات المطلوبة إلى super() كما هو موضح في المثال التالي:

typescriptCopy code
class StreetArtist extends Artist {
  constructor(
    public medium: string,
    public famous: boolean,
    public arrested: boolean,
    public art: Artist,
    name: string, // إضافة المعاملات المطلوبة لل constructor في الفئة الأساسية
    age: number,
    style: string,
    location: string
  ){
    super(name, age, style, location); // استدعاء constructor في الفئة الأساسية مع المعاملات المطلوبة
    console.log(`instantiated ${this.name}. Are they famous? ${famous}. Are they locked up? ${arrested}`);
  }
}

أو يمكنك تعديل constructor في Artist لجعل بعض المعاملات اختيارية، مما يسمح لك بتمرير فقط المعاملات التي تحتاجها في StreetArtist كما هو موضح في المثال التالي:

typescriptCopy code
class Artist {
  constructor(
    public name?: string, // جعل المعاملات اختيارية
    public age?: number,
    public style?: string,
    public location?: string
  ){
    if (name) { // التحقق من وجود المعامل قبل استخدامه
      console.log(`instantiated ${name}, whom is ${age} old, from ${location}, and heavily regarded in the ${style} community`);
    }
  }
}

class StreetArtist extends Artist {
  constructor(
    public medium: string,
    public famous: boolean,
    public arrested: boolean,
    public art: Artist
  ){
    super(); // يمكنك تمرير فقط المعاملات التي تحتاجها هنا
    console.log(`instantiated ${this.name}. Are they famous? ${famous}. Are they locked up? ${arrested}`);
  }
}

يرجى ملاحظة أنه في المثال الثاني، قمت بتعديل constructor في Artist لجعل المعاملات اختيارية، ولذلك يجب عليك التحقق من وجود المعامل قبل استخدامه داخل constructor.

بالتأكيد، إليك المزيد من المعلومات حول استخدام super() في TypeScript:

1. super() يجب أن يكون الاستدعاء الأول في constructor في الفئة المشتقة. وهذا يعني أنه يجب أن يكون في السطر الأول من constructor.

2. إذا كان constructor في الفئة المشتقة لا يحتوي على أي استدعاء ل super()، سيتم ضمنياً استدعاء super() بدون معاملات.

3. عند استخدام super()، يجب تمرير المعاملات المطلوبة ل constructor في الفئة الأساسية. إذا تم تعريف constructor في الفئة الأساسية بحيث يأخذ معاملات اختيارية، يمكنك تمرير فقط المعاملات التي تحتاجها.

4. إذا كنت بحاجة إلى تمرير معاملات ل super() في constructor الفئة المشتقة وكذلك القيام بعمليات إضافية، يمكنك تنفيذ العمليات الإضافية بعد استدعاء super().

5. يمكنك استخدام super أيضًا للوصول إلى الخصائص والأساليب الموروثة من الفئة الأساسية. على سبيل المثال، يمكنك استدعاء أساليب موروثة من super داخل أساليب في الفئة المشتقة.

هذه هي الأساسيات الرئيسية لاستخدام super() في TypeScript. إذا كان لديك أي أسئلة أو استفسارات أخرى، فلا تتردد في طرحها.

عند دراسة الشيفرة التي قدمتها، يظهر وجود تفاعل غير متوقع يتعلق بتنفيذ الكود الثابت في الفئة الفرعية Sub. لفهم هذا السلوك الغريب، يجب النظر في كيفية تفاعل الشيفرة في بيئة Java.

أولاً وقبل كل شيء، دعونا نلقي نظرة على التصميم الأساسي للشيفرة. لدينا فئتين، SuperClass و Sub، حيث تمتد Sub من SuperClass. يظهر الكود الثابت في الفئتين، وهو الذي أدى إلى النتائج الغير متوقعة عند تشغيل البرنامج.

عند تشغيل البرنامج، يتم تنفيذ الكود الثابت في الفئة الأم (SuperClass) أولاً. لذلك ترى “super” كإخراج أولي. ثم، عندما يتم تحميل الفئة الفرعية (Sub)، يتم تنفيذ الكود الثابت فيها، مما يؤدي إلى ظهور “sub” كجزء من الإخراج.

لكن هنا يأتي السؤال: لماذا يتم تنفيذ الكود الثابت في الفئة الفرعية عندما يتم إنشاء كائن من الفئة الأم؟

الإجابة تكمن في العلاقة بين الفئة الفرعية والفئة الأم. عندما يتم تحميل الفئة الفرعية، سواء تم إنشاء كائن منها أم لا، يتم تنفيذ الكود الثابت في الفئة الفرعية. هذا يحدث لأن الفئة الفرعية هي جزء من تعليمة new SuperClass() في الطريقة main.

لتجنب تنفيذ الكود الثابت في الفئة الفرعية عند إنشاء كائن من الفئة الأم، يمكنك تجربة إنشاء كائن من الفئة الفرعية مباشرة، دون الرجوع إلى الفئة الأم، وستجد أن الإخراج يختلف.

باختصار، يحدث تنفيذ الكود الثابت في الفئة الفرعية لأنها جزء من تحميل الفئة الأم.

بناءً على التحليل السابق للشيفرة والإجابة على السؤال حول سبب تنفيذ كود الفئة الفرعية عند إنشاء كائن من الفئة الأم، يمكننا استكشاف المزيد من المعلومات حول المفاهيم المتعلقة بلغة البرمجة Java والتصرفات الثابتة والديناميكية في البرنامج.

مفهوم الـ Static في Java:

في Java، يعني استخدام كلمة المفتاح static أن العنصر (سواء كانت هي متغير أو طريقة) ينتمي إلى الفئة نفسها بدلاً من الكائنات التي يتم إنشاؤها من الفئة. وبما أن الكود الثابت ينتمي إلى الفئة، يتم تنفيذه عند تحميل الفئة في الذاكرة، وليس عند إنشاء كائن من هذه الفئة.

تسلسل تنفيذ الكود في Java:

عند تحميل البرنامج، تتم مراحل مختلفة من تنفيذ الكود. يتم تنفيذ الكود الثابت في الفئة عندما تكون الفئة جاهزة للاستخدام، ويتم تنفيذ الكود الدينامي عندما تتم استدعاء الطرق أو إنشاء الكائنات.

التأثير على الفئات الفرعية:

عند توسيع الفئة الفرعية من الفئة الأم، تحمل الفئة الفرعية جميع الخصائص الثابتة والدينامية من الفئة الأم. ولهذا السبب، عندما تتم تحميل الفئة الفرعية، يتم تنفيذ الكود الثابت فيها أيضًا، وذلك بغض النظر عما إذا كنا نقوم بإنشاء كائن من الفئة الفرعية أو الفئة الأم.

تجنب تنفيذ الكود الثابت:

إذا أردت تجنب تنفيذ الكود الثابت في الفئة الفرعية عند إنشاء كائن من الفئة الأم، يمكنك تجربة إنشاء كائن من الفئة الفرعية مباشرة دون الرجوع إلى الفئة الأم، أو يمكنك استخدام كائن من الفئة الفرعية في طريقة main.

استنتاج:

فهم تفاعل الشيفرة يعتمد على فهم تفاصيل اللغة والمفاهيم المتعلقة بها. Java تعتبر لغة قائمة على الكائنات وتتميز بسلوك معين عند تحميل الفئات وتنفيذ الكود الثابت والدينامي. بفهم هذه المفاهيم، يمكن للمطور تحسين تصميمه وفهم سبب تنفيذ الشيفرة بالطريقة التي تمت.