ملخص مفاهيم :

مقدمة :
. بدايتا نفس ما نعرف كلنا ان البرمجة هي وسيلة وصفية لأعطاء أوامر الى الحاسوب وهذه الأوامر لها نسق منطقي وهدف هذا النسق المرتب بطريقة متسلسلة هو حل مشكلة برمجية او واقعية وبالتالي نكدر نكول ان البرمجة هي اداة لا غير والأعتماد الكلي هو على فهم منطقية هذه الأوامر من دون حفظ! ,

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

————————————
البرمجة الهيكلية والكيانية التوجه :

1)
وهذا الشيء ينقلنا الى نسق برمجي قد تلعمناه في المرحلة الأولى وهو البرمجة الهيكلية او بسمى اخر :
Procedural Programming or Procedural Oriented Programming ( POP )

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

2)
والنسق الأخر والذي نستعمله في ترتيب الكود هو البرمجية الكائنية او بمسمى اخر :
Object Oriented Programming ( OOP )

ونكدر نكول بهذا النسق الجديد كدرنا ان نوسع افاقنا كمبرمجين بجعل الكود اكثر واقعية وتقريب البرمجة من الواقع بمفاهيمها ولكن تضل الثلاث شغلات نفسها ( اداخل , معالجة , اخراج ) مع اختلاف اسلوب ترتيب وتنسيق الكود بطريقة متسلسلة ,

ويتمحور هذا الأسلوب البرمجي حول كيف ادارة البيانات وكيف انشاء نسق لسلوك معين لشيء واقعي ان كان حركة او وظيفة معينة ,

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

فبأختصار الكيان = وظائف + بيانات
وهو يعتبر مفهوم لا غير وهو يعتبر بوابة لفهم البرمجة الكيانية واسلوب استخدام الكود لحل مشكلة معينه
————————————

اهم الفروقات بين البرمجة الهيكلية والبرمجة الكيانية :

بالمختصر بالهيكلية :
- نستخدم الدوال فقط تمرير واستقبال البيانات
- اسلوب غير امن لان لا توجد طريقة مناسبة لأخفاء البينات
- ما نكدر نسوي overloading :
التالي لازم ألتزم بنوع البياني للمرسل والمستقبل حتى ما يصير عندي خسارة بالبينات او حتى ما يصير عندي ايرور


بالمختصر بالكيانية :
- نستخدم وصف كيان عندما ننشئ حقل من البياتات ( كائن )
- نستخدم تعليمات طرق الوصول لتحديد مَن يمكن له ان يصل لبينات هذا الكائن او دوال هذا الكائن ( داخل الكلاس )
- عندما ننشئ كيان جديد ونرسل وسائط او argument من هذا الكائن يجب ان يكون هناك مكان لأستقبال هذه الوسائط كمعلمات من نفس اسم الكلاس او الفئة
بمعنى عدنا هنا دالة خاصة للكائن موجودة داخل الكلاس نسميها constructor
- نكدر نسوي overloading :
وهذا الشكل اتاحلنا مرونه بعدم الألتازم بنوع البياني للدالة المستقبلة او معالم الدالة المستقبلة وبهذا الشكل ما نخسر بينات ونسوي دالة واحدة تستقبل مختلف السيناريوهات المرسلة والمسقبِلة

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

نكدر نسمي object بـ instance اي حالة , ( حالة من الكلاس )
وايضا نكدر نسمي Object بـ :
Reference variables or Object references)
نكدر نسمي behaviors بـ properties اي خصائص ( دوال و متغيرات ) وايضا نكدر نسميهم بـ instance Variables متغيرات الحالة , لان الكيان هو حالة من الكلاس اي نسخة من الكلاس
وهمين نكدر نسمي class بـ characteristics

اساسيات مبادئ البرمجة الكائنية :

- Class and object الكيان والصف ( اخذناها )
- Inheritance الوراثة ( بعدنا ما وصلنالها )
- Abstraction التجريد
- Polymorphism تعدد الأشكال
- Encapsulation التغليف

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

خلاصة الحجي :
Class = Structure + behaviors
=> Structure = نمط او هيكل كتابي برمجي يتسم به فقط هو الكلاس
=> behaviors = properties = attributes ( member ) + method

مثال :
class Student {
int S1 = 10;
}

فالمتغير الموجود داخل الكلاس S1 راح نسميه Instance variables or memebr المتغير التابع للكائن او العضو التابع للكائن
والقيمة 10 تمثل بيانات الكائن او بيانات العضو Data member

وبشكل عام نكدر نكول ان :( int S1 = 10 ) ككل نكدر سميها Data Fields او حقل البيانات

خلاصة الحجي :
اذا ردنا نسوي كائن لازم نسوي قالب لهذا الكائن وهو الصف
ويحتوي داخل هذا القالب متغيرات ودوال تابعة للصف وبدوره الصف تابع الى الكائن

ملاحظة : اي دالة نسويها داخل Class راح نسميها الدالة التابعة الى الصف Class method
——-
- Polymorphism : تعدد الأشكال
بكل اختصال عندما نستعمل Overloading او التحميل الزائد للدوال راح نحصل على نفس الدوال ولكن بأشكال مختلفة لهذا السبب نطلق عليها تعدد الأشكال

