Constructor method v.s Java methods : الفرق بين دوال جافا والدالة المنشئة

Constructor method :

class Example {
    void displayMessage() {
        System.out.println("Method called");
    }
}

public class Main {
    public static void main(String[] args) {
        Example obj = new Example();  // Constructor is called (default in this case)
        obj.displayMessage();  // Method is called
        obj.displayMessage();  // Method is called again
    }
}

Java methods :

class Example {
    void displayMessage() {
        System.out.println("Method called");
    }
}

public class Main {
    public static void main(String[] args) {
        Example obj = new Example();  // Constructor is called (default in this case)
        obj.displayMessage();  // Method is called
        obj.displayMessage();  // Method is called again
    }
}

أي الفرق بينهما ان الكونستركتر اول ما نسوي كائن والمترجم يدخل الى كلاس الكائن وعندما يصل الى الكونستركتر راح يدخل داخل دالة الكونستركتر وينفذي شكو شي موجود طباعة , اسناد , معالجة , والخ.. من دون ما استدعيه من خلال الكائن بأستخدام النقطة ( . )

بينما الدالة الأعتيادية ألي بيها نوع مرجعي و تعليمة الأرجاع return لازم استدعيها حتى اوصل ألها داخل الكلاس تلاحظون الفرق شكد جبير ومفيد!

بالمختصر الكونستركتر ما نستدعيه في الدالة الرئيسية بينما الدالة الأعتيادية نستدعيها في الدالة الرئيسية وشكرا .

Constructor Chaining : الدالة المنشئة المترابطة
بكل بساطة احنه مو سوينا كونستركتر داخل الكلاس مجرد نخلي تعلمية : this ( );
الهدف مِنها استدعاء داخل هذا الكونستركتر , كونستركتر اخر ونكدر نرسل له وسائط argument داخل اقواس this ( ) ويتم استقبالها في معالم الكونستركتر الاخر , فبعد ما نرسل راح المترج
راح يسئل هل هناك كونستركتر له معالم Parameters بنفس النوع البياني للوسائط argument المرسلة؟
اذا فعلا اكو فراح يشتغل بشكل طبيعي ويذهب البرنامج الى الكونستركتر الاخر وينفذ ما كتبناه فيه من اوامر وتعليمات , وخلافا لذالك راح يصير erorr .
ملاحظة : يحقلي استخدم تعلمية this( ) مرة واحدة فقط لكل كونستركتر اذا ما ألتزمنا بيها فراح يطلعلي erorr .

خلاصة الحجي كله : فكرة Constructor Chaining هي كأن جاي نسوي Nested Constructor اي كونستركتر متداخل بس بأستعمال تعليمة this ( )

الفائدة من Channing هو تقليل كتابة الكود المكرر وبهذا الشكل بالمشاريع الضخمة مهم جدا يخلونه بالحسبان .

ويجدر بالذكر ان الكونستركتر المترابط يستعمل في الوراثة وهذا الموضوع بعدنا ما وصلناله في البرمجة الكيانية

مثال يوضح طريقة استعماله :

class clCar
{
   // Default Constructor
   public clCar( ) {
   this ( "Helo world" ); // Constructor Chaining to public clCar(String Text)
   }
   
   // Parameterized Constructor
   public clCar(String Text) {
   System.out.println(Text); 
   }

}

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

class clCar
{

   // Parameterized Constructor
   public clCar(String Text) {
   System.out.println(Text); 
   }

   // Default Constructor
   public clCar( ) {
   this ( "Helo world" ); // Constructor Chaining to public clCar(String Text)
   }
   
}

ملاحظة مهمه جدا :
نكدر نستنتج طريقتين نكدر نوصل من خلالهم الى الكونستركتر داخل الكلاس , يفهم عن طريق هذا الكود :

import java.util.Scanner;

class clEmployee
{
    public clEmployee(String MyName)
    {
        System.out.println("\nMay Name is: " + MyName);
    }

    public clEmployee()
    {
        this("Ali");
        System.out.println("By using Constructor Chaining");
    }

}
public class Main
{

    public static void main(String[] args)
    {
        clEmployee Employee1,Employee2 ;

        Employee1 = new clEmployee();

        System.out.println("\n---------------------");
        Employee2 = new clEmployee("Abdulhamid");
        System.out.println("Using same class but does'nt use Chaining , we use Parameterized Constructor");
    }

}

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

