import java.util.Scanner;

public class wo {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

  
        System.out.print("أدخل عدد الصفوف: ");
        int rows = in.nextInt();
        System.out.print("أدخل عدد الأعمدة: ");
        int cols = in.nextInt();


        int[][] matrix = new int[rows][cols];


        System.out.println("أدخل عناصر المصفوفة:");
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print("أدخل العنصر في الصف " + (i + 1) + " والعمود " + (j + 1) + ": ");
                matrix[i][j] = in.nextInt();
            }
        }


        wo(matrix);
        in.close();
    }

    private static void wo(int[][] matrix) {
        boolean b = true;
        Scanner in = new Scanner(System.in);
        while (b) {
            printd2(matrix);
            System.out.println("اختر الجزء:");
            System.out.println("1. الجزء العلوي");
            System.out.println("2. الجزء السفلي");
            System.out.println("3. العودة إلى القائمة الرئيسية");

            int partChoice = in.nextInt();

            if (partChoice == 3) {
                b = false;
                continue;
            }


            int startRow, endRow;
            if (partChoice == 1) {
                startRow = 0;
                endRow = (matrix.length + 1) / 2;
            } else if (partChoice == 2) {
                startRow = matrix.length / 2;
                endRow = matrix.length;
            } else {
                System.out.println("اختر عددًا صحيحًا بين 1 و 3.");
                continue;
            }

            while (true) {
                printd2Range(matrix, startRow, endRow);
                System.out.println("اختر عملية:");
                System.out.println("1. sum");
                System.out.println("2. avg");
                System.out.println("3. max");
                System.out.println("4. min");
                System.out.println("5. reverse");
                System.out.println("6. العودة إلى القائمة الرئيسية");

                int operation = in.nextInt();

                switch (operation) {
                    case 1:
                        System.out.println("sum = " + sumRange(matrix, startRow, endRow));
                        break;
                    case 2:
                        System.out.println("avg = " + averageRange(matrix, startRow, endRow));
                        break;
                    case 3:
                        System.out.println("max = " + maxRange(matrix, startRow, endRow));
                        break;
                    case 4:
                        System.out.println("min = " + minRange(matrix, startRow, endRow));
                        break;
                    case 5:
                        reverseMatrixRange(matrix, startRow, endRow);
                        break;
                    case 6:
                        b = false;
                        break;
                    default:
                        System.out.println("اختر عددًا بين 1 و 6.");
                }
            }
        }
    }

    private static void printd2(int[][] matrix) {
        System.out.println("المصفوفة الثنائية الأبعاد:");
        for (int[] row : matrix) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }

    private static void printd2Range(int[][] matrix, int startRow, int endRow) {
        System.out.println("الجزء المحدد من المصفوفة الثنائية الأبعاد:");
        for (int i = startRow; i < endRow; i++) {
            for (int num : matrix[i]) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }

    private static int sumRange(int[][] matrix, int startRow, int endRow) {
        int total = 0;
        for (int i = startRow; i < endRow; i++) {
            total += sum(matrix[i]);
        }
        return total;
    }

private static double averageRange(int[][] matrix, int startRow, int endRow) {
        return (double) sumRange(matrix, startRow, endRow) / ((endRow - startRow) * matrix[0].length);
    }

    private static int maxRange(int[][] matrix, int startRow, int endRow) {

        int max = matrix[startRow][0];
        for (int i = startRow; i < endRow; i++) {
            for (int num : matrix[i]) {
                if (num > max) {
                    max = num;
                }
            }
        }
        return max;
    }

    private static int minRange(int[][] matrix, int startRow, int endRow) {
        
        int min = matrix[startRow][0];
        for (int i = startRow; i < endRow; i++) {
            for (int num : matrix[i]) {
                if (num < min) {
                    min = num;
                }
            }
        }
        return min;
    }

    private static void reverseMatrixRange(int[][] matrix, int startRow, int endRow) {
        for (int i = startRow; i < endRow; i++) {
            reverseArray(matrix[i]);
        }
        System.out.println("المصفوفة بعد عكس الجزء المحدد:");
        printd2Range(matrix, startRow, endRow);
    }

    private static void reverseArray(int[] array) {
        int n = array.length;
        for (int i = 0; i < n / 2; i++) {
            int temp = array[i];
            array[i] = array[n - i - 1];
            array[n - i - 1] = temp;
        }
    }

    private static int sum(int[] array) {
        int total = 0;
        for (int num : array) {
            total += num;
        }
        return total;
    }
}