——-

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

خلاصة خلاصة الخلاصة :
الكلاس بحد ذاته هو قالب أو مخطط، بينما الكائن هو التمثيل الحقيقي الذي يُنشأ بناءً على هذا القالب , بمعنى :
الكلاس : هو التصميم النظري أو الهيكل الذي يحتوي على تعريف للخصائص (attributes) والسلوكيات (methods).
الكائن : هو تطبيق عملي لهذا التصميم. بمجرد إنشاء كائن من كلاس، يصبح هذا الكائن قادرًا على تخزين بيانات فريدة به واستخدام السلوكيات المحددة في الكلاس.

مثال لتوضيح الفكرة :
تخيل أن الكلاس هو مخطط لتصميم سيارة:

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

وبالتالي نستنتج من نسوي كيان من نوع الكلاس كأن جاي نسوي نوع بياني خاص بينه لهذا السبب يسمونه user defined data type اي المستخدم الذي يبرمج او المبرمج هو الذي يصنعهُ ,

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

Class components : مكونات الصف
بأختصار نكدر نخلي داخل القالب او الكلاس ثلاث اشياء فقط وهم :
1- Memebrs
2- methods
3- constructors
————————————

هسه عرفنه ان الكيان يعتبر user defined data type

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

Access Modifiers for members : طرق الوصل الى الأعضاء

1- Private : خاص
بمعنى لو خليت Private الى العضو فبداخل الكلاس نكدر نوصله بس لو ردت أوصله من خلال الكائن ما راح أكدر
2- Public : عام
لو خليت Public الى العضو بداخل الكلاس نكدر نوصله والكائن يكدر يوصله واذا ردت اسوي حزمه واضع فيها الكود يكدرون يوصلوله وخارج الحزمة همين يكدرون يوصلوله يعني تاايه وما يدري وين الله حاطة
3- Default : الشيء الأفتراضي
هاي اذا اصلا ما خلينه كلشي للعضو بداخل الكلاس فهو افتراضيا او معيارياً دائما راح يكون Default فنكدر نوصله من داخل الكلاس ويكدر الكائن يوصله

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

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

Class Area {
  private int Bass = 10;
  private int Hight = 20

  public getPrivateBase( ) {
  return Base;
  }

  public getPrivateHight( ) { 
  return Hight;
  }
}

————————————
Methods Overloading : التحميل الزائد للدوال
هي مجموعة من الدوال يكونون بنفس الأسم ولكن الشيء المختلف بينهم هو النوع البياني للدالة والأنواع البيانية لـ Parameters وترتيب Parameters
مع ملاحظة يجب ان نكتب هذه الدوال فقط داخل الكلاس التابع للكائن ولا يصح ان نكتبها فوق الدالة الرئيسية اي داخل الكلاس الرئيسي
مثال// اكتب

class clSum
{
    public int SumTowNumbers(int Number1,int Number2)
    {
        return Number1 + Number2;
    }

    public double SumTowNumbers(double Number1, double Number2)
    {
        return Number1 + Number2;
    }

    public double SumTowNumbers(double Number1, int Number2)
    {
        return Number1 + Number2;
    }

    public double SumTowNumbers(int Number1, double Number2)
    {
        return Number1 + Number2;
    }

}
public class Main
{

    public static void main(String[] args)
    {
        clSum Sum = new clSum();

        System.out.println("1) Sum = " + Sum.SumTowNumbers(1,1)); // 2
        System.out.println("2) Sum = " + Sum.SumTowNumbers(1.3,1)); // 2.3
        System.out.println("3) Sum = " + Sum.SumTowNumbers(1,1.5)); // 2.5
        System.out.println("4) Sum = " + Sum.SumTowNumbers(2.2,3.3)); // 5.5

    }

}

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

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

Constructor method : الدالة المنشئة او البنائات

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

الان هل هناك بعد فيزيائي او تأثير على ذاكرة RAM من نسوي كيان و كونستركتر؟
الجواب نعم , فمن نسوي كيان اساسا راح نحجز في ذاكرة RAM مكان في Heap و pool Memory

حقيقة :
كل مرة نسوي كلاس ونسوي كيان تابع للكلاس فنهاك على الأقل اكو Constructor من نوع Default Constructor
يعني اول ما نسوي الكلاس والكيان فاكو كونستركتر بس مخفي من اللغة وظيفته فقط تهيئة members بقيم افتراضية فهو المسؤال اذا عرفنه متغير وما خليناله قيمه وطبعناه يطلع عندي قيمة افتراضية ألة في جافا فقط طبعا .

يعتبر الكونستركتر دالة ليس لها نوع بياني وبالتالي ما نكتب return الها ولا هي void , بس نكدر تحدد طريقة الوصول ألها , حيث أنها تكون بنفس أسم الكلاس
حتى تكون الصورة واضحة من نسوي كلاس و نسوي كيان فأحنه هنا بالحقيقة سوينه كونستركتر
مثال :
Scanner object = new Scanner( System.in );
فهذا الجزء راح نسميه كونستركتر Scanner( System.in ) والقيمة الذي يرسلها System.in تعتبر وسائط او argument تمام؟
————————————

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 او القوائم المترابطة او خلي نسويها العُقد المترابطة

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

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

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

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