خلاصة 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 اكدر أعرف ان هذه العقدة هي العقدة الأولى فهنا عرفنه نقطة الأنطلاق للعقد المترابطة وهذا امر كلش مهم نسويه , أحنه نكدر نسوي عقد مترابطة بس المشكلة لو سوينها ما اعرف نقطة بداية العقد لان ما حددناها وهذا الشي يؤدي الى انو ما أكدر أجري عمليات للعقد مثل التنقل و الأضافة و الحذف و الترتيب ايضا فلهذا السبب لازم احدد نقطة البداية والتي هي العقدة الأولى .

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

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

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

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

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

اهم دالة لازم نسويها هي
دالة انشاء عقدة متسلسلة وراح تكون الدالة من نوع void وسبب انو void لان ما عندي شي ارجعه لان راح يكون اكثر تعاملي مع المؤشرات لكل عقدة وكيف ربطهم مع بعض :

الكلاس الأول :

class clNode
{
    int Data;
    clNode Next;
    
}

الكلاس الثاني :

class SingleLinledList
{
    clNode Head;

    public void add(int DataFromMain)
    {
        clNode n = new clNode();
        n.Data = DataFromMain;

        if(Head == null)
        {
            Head = n;
            //System.out.println("Head Address: " + Head);
            //System.out.println("Node Address: " + n);
            // اخذنا عنوان أول عقدة وخزناها في Head

        }
        else
        {
            clNode P = Head;

            while (P.Next != null)
            {
                P = P.Next;
            }
            P.Next = n;
            //System.out.println(P.Next);
        }
    }

- لاحظ Head صاير بنفس اسم الكلاس العقد clNode فبتالي Head مو اتفقنا يعتبر مؤشر , وبما انو هو من نفس نوع الكلاس يعني من الاخير كائن واحنه اتفقنى في شرح البرمجة الكيانية , الكائن يكدر يوصل لأي متغير موجود داخل الكلاس التابع له الكائن عن طريق ( . ) Head.Data , Head.Next , فخلاصة الحجي اي كائن اسويه من نفس اسم الكلاس فهذا الكائن يكدر يوصل الى المتغيرات الموجودة داخل الكلاس التابع له الكائن ,

الكلاس الأخير هو الكلاس الرئيسي وفي الدالة الرئيسية راح نرسل البينات الى public void add(int DataFromMain)
شلون؟
بكل بساطة لازم نسوي كائن تابع الى كلاس SingleLinledList وهذا يعني ان هذا الكائن يكدر يوصل الى متغيرات الكلاس ( Memebr and Data Memebr ) ألي هو هنا Head
وايضا يكدر يوصل الى دوال هذا الكلاس ومن الدالة الرئيسية نرسل وسائط الى الدالة المجودة في الكلاس عن طريق الكائن بهذا الشكل :

public class Main
{
    public static void main(String[] args)
    {
        SingleLinledList SLL = new SingleLinledList();

        SLL.add(1);
        SLL.add(2);
        SLL.add(3);
        SLL.add(4);
        SLL.add(5);

    }
}

فنفس ما نعرف اول ما يجي المترجي يبدي من الكلاس الرئيسي ثم يدخل الى الدالة الرئيسية ومن ثم راح يكله هذا السطر :
SingleLinledList SLL = new SingleLinledList(); ونعرف هذا السطر معناه سويلي كائن تابع الى الكلاس
فراح يدخل الى الكلاس SingleLinledList يقراء الموجود داخل الكلاس راح يلكه عندي Head وراح يلكه عندي دالة أسمها add من نوع void بس ما راح يدخل للدالة تمام؟

فبعد ما يطلع من الكلاس ويرجع الى الدالة الرئيسية وتحديدا هذا السطر SingleLinledList SLL = new SingleLinledList();
فراح SLL ألي هو الكائن مالتنا صار وعاء داخله المتغيرات والدوال الموجودة في الكلاس التابع للكائن , فبتالي صار من عمامه 😂 , فيكدر يوصللهم عن طريق ( . )
بمعنى SLL.Head , وايضا SLL.add(1)

الان بعدما كتبنا SLL.add(1) هذا يعني جاي نأمر الحاسوب بأن يدخل الى كلاس الكائن ألي هو SingleLinledList ثم روح الى اسم الدالة الموجودة في هذا الكلاس وبما ان هذه الدالة تستقبل معالم فأحنه راح نرسل القيمة كوسائط argumts الى معالم دالة add ألي مسمينها هنا DataFromMain تمام؟

زين شنو فكرة أني ارسل القيمة الى معالم دالة add ؟
بكل بساطة حتة من اسوي عقدة اخزن في بينات هذه العقدة البينات الي رسلتها من الدالة الرئيسية الى دالة add الموجودة في كلاس SingleLinledList .

الأن بعدما سوينا دالة add وهذه الدالة استقبلت في معالمها القيمة 1 شلون اسوي عقدة واخزن داخل بينات العقدة القيمة 1 ؟
فأحنه مو كلنا العقدة هي كائن؟
خلاص نسوي كائن ونعطيه اسم ولازم يكون من نفس كلاس العقدة بهذا الشكل :

clNode n = new clNode();

شلون نخزن القيمة 1 داخل بيانات العقدة؟

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

n.Data = DataFromMain;

فهنا الكائن n (n اختصار لكلمة Node) , وصل الى المتغير Data ثم اسندنا الى هذا المتغير القيمة 1 الموجودة في DataFromMain .

تمام ,,

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

        clNode n = new clNode();
        n.Data = DataFromMain;

        if(Head == null)
        {
            //System.out.println("Head Address: " + Head);
            //System.out.println("Node Address: " + n);

            Head = n;

            //System.out.println("Head Address = Node Address: " + Head);
            
       // اخذنا عنوان أول عقدة وخزناها في Head

        }