سؤال المختبر القادم للهياكل /علوم صباحي
//
اكتب برنامج يقرء مصفوفه احاديه ومصفوفة ثنائيه ومصفوفه ثلاثيه ثم يطلب من المستخدم اختيار نوع المصفوفه ووحجم المصفوفه وعناصر المجموعه ثم طباعتها واجراء 5 عمليات عليها ويبقى يطلب من المستخدم اجراء عمليات لحين طلب المستخدم الخروج من العمليات

import java.util.Scanner;

public class hmd {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        boolean exit = false;

        while (!exit) {
            System.out.println("اختر نوع المصفوفة: 1. أحادية 2. ثنائية 3. ثلاثية 4. خروج");
            int choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    
                    System.out.println("أدخل عدد العناصر في المصفوفة الأحادية:");
                    int size = scanner.nextInt();
                    int[] array = new int[size];
                    System.out.println("أدخل العناصر:");
                    for (int i = 0; i < size; i++) {
                        array[i] = scanner.nextInt();
                    }
                    printArray(array);
                    arrayD1(array);
                    break;

                case 2:
                    
                    System.out.println("أدخل عدد الصفوف:");
                    int rows = scanner.nextInt();
                    System.out.println("أدخل عدد الأعمدة:");
                    int cols = scanner.nextInt();
                    int[][] matrix = new int[rows][cols];
                    System.out.println("أدخل العناصر:");
                    for (int i = 0; i < rows; i++) {
                        for (int j = 0; j < cols; j++) {
                            matrix[i][j] = scanner.nextInt();
                        }
                    }
                    printArray(matrix);
                    arrayD2(matrix);
                    break;

                case 3:
                 
                    System.out.println("أدخل عدد الطبقات:");
                    int layers = scanner.nextInt();
                    System.out.println("أدخل عدد الصفوف:");
                    int threesRows = scanner.nextInt();
                    System.out.println("أدخل عدد الأعمدة:");
                    int threesCols = scanner.nextInt();
                    int[][][] threeDMatrix = new int[layers][threesRows][threesCols];
                    System.out.println("أدخل العناصر:");
                    for (int i = 0; i < layers; i++) {
                        for (int j = 0; j < threesRows; j++) {
                            for (int k = 0; k < threesCols; k++) {
                                threeDMatrix[i][j][k] = scanner.nextInt();
                            }
                        }
                    }
                    printArray(threeDMatrix);
                    arrayD3(threeDMatrix);
                    break;

                case 4:
                    exit = true;
                    System.out.println("تم الخروج من البرنامج.");
                    break;

                default:
                    System.out.println("اختيار غير صالح.");
            }
        }

        scanner.close();
    }

    // العمليات على المصفوفة الأحادية
    private static void arrayD1(int[] array) {
        boolean backToMenu = false;
        while (!backToMenu) {
            printArray(array);
            System.out.println("اختر عملية:");
            System.out.println("1. حساب مجموع العناصر");
            System.out.println("2. حساب متوسط العناصر");
            System.out.println("3. العثور على أكبر عنصر");
            System.out.println("4. العثور على أصغر عنصر");
            System.out.println("5. عكس المصفوفة");
            System.out.println("6. العودة إلى القائمة الرئيسية");

            int operation = new Scanner(System.in).nextInt();
            switch (operation) {
                case 1:
                    System.out.println("مجموع العناصر: " + sum(array));
                    break;
                case 2:
                    System.out.println("متوسط العناصر: " + average(array));

break;
                case 3:
                    System.out.println("أكبر عنصر: " + max(array));
                    break;
                case 4:
                    System.out.println("أصغر عنصر: " + min(array));
                    break;
                case 5:
                    reverseArray(array);
                    break;
                case 6:
                    backToMenu = true;
                    break;
                default:
                    System.out.println("اختيار غير صالح!");
            }
        }
    }

    // العمليات على المصفوفة الثنائية
    private static void arrayD2(int[][] matrix) {
        boolean backToMenu = false;
        while (!backToMenu) {
            printArray(matrix);
            System.out.println("اختر عملية:");
            System.out.println("1. حساب مجموع العناصر");
            System.out.println("2. حساب متوسط العناصر");
            System.out.println("3. العثور على أكبر عنصر");
            System.out.println("4. العثور على أصغر عنصر");
            System.out.println("5. عكس المصفوفة");
            System.out.println("6. العودة إلى القائمة الرئيسية");

            int operation = new Scanner(System.in).nextInt();
            switch (operation) {
                case 1:
                    System.out.println("مجموع العناصر: " + sum(matrix));
                    break;
                case 2:
                    System.out.println("متوسط العناصر: " + average(matrix));
                    break;
                case 3:
                    System.out.println("أكبر عنصر: " + max(matrix));
                    break;
                case 4:
                    System.out.println("أصغر عنصر: " + min(matrix));
                    break;
                case 5:
                    reverseMatrix(matrix);
                    break;
                case 6:
                    backToMenu = true;
                    break;
                default:
                    System.out.println("اختيار غير صالح!");
            }
        }
    }

    // العمليات على المصفوفة الثلاثية
    private static void arrayD3(int[][][] matrix) {
        boolean backToMenu = false;
        while (!backToMenu) {
            printArray(matrix);
            System.out.println("اختر عملية:");
            System.out.println("1. حساب مجموع العناصر");
            System.out.println("2. حساب متوسط العناصر");
            System.out.println("3. العثور على أكبر عنصر");
            System.out.println("4. العثور على أصغر عنصر");
            System.out.println("5. عكس المصفوفة");
            System.out.println("6. العودة إلى القائمة الرئيسية");

            int operation = new Scanner(System.in).nextInt();
            switch (operation) {
                case 1:
                    System.out.println("مجموع العناصر: " + sum(matrix));
                    break;
                case 2:
                    System.out.println("متوسط العناصر: " + average(matrix));
                    break;
                case 3:
                    System.out.println("أكبر عنصر: " + max(matrix));
                    break;
                case 4:
                    System.out.println("أصغر عنصر: " + min(matrix));
                    break;
                case 5:
                    reverseMatrix(matrix);
                    break;
                case 6:
                    backToMenu = true;
                    break;
                default:
                    System.out.println("اختيار غير صالح!");
            }
        }
    }

    private static int sum(int[] array) {
        int total = 0;
        for (int i : array) total += i;
        return total;
    }

    private static double average(int[] array) {
        return (double) sum(array) / array.length;
    }

    private static int max(int[] array) {
        int max = array[0];
        for (int i : array) if (i > max) max = i;
        return max;
    }

    private static int min(int[] array) {
        int min = array[0];
        for (int i : array) if (i < min) min = i;
        return min;
    }

private static int sum(int[][] matrix) {
        int total = 0;
        for (int[] row : matrix) total += sum(row);
        return total;
    }

    private static double average(int[][] matrix) {
        return (double) sum(matrix) / (matrix.length * matrix[0].length);
    }

    private static int max(int[][] matrix) {
        int max = matrix[0][0];
        for (int[] row : matrix) for (int i : row) if (i > max) max = i;
        return max;
    }

    private static int min(int[][] matrix) {
        int min = matrix[0][0];
        for (int[] row : matrix) for (int i : row) if (i < min) min = i;
        return min;
    }

    private static int sum(int[][][] matrix) {
        int total = 0;
        for (int[][] layer : matrix) total += sum(layer);
        return total;
    }

    private static double average(int[][][] matrix) {
        return (double) sum(matrix) / (matrix.length * matrix[0].length * matrix[0][0].length);
    }

    private static int max(int[][][] matrix) {
        int max = matrix[0][0][0];
        for (int[][] layer : matrix) for (int[] row : layer) for (int i : row) if (i > max) max = i;
        return max;
    }

    private static int min(int[][][] matrix) {
        int min = matrix[0][0][0];
        for (int[][] layer : matrix) for (int[] row : layer) for (int i : row) if (i < min) min = i;
        return min;
    }

    private static void reverseArray(int[] array) {
        int n = array.length;
        for (int i = 0; i < n / 2; i++) {
            int temp = array[i];
            array[i] = array[n - i - 1];
            array[n - i - 1] = temp;
        }
        printArray(array);
    }

    private static void reverseMatrix(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            reverseArray(matrix[i]);
        }
        System.out.println("المصفوفة الثنائية بعد العكس:");
        printArray(matrix);
    }

    private static void reverseMatrix(int[][][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            reverseMatrix(matrix[i]);
        }
        System.out.println("المصفوفة الثلاثية بعد العكس:");
        printArray(matrix);
    }

    private static void printArray(int[] array) {
        System.out.println("عناصر المصفوفة الأحادية:");
        for (int i : array) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    private static void printArray(int[][] matrix) {
        System.out.println("عناصر المصفوفة الثنائية:");
        for (int[] row : matrix) {
            for (int j : row) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
    }

    private static void printArray(int[][][] matrix) {
        System.out.println("عناصر المصفوفة الثلاثية:");
        for (int[][] layer : matrix) {
            for (int[] row : layer) {
                for (int i : row) {
                    System.out.print(i + " ");
                }
                System.out.println();
            }
            System.out.println("---");
        }
    }
}

الحل

OOP

.
.

Method Overloading

.
.

تعدد (Overloading) هو ميزة في البرمجة تسمح بتعريف عدة دوال (Methods) أو بنائين (Constructors) بنفس الاسم ولكن بمعاملات مختلفة. بمعنى آخر، يمكن إنشاء دوال بنفس الاسم طالما كانت تملك عددًا مختلفًا من المعاملات أو أنواعًا مختلفة لها. يُحدد أي دالة سيتم استدعاؤها أثناء التنفيذ بناءً على نوع وعدد المعاملات المقدمة

public class MathOperations {
    // دالة لإضافة عددين صحيحين
    public int add(int a, int b) {
        return a + b;
    }

    // دالة لإضافة ثلاثة أعداد صحيحة
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // دالة لإضافة عددين عشريين
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        MathOperations math = new MathOperations();
        
        System.out.println("مجموع عددين صحيحين: " + math.add(5, 10));          // الناتج: 15
        System.out.println("مجموع ثلاثة أعداد صحيحة: " + math.add(5, 10, 15)); // الناتج: 30
        System.out.println("مجموع عددين عشريين: " + math.add(5.5, 10.5));      // الناتج: 16.0
    }
}

فوائد تعدد التحميل
- تسهيل قراءة الكود: حيث يمكن استخدام نفس الاسم للدوال المتشابهة في الوظيفة ولكن مع اختلاف المدخلات.
- إعادة الاستخدام: يسمح بتعريف طرق متعددة لاستخدام نفس الاسم بطريقة تسهل على المطور إعادة استخدام الكود في أماكن مختلفة.

##مثال على تعدد تحميل البنائين (Constructors)

public class Person {
    String name;
    int age;

    // البناء الافتراضي
    public Person() {
        this.name = "غير معروف";
        this.age = 0;
    }

    // البناء بمعامل واحد (الاسم)
    public Person(String name) {
        this.name = name;
        this.age = 0;
    }

    // البناء بمعاملين (الاسم والعمر)
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("الاسم: " + name + ", العمر: " + age);
    }

    public static void main(String[] args) {
        Person person1 = new Person();                  // استدعاء البناء الافتراضي
        Person person2 = new Person("علي");             // استدعاء البناء بمعامل واحد
        Person person3 = new Person("مريم", 25);       // استدعاء البناء بمعاملين

        person1.display(); // الاسم: غير معروف، العمر: 0
        person2.display(); // الاسم: علي، العمر: 0
        person3.display(); // الاسم: مريم، العمر: 25
    }
}

في هذا المثال:
- تم تعريف ثلاثة بنائين لفئة Person:
- البناء الأول بدون معاملات (الافتراضي)، ويقوم بتعيين القيم الافتراضية للاسم والعمر.
- البناء الثاني يأخذ معاملًا واحدًا (الاسم)، ويضبط العمر كـ 0 افتراضيًا.
- البناء الثالث يأخذ معاملين (الاسم والعمر) ويضبطهما.

بهذه الطريقة، يمكن إنشاء كائنات من Person بطرق متعددة بناءً على المعلومات المتوفرة.

إمثلة إضافية

1-دالة لحساب المساحة بأشكال متعددة

public class AreaCalculator {

    // دالة لحساب مساحة المستطيل (الطول × العرض)
    public int calculateArea(int length, int width) {
        return length * width;
    }