Overloading Constructors : التحميل الزائد للدوال المنشئة
نفس Overloading ألي اخذناها قبل ولطالما الكونستركتر هي دالة خاصة ليس لها نوع بياني للدالة اي user defined data type
فالتلاعب يكمن في :
1- عدد معالم الكونستركتر
2- الأنواع البيانية لمعالم الكونستركتر
3- ترتيب معالم الكونستركتر

مثال :

class clStudent
{
    String name;
    int age;

    // No-argument Constructor
    public clStudent()
    {
        this.name = "Unknown";
        this.age = 0;
    }

    // Parameterized constructor with one parameter
    public clStudent(String name)
    {
        this.name = name;
        this.age = 0;
    }

    // Parameterized constructor with Two parameter
    public clStudent(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    public void display()
    {
        System.out.println("Name: " + name + ", Age: " + age);
    }

}

public class Main
{

    public static void main(String[] args)
    {

        clStudent student1 = new clStudent(); // argument
        clStudent student2 = new clStudent("Ali"); // argument
        clStudent student3 = new clStudent("Mohammed", 20); // argument

        System.out.println();
        student1.display(); // Name: Unknown, Age: 0
        student2.display(); // Name: Ali, Age: 0
        student3.display(); // Name: Mona, Age: 20
    }
}

وخلاصة الموضوع نكدر نسوي اكثر من كونستركتر بمختلف المعالم Parameter وبمختلف نوع Parameter وبمختلف ترتيب Parameter ,
بحيث لو سويت كيان داخل الدالة الرئيسية اكدر ارسل وسائط argument بألي يعجبني من ترتيب ونوع .

خلاصة String :

اول شي شنو هو String ?
بكل بساطة هو مجموعة من الأحرف متصلة مع بعضها البعض

مثل :
"Hello"
وهي بالأصل تكون بهذا الشكل
'h','e','l','l','o'

في معضم لغات البرمجة يكون string نوع بياني والذي يبنى كجزء من اللغة
ولهُ طريقتانِ لانشائه وهما :

1- Null Terminated : المنتهي بالعدم
حيث ان هذا التمثيل يكون بهذا الشكل :

char Src[] = {'h','e','l','l','o','\0 or $'};
ونلاحض في اخر هذه المصفوفة من الأحرف انها تنتهي بـما يسمى null
حيث انه رمز يمثل نهاية هذه السلسة وفائدته حتى يعلم المترجم compiler نهاية السلسة ويتوقف عندما يصل الى هذا الرمز


2- Pointer/Length : المؤشر والطول
حيث ان هذا التمثيل يكون بهذا الشكل :

String Name = "Ail";
حيث ان هنالك مؤشر في هذا التمثيل يؤشر على اول عنصر وهو A
وفي هذا التمثيل طول النص معروف لدى compiler
ويمكننا طباعة طول هذا النص عن طريق كتابة
System.out.print( Name.length() );


خلاصة الخلاصة :
عدنا تمثيلين للنص, التمثيل الأول النص عبارة عن مصفوفة من الأحرف , والثاني النص عبارة عن متغير من نوع نص بالأول ما يعرف المترجم نهاية المصفولة لذا يجب ان يمر بجميع الأحرف الى ان يصل الى \0 او $ حتى يتوقف , الثاني عدنا مؤشر ينضر الى اول حرف وعدنا الطول معلوم لذا يعرف المترجم متى يتوقف من دون ان في كل مرة يتحقق ويسأل وصلنه لو لا الطول معروف بعد ,


خلاصة خلاصة الخلاصة😂 :

Array of characters : char Name[] = { 'A','l','i' };
هنا المترجم ما يعرف طول المصفوفة

String DataType : String Name = "Ali";
هنا المترجم حاط عينه على اول حرف ويعرف طول المصفوفة

الخلاصة الكلية☠️ :
كل مصفوفة تنتهي دائما بnull Terminated (\0 or $ )
وكل متغير نصي طوله معروف وهناك مؤشر يؤشر على اول حرف في هذا النص

____________

زين ماذا يتعبر المتغير النصي في جافا؟؟؟؟
بكل بساطة هو كائن لديه خصائص حيث انهُ يمثل تسلسل من الحروف ,
حيث يمكن انشاء متغير نصي وذالك في طريقتين :

1 - Array of characters :
char Name[] = { 'A','l','i' };
ومن ثم نجمع هذه الحروف بواسطة انشاء كائن يختزن كل حروف المصفوفة داخل نص ثم بعدما اختزنت في نص سوف نسندها الى المتغير النصي ألي هو MyName
String MyName = new String(Name);

2 -String Varible :
String H;
H = "Hello Wolrd";

مصطلاحت عن المتغير النصي وطرق انشائه :

1- String literal :
هو نص محاط بعلامات اقتباس مزدوجة، مثل "Hello".

يتم تخزينه في String Constant Pool، مما يتيح للمترجم إدارة الذاكرة بكفاءة.
شنو هو String constant pool بكل اختصار هو مكان مخصص في الذاكرة لخزين النصوص

كيف يتعامل المترجم مع النصوص؟ راح اشرح فكرتها بهذا الشكل :
تخيل عندك مسبح، وهذا المسبح هو String Constant Pool في Java. حول المسبح توجد اليابسة، وهي منطقة الذاكرة الأوسع التي تُسمى Heap.

الآن، عندنا شخصين:
أحمد ويمثل متغير نصي.
محمد ويمثل متغير نصي آخر.

أحمد ومحمد يريدان السباحة في نفس المسبح، ورغم أن أسماؤهم مختلفة، لكنهم يشتركون في نفس المسبح
في Java، إذا كان لديك متغيرين يحملان نفس النص (مثل "Hello"):
String s1 = "Hello";
String s2 = "Hello";

- المترجم لن يقوم بإنشاء كائنين منفصلين لكل نص.
- بل سيقوم بوضع النص "Hello" في String Constant Pool، ويجعل كل من أحمد ومحمد (أي s1 و s2) يشتركان في نفس الكائن الموجود في المسبح.

بمعنى آخر، حتى لو كانت أسماؤهم مختلفة، فإنهم يستخدمون نفس النص داخل الذاكرة مما يوفر المساحة ويمنع تكرار الكائنات المتطابقة.

خلاصة :
إذا كان لدينا نصوص متطابقة في Java، سيتم تخزينها مرة واحدة فقط في المسبح، وكل المتغيرات التي تحمل نفس القيمة ستشير إلى نفس النص، حتى لو كانت أسماء المتغيرات مختلفة.


خلاصة الخلاصة :
عندما يتم انشاء متغيرات نصية ولهم نفس النص كقيمة كيف سَيتعامل معهم الcompiler?
وذالك عن طريق عدة خطوات :
الأوى :
المترجم يتحقق من المسبح النصي string constant pool في الذاكرة
هل نصوص المتغرات متطابقة؟
اذا كان الجواب بنعم.
فسوف يجعل هذه المتغيرات من النوع النصي والتي تحتوي على نفس النص سَيجعلهم كلهم يشيرون على نص واحد في الذاكرة RAM وذالك عن طريق العنوان address
اذا كان الجواب بِلا
فلن يفعل شيء.

خلاصة خلاصة الخلاصة 😭 :
لفترض سويت متغير نصي وخليت داخله نص
اول شي راح يسويه المترجم يروح يشوف اكو متغير نصي اخر بنفس نص هذا المتغير في البرنامج
اذا ماكو فراح يسوي كيان خاص لهذا المتغير في مسبح النصوص في الذاكرة ويضع بداخله نص هذا المتغير ويكدر يوصل المترجم لهذا النص ويتعامل مع عن طريق الaddress
لنفترض سويت متغير نصي اخر ووضع بداخله نفس النص المتغير الأول شنو راح يصير؟
فراح المترجم يأخذ عنوان او address ويربطه بالمتغير النصي الأخر
ولن ينشئ كان جديد في مسبح النصوص في الذاكرة

زين ليش ما كل مرة من نسوي متغير نصي ما يسوي كائن او حيز جديد في الذاكرة للمتغير الجديد؟
وذالك لجعل الذاكرة اكثر كفائة تخيل معي برنامج مال جوازات كمية الناس المتشابه اسمائهم كل مرة لازم اخلي مكان الهم بالذاكرة وهذا يحتاج سعات ضخمة جدا! وبتالي كفائة اقل لهذا السبب اخترعوا المهندسين والمبرمجين هذه الأفكار حتى نتعامل مع الذاكرة بشكل عقلاني وواقعي ولتقليل الكلفات المادية وزيادة السرعة والأستجابة في الحاسوب

2- new keyword :
يمكننا انشاء متغير نصي بواسطة تعليمة new
والتي تعني يا مترجم انشئ كائن منفصل من نفس النوع المتغير
ويمتاز بأنه لو كان لدينا متغيرين من النوع النصي لهما نصُ متطابق سَيجعل المتغير الأول حيز خاص به في الذاكرة والمتغير الثاني كذالك حيز خاص به في الذاكرة وبالتالي كلاهما لديهِ موقع او address خاص بهِ

مثال :
String Name1 = new String("Ali"); // موقع خاص به
String Name2 = new string("Ali"); // موقع خاص به
___________________

Primitive Type الأنواع البيانية البدائية
مثال :
int x = 5;
int y = 5;
في جميع الأنواع البدائية لو سويت متغيرن لهما نفس القيمة سَيكون كل واحد فيهما موقع خاص به في الذاكرة

___________________

Reference type : الأنواع البيانية المرجعية
مثال :
string x = "Abdulhamid";
string y = "Abdulhamid";

فبتالي y تشبه x في القيمة النصية
فراح المترجم ينطي موقع x الى y وبتالي راح نلكة في الذاكرة فقط نص واحد وهو
Abdulhamid
وليس
Abdulhamid
Abdulhamid

ان شاء الله وصلت الفكرة

واسأل الله تعلى ان يكون ملخصي للملزمة الثالثة في مادة الهياكل قد نال اعجابكم واضاف لكم الفهم الكامل والصورة الكاملة لكيفية التعامل مع المتغيرات وما علاقتها مع الذاكرة بالشكل المنطقي والمادي الفيزيائي

السلام عليكم , خلال هذه المدة اشتغلت على ملخص لمفاهيم متعلقة بشكل مباشر بالبرمجة الكيانية تخص مادة هياكل البينات , وتفصلت في شلون خلانا هذا الأسلوب البرمجي نسوي خوارزمية او بنية هيكلية من القوائم المترابطية أو نفس ما أحنه نعرفها بـ linked List , فشرحت الكود الأساسي ألي من خلاله اذا وصلت الفكرة مالته تكدرون تفهموم جميع التفاصيل المتعلقة بهيكلية البيانات الأساسية :

ملخص مفاهيم :

مقدمة:
كلنا نعرف شنو هي المصفوفة بس كمراجعة تعتبر المصفوفة من اهم الوسائل لتمثيل بيانات وهي اجت لحل مشكلة برمجية وهي تخيل معي اريد اسوي 1000 متغير كلهم من نفس النوع البياني فهذا الشي راح ياخذ 1000 سطر كود وبالتالي راح يكون صعب نتعامل مع المتغيرات الهائلة وصعب جدا نوصللهم حتى نخزن داخلهم قيم وايضا راح ياخذ من عدنا وقت وهذا الشي مو بصالحنا
فما بالك برنامج فيه الاف المتغيرات شلون راح نقلص عددهم بحيث نسوي وعاء او خزان او شكل من خلاله نعبر عن 1000 متغير من نفس النوع في سطر واحد بس
وهنا اجت سالفة المصفوفة وتفرعت الى ان تكون ثنائية وثلاثية والخ من الأبعاد ,

تمام لحد الان؟


ونفس ما كلنا نعرف المصفوفة لها مواقع تبدأ من الموقع الصفري الى حجم المصفوفة - 1
مثال :

int Array[] = new int[3]; // 3 - 1 = 2 هاي تعتبر نهاية موقع المصفوفة

Array[0] = new int(10); // 1
Array[1] = new int(20); // 2
Array[2] = new int(30); // 3

فنستنج من هذا الحجي ان المصفوفة :
1- حجمها ثابت
2- تبدأ من الموقع الصفري وتنتهي الى حجم المصفوفة - 1
3 - لا يوجد ترابط بين جميع مواقعها
4 - لكل موقع عنوان في الذاكرة يمكنا الحاسوب الوصول الى الموقع المطلوب منهُ

--------------------------------------

زين شنو ربط Linked list بالمصفوفات ؟
بكل أريحية مو كلنا المصفوفات أجت عن طريقة مشكلة ثم حلوها وسوو شي نسميه بالمصفوفة
نفس الشي ال Linked list او القوائم المترابطة او خلي نسويها العُقد المترابطة

فمشكلة المصفوفة لو ردت اضيف قيمة تصير في وسط مواقع المصوفة راح تكون عملية جدا جدا معقدة ودائما كمبرمج اذهب الى الطرق الأسلك والأبسط لحل المشكلة ليش اعقدها على نفسي من الأخير؟!
فلهذا السبب أجت العقد المترابطة لتسهل علي كمبرمج الأضفة في وسط عقد مترابطة تلاحضون شي شبيه بالمصوفة بس بشكل مختلف , عنها ولكن المبدأ متشابه تقريا تمام!

----------
زين شلون نكدر نصف او نعرف العقد المترابطة؟
فالعقد المترابطة تعتبر مجموعة من الكائنات المتصلة مع بعضها البعض بشكل متوارث ومتسلسل بطريقة مرتبة

وداخل كلاس العقدة هنالكَ متغيرات او أعضاء , فالمتغيرات الموجودة داخل كلاس العقدة راح تكون متغير لتخزين البيانات ومتغير من نفس نوع الكلاس ,

شنو فائدة نسوي متغير من نفس اسم كلاس؟
فائدتها من يكون عندي عُقد من نفس اسم الكلاس هذا الشي راح يخليلي اتنقل من عقدة الى اخرى وبالتالي من كيان الى اخر وهذا يعني ربط العقد من بعضهم البعض

خلونا نتفق من نسوي متغير من اي نوع بياني فأن له موقع او address في ذاكرة RAM فبتالي انا عندي طريقتين برمجيا من خلالهم اصل الى هذا المتغير

1- عن طريق استدعاء المتغير مباشرتا
مثال:

int Number;
Number = 10; // هنا وصلنا الى المتغير عن طريق استدعائه مباشرتا 

2- عن طريق الوصول الى المتغير بواسطة الكائن
مثال:

class clClass
{
    int Number;

}

public class Main
{
    public static void main(String[] args)
    {
        clClass Object = new clClass();
        Object.Number = 10; // هنا وصلنا الى المتغير بواسطة الكائن 
        
    }

}

وأيضا لازم نتفق عندي نوعين من المتغيرات من ناحية تخزين :
1- متغير يخزن قيمة
2- متغير يخزن عنوان
—
المتغير الذي يخزن قيمة كلنا نعرف الأنواع البيانية int , float , double , ... تخزن قيم لمتغيراتها
بينما الشيء الجديد متغير يخزن موقع address؟ !

فالمتغير الذي يخزن موقع شلون نسويه؟
نكدر نسويه بعد ما نسوي كلاس ونعطي للكلاس اسم ثم داخل الكلاس نكتب اسم الكلاس ونعطي اسم بهذا الشكل:

class clNode
{
   int Data;
   clNode Next;
  // متغير من نوع اسم الكلاس
}

تمام اي العنوان الي اكدر اخزن بيها داخل Next ؟
فنكدر نخزن عنون اي قيمة ( لاحظ عنوان وليس القيمة! ) ,
وبالتالي هذا المتغير اكدر اخزن بيه عنوان اي متغير كذالك له عنوان نكدر نوصله من خلاله .

خلاصة هذا الشرح :
كل متغير له عنوان في الذاكرة سواء كان متغير لتخزين القيم او كان متغي لخزين العناوين

فالمتغير ألي يخزن موقع فقط راح نسميه المؤشر او Pointer وضيفته من ياخذ موقع اي متغير ويخزنه داخله فشنو راح يسوي راح يضل يأشر عليه وهذا يعني من خلال المؤشر اكدر اوصل لهذا المتغير المؤَشر عليه وهذا يعني أننا ربطنا المتغير بالمؤشر واصبح لدي شيء اشبه بالسلسلة المترابطة .
فخلاصة المؤشر : هو متغير يخزن عنوان متغير آخر.

فبعد ما تعرفنا على المؤشر توضحت ألنا الصوة من خلاله راح نربط بين العقد المتجاورة سواء كان عندي Single Linked list او Double Linked List

أنواع العقد الترابطة :
A- Single
1- Single Linked list
2- Circular Single Linked List

B- Double
1- Duble Linked list
2- Circular Double Linked List

—————————————————

A- Single
1- Single Linked list

هذا النوع من العقد المترابطة يتكون من كلاسين , الكلاس الأول نخلي بيه Data من نوع بياني معين ونسوي مؤشر ونسميه Next
كما موضح هنا :

class clNode
{
  int Data;
  clNode Next;
}

والكلاس الثاني هو راح نسوي كل الشغل عليه كما موضح هنا:

class SingleLinkedList 
{
   

}

هسه احنه مو عدنا كلاس بيه البيانات والمؤشر فكل ما يدخل المترجم الى هذا الكلاس راح يسويلي عقدة واذا دخل الى نفس الكلاس ستكون المتغيرات تابعة الى عقدة جديدة وهكذا ,
يعني متغيرات العقدة الأولى لاتسواي متغيرات العقدة الثانية
مثال :

class clNode
{
    int Data;
    clNode Next;

}

public class Main
{
    public static void main(String[] args)
    {
        clNode n1 = new clNode();
        clNode n2 = new clNode;
        
    }

}

خلاصة الكود , اول ما يدخل المترجم الى الكلاس الرئيسي ومن ثم يدخل الى الدالة الرئيسية ومن ثم راح يدخل الى الكيان ni والكيان n1 يمثل العقدة الأولى والكلاس التابع له تحتوي متغيرات تابعه له هو فقط , فبعد ما يطلع من الكلاس راح يدخل الى الكيان n2 ويمثل العقدة الثانية والكلاس التابع له متغيرات جديدة تابعة له فمتغيرات n1 لا تسواي متغيرات n2 .

احد الشغلات الموجودة بكل هيكل متسلسل بأستخدام المؤشرات لربط بين الكائنات او العقد المترابطة هو رأس هذه الكائنات او العقد المترابطة Head فهذا يتعبر مؤشر من خلاله اكدر احدد أول عقدة لتكوين هيكل من العقد المتجاورة و المتسلسلة لازم أبدأ بنقطة بداية فمن خلاله اخلي هذا المؤشر ألي هو Head يأشر على أول عقدة التي تم أنشائها مسبقا اي بمعنى يؤشر على كائن العقدة ( وكائن العقدة له عنوان فبتالي راح يتخزن عنوان كائن العقدة داخل المؤشر Head ) وبالتالي اصبح Head يؤشر على اول عقدة ,
زين هنا يجي سؤال اذا ما خزنا داخل المؤشر موقع هل هناك قيمة أفتراضية وضعوها منشئيي جافا داخل المؤشر؟
فالجواب نعم وهو null

يعني من اسوي كيان واجي اطبع الكيان راح يطبعلي موقع هذا الكيان في الذاكرة

class clClass
{
    int Data;
    clClass Next;

}

public class Main
{
    public static void main(String[] args)
    {
        clClass Object1 = new clClass();
        clClass Object2 = new clClass();

        System.out.println("Object1 = " + Object1);
        // Output : clClass@6acbcfc0

        System.out.println("Object2 = " + Object2);
       // Output : clClass@5b480cf9
        
    }

}

ولهذا السبب من اخلي Head يأشر على أول كأن فهنا جاي اخذ عنوان هذا الكائن واخزنه داخل Head وبالتالي من اخذ عنوان الكائن واخزنه داخل Head هذا يعني من خلال متغير Head اكدر أعرف ان هذه العقدة هي العقدة الأولى فهنا عرفنه نقطة الأنطلاق للعقد المترابطة وهذا امر كلش مهم نسويه , أحنه نكدر نسوي عقد مترابطة بس المشكلة لو سوينها ما اعرف نقطة بداية العقد لان ما حددناها وهذا الشي يؤدي الى انو ما أكدر أجري عمليات للعقد مثل التنقل و الأضافة و الحذف و الترتيب ايضا فلهذا السبب لازم احدد نقطة البداية والتي هي العقدة الأولى .