    // دالة لحساب مساحة المربع (الضلع × الضلع)
    public int calculateArea(int side) {
        return side * side;
    }

    // دالة لحساب مساحة الدائرة (π × نصف القطر²)
    public double calculateArea(double radius) {
        return Math.PI * radius * radius;
    }

    public static void main(String[] args) {
        AreaCalculator calculator = new AreaCalculator();

        System.out.println("مساحة المستطيل: " + calculator.calculateArea(10, 5));       // الناتج: 50
        System.out.println("مساحة المربع: " + calculator.calculateArea(7));             // الناتج: 49
        System.out.println("مساحة الدائرة: " + calculator.calculateArea(3.5));          // الناتج: 38.48451000647496
    }
}

هنا لدينا ثلاث دوال بنفس الاسم calculateArea:
- الدالة الأولى تحسب مساحة المستطيل باستخدام الطول والعرض.
- الدالة الثانية تحسب مساحة المربع باستخدام طول الضلع.
- الدالة الثالثة تحسب مساحة الدائرة باستخدام نصف القطر، مع الأخذ في الاعتبار أن قيمة نصف القطر من النوع

2- دالة لحساب مجموع أعداد صحيحة ومصفوفات

public class SumCalculator {

    // دالة لحساب مجموع عددين صحيحين
    public int sum(int a, int b) {
        return a + b;
    }

    // دالة لحساب مجموع ثلاثة أعداد صحيحة
    public int sum(int a, int b, int c) {
        return a + b + c;
    }

    // دالة لحساب مجموع العناصر في مصفوفة
    public int sum(int[] numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    public static void main(String[] args) {
        SumCalculator calculator = new SumCalculator();

        System.out.println("مجموع عددين: " + calculator.sum(10, 20));          // الناتج: 30
        System.out.println("مجموع ثلاثة أعداد: " + calculator.sum(10, 20, 30)); // الناتج: 60
        System.out.println("مجموع مصفوفة: " + calculator.sum(new int[]{1, 2, 3, 4, 5})); // الناتج: 15
    }
}

هنا لدينا ثلاث دوال

3- دالة للعثور على أكبر قيمة بين رقمين أو ثلاثة أرقام

public class MaxFinder {

    // دالة لإيجاد القيمة الكبرى بين عددين صحيحين
    public int max(int a, int b) {
        return (a > b) ? a : b;
    }

    // دالة لإيجاد القيمة الكبرى بين ثلاثة أعداد صحيحة
    public int max(int a, int b, int c) {
        return max(max(a, b), c);
    }

    // دالة لإيجاد القيمة الكبرى بين عددين عشريين
    public double max(double a, double b) {
        return (a > b) ? a : b;
    }

    public static void main(String[] args) {
        MaxFinder finder = new MaxFinder();

        System.out.println("القيمة الكبرى بين 5 و 10: " + finder.max(5, 10));            // الناتج: 10
        System.out.println("القيمة الكبرى بين 5 و 10 و 15: " + finder.max(5, 10, 15));    // الناتج: 15
        System.out.println("القيمة الكبرى بين 7.5 و 2.3: " + finder.max(7.5, 2.3));       // الناتج: 7.5
    }
}

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

Constructor

ما هو Constructor؟
الـ Constructor هو دالة خاصة تُستخدم لتهيئة (initialize) الكائنات (objects) عند إنشائها. يتم استدعاؤه عند إنشاء كائن جديد باستخدام الكلمة المفتاحية new. وظيفة الـ Constructor الأساسية هي تعيين القيم الأولية لأعضاء البيانات (attributes) في الكائن.

خصائص Constructor:
نفس اسم الصف (Class): يجب أن يكون اسم الـ Constructor هو نفس اسم الصف الذي يتم تعريفه بداخله.
لا يوجد نوع إرجاع (Return Type): لا يحتوي الـ Constructor على نوع إرجاع حتى void.
يُستدعى مرة واحدة فقط عند إنشاء الكائن.
أنواع Constructors:
Constructor الافتراضي (Default Constructor):

هو Constructor بدون معلمات، يتم إنشاؤه تلقائيًا إذا لم يتم تعريف أي Constructor في الصف. يعطي قيمًا افتراضية للبيانات مثل 0 أو null

محمد الدسوقي

عادل نسيم