JavaRush /جاوا بلاگ /Random-UR /جاوا میں جمپ آپریٹرز

سطح

28 February 2021
48 views
0 comments

جاوا میں جمپ آپریٹرز

ہیلو! آج ہم جاوا میں جمپ آپریٹرز کے بارے میں بات کریں گے:

return
break
continue
goto

پہلے، آئیے اس کی وضاحت کرتے ہیں کہ یہ اصل میں کیا ہے۔ جیسا کہ آپ جانتے ہیں، ایک عام صورت حال میں، ایک پروگرام کو لکیری طور پر انجام دیا جاتا ہے - اوپر سے نیچے تک، کمانڈ بذریعہ کمانڈ۔ کسی پروگرام کے لکیری بہاؤ کو نام نہاد کنٹرول ڈھانچے کے ذریعے تبدیل کیا جا سکتا ہے: مثال کے طور پر، شاخیں ( if) اور لوپس ( for، whileوغیرہ)۔ کنٹرول ڈھانچے کے علاوہ، کسی پروگرام کے لکیری عمل کو جمپ بیانات کے ذریعے تبدیل کیا جا سکتا ہے۔ وہ پروگرام کے عمل کو ایک مخصوص مقام پر ری ڈائریکٹ کرنے کے ذمہ دار ہیں، جو سیاق و سباق اور مخصوص بیان پر منحصر ہے۔ جاوا میں جمپ آپریٹرز - 1

آئیے چار آپریٹرز میں سے ہر ایک کو قریب سے دیکھیں۔

واپسی

یہ آپریٹر ہے جس سے نئے آنے والے اکثر پہلے سے واقف ہو جاتے ہیں۔ بیان returnاس طریقہ کو ختم کرتا ہے جس میں اسے بلایا گیا تھا، اور پروگرام پر عمل درآمد اس جگہ پر واپس آجاتا ہے جہاں سے طریقہ بلایا گیا تھا۔ اس returnکی دو صورتیں ہیں:

طریقہ کار پر عمل درآمد کو فوری طور پر ختم کرتا ہے۔
طریقہ کار کے نفاذ کو فوری طور پر ختم کرتا ہے اور طریقہ کار کے نتیجے میں کچھ قدر واپس کرتا ہے۔

دونوں شکلوں کا نحو یہ ہے:

return;
return value; // где value — некоторое возвращаемое meaning

وہ طریقے جو قدر واپس کرتے ہیں ان میں کم از کم ایک آپریٹر ہونا چاہیے جس میں واپسی کی قدر کی ضمانت دی گئی ہو، اور اس میں واپسی کی قدر کے بغیر returnآپریٹر نہیں ہونا چاہیے ۔ returnآئیے ذیل کی مثالوں کو دیکھتے ہیں:

public int sum(int a, int b) {
    return a + b;
}

public String getGreetings(String name) {
    return "Hello " + name;
}

public int max(int x, int y) {
    if (x > y) {
        return x;
    } else {
        return y;
    }
}

ایسے طریقوں میں جو قدر واپس نہیں کرتے ہیں (طریقے void)، یہ قابل قبول ہے، لیکن اس کی ضرورت نہیں ہے، کم از کم ایک بیان returnواپسی کی قدر کے بغیر، اور returnواپسی کی قدر کے ساتھ ایک بھی بیان نہیں۔ آئیے ذیل کی مثالوں کے ساتھ اس کو دیکھتے ہیں:

public void print(String s) {
    // наличие return в void методах не обязательно
    System.out.println(s);
}

//Метод выведет в консоль число, если оно нечетное
public void printIfOdd(int number) {
    if (number % 2 == 0) {
        // Если число четное, метод завершит свою работу
        // Наличие return в void методах опционально
        return;
    }

    System.out.println(number);
}

// Метод выведет в консоль наибольшее meaning из массива
private void printMaxInArray(int[] array) {
    if (array == null || array.length == 0) {
        /*
         Если массив пуст, метод завершит свою работу.
         Иногда полезно проверять подобным образом аргументы метода вначале и прерывать выполнение метода, если аргументы не подходят для дальнейшей корректной работы
        */
        System.out.println("Empty array");
        return;
    }

    int max = array[1];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    System.out.println(max);
}

لیبلز

breakاور آپریٹرز کو دیکھنے سے پہلے continue، میں جاوا میں لیبلز کے بارے میں بات کرنا چاہوں گا۔ یہ اہم ہے کیونکہ کچھ حالات میں، breakاور آپریٹرز کو continueلیبل کے ساتھ مل کر استعمال کیا جاتا ہے۔ لیکن پہلے، اس سوال کا جواب دینے کی کوشش کریں کہ آیا یہ کوڈ مرتب کرے گا:

public static void main(String[] args) {
    https://www.google.com/
    System.out.println("Interesting...");
}

ایک لیبل کوڈ کا ایک نامزد ٹکڑا ہے۔ لیبل خود کوئی فعالیت فراہم نہیں کرتا ہے۔ یہ کوڈ میں بک مارک کی طرح کچھ ہے جسے پروگرامر بعد میں استعمال کرنے کا ارادہ رکھتا ہے۔ کوڈ میں ایک لیبل کی وضاحت بہت آسان ہے - ایک نام اور بڑی آنت کے ذریعے۔ مثال کے طور پر:

labelName:
outerLoop:
printing:
anyWordYouLike:

اور جاوا کوڈ کے اندر لیبل اس طرح نظر آتے ہیں:

public static void main(String[] args) {
    definePrintName:
    System.out.println("Таблица Умножения");

    loop1:
    for (int i = 1; i <= 10; i++) {
        loop2:
        for (int j = 1; j <= 10; j++) {
            System.out.printf("%4d", i * j);
        }
        System.out.println();
    }
}

طریقہ کار کی پیداوار mainمندرجہ ذیل ہوگی:

Таблица Умножения
   1   2   3   4   5   6   7   8   9   10
   2   4   6   8   10  12  14  16  18  20
   3   6   9   12  15  18  21  24  27  30
   4   8   12  16  20  24  28  32  36  40
   5   10  15  20  25  30  35  40  45  50
   6   12  18  24  30  36  42  48  54  60
   7   14  21  28  35  42  49  56  63  70
   8   16  24  32  40  48  56  64  72  80
   9   18  27  36  45  54  63  72  81  90
  10  20  30  40  50  60  70  80  90  100

Process finished with exit code 0

اوپر کی مثال میں definePrintName، loop1:اور loop2:لیبل ہیں۔ loop1:اور loop2:دو چکروں کو "نشان" کریں - بیرونی اور اندرونی۔ ہم ذیل کے سیکشن میں لیبل استعمال کرنے پر غور کریں گے۔ اس دوران، اگر آپ نے اس سوال کا جواب "نہیں" میں دیا کہ آیا یہ کوڈ مرتب کرے گا:

public static void main(String[] args) {
      https://www.google.com/
      System.out.println("Interesting...");
  }

IDE کا استعمال کرتے ہوئے اسے دوبارہ جواب دینے کی کوشش کریں۔

توڑنا

آپریٹر breakدو صورتوں میں استعمال ہوتا ہے:

سوئچ کیس بلاک میں کسی بھی عمل درآمد کی شاخ کو مکمل کرنے کے لیے۔
ایک لوپ کے عمل میں خلل ڈالنا۔

آپریٹر کی دو شکلیں ہیں: نشانات کے ساتھ (لیبل) اور بغیر۔ دونوں شکلوں کا نحو یہ ہے:

break labelName; // Синтаксис оператора с меткой
break; // Синтаксис оператора без метки

سوئچ کیس بلاکس میں، آپریٹر کو breakلیبل کے بغیر استعمال کیا جاتا ہے:

public static void main(String[] args) {
    int dayOfWeekInt = 4;
    String dayOfWeek;
    switch (dayOfWeekInt) {
        case 1:
            dayOfWeek = "Monday";
            break;
        case 2:
            dayOfWeek = "Tuesday";
            break;
        case 3:
            dayOfWeek = "Wednesday";
            break;
        case 4:
            dayOfWeek = "Thursday";
            break;
        case 5:
            dayOfWeek = "Friday";
            break;
        case 6:
            dayOfWeek = "Saturday";
            break;
        case 7:
            dayOfWeek = "Sunday";
            break;
        default:
            dayOfWeek = "Неизвестный день";
            break;
    }

    System.out.println("Сегодня " + dayOfWeek);
}

لوپس میں، breakکچھ شرائط پوری ہونے کے بعد مزید تکرار کو روکنے کے لیے ایک بیان استعمال کیا جاتا ہے۔ یہ اکثر اس وقت پایا جا سکتا ہے جب آپ کو کسی صف یا عناصر کے مجموعے کے ذریعے اعادہ کرنے کی ضرورت ہوتی ہے اور اس میں کوئی ایسا عنصر ڈھونڈنا پڑتا ہے جو ضروری شرائط کو پورا کرتا ہو۔ آئیے اس مثال پر غور کریں۔ ہمارے پاس ایک صف ہے اور ہمیں یہ تعین کرنے کی ضرورت ہے کہ آیا صف میں منفی عناصر ہیں:

int a[] = {1,2,234,-123,12,-2,312,0,412,433};
boolean arrayHasNegativeElements = false;

for (int i = 0; i < a.length; i++) {
   if (a[i] < 0) {
       /*
        Как только найдется
        хотя бы один отрицательный элемент,
        мы прервем цикл с помощью
        оператора break, потому что
        мы выяснor то, что нас интересовало,
        и дальнейший перебор элементов не имеет смысла.
        */
       arrayHasNegativeElements = true;
       break;
   }
}

آئیے ایک ہی مثال کو مختلف لوپس کے ساتھ دیکھتے ہیں۔ سائیکل for-each:

public static void main(String[] args) {
    int a[] = {1,2,234,-123,12,-2,312,0,412,433};
    boolean arrayHasNegativeElements = false;

    for (int number : a) {
        if (number < 0) {
            arrayHasNegativeElements = true;
            break;
        }
    }
}

سائیکل while:

public static void main(String[] args) {
    int a[] = {1,2,234,-123,12,-2,312,0,412,433};
    boolean arrayHasNegativeElements = false;

    int counter = 0;
    while (counter < a.length) {
        if (a[counter] < 0) {
            arrayHasNegativeElements = true;
            break;
        }
        counter ++;
    }
}

سائیکل do-while:

public static void main(String[] args) {
    int a[] = {1,2,234,-123,12,-2,312,0,412,433};
    boolean arrayHasNegativeElements = false;

    int counter = 0;
    do {
        if (a[counter] < 0) {
            arrayHasNegativeElements = true;
            break;
        }
        counter ++;
    } while (counter < a.length);
}

لوپس میں بیان کی ایک اور مثال breakیہ ہے کہ جب کچھ شرائط پوری ہو جائیں تو لامحدود لوپ کو روکنا ہے۔ یہاں ایک پروگرام کی ایک مثال ہے جو صارف کے ذریعہ درج کردہ لائن کو دکھاتا ہے جب تک کہ صارف لفظ "اسٹاپ" داخل نہیں کرتا ہے۔

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

    while (true) {
        line = scanner.nextLine();
        if ("stop".equals(line)){
            /*
             Прерываем бесконечный цикл,
             при достижении
             определенного условия
             */
            break;
        }
        System.out.println("Пользователь ввел: " + line);
    }
}

آئیے آپریٹر کو breakایک لیبل کے ساتھ استعمال کرنے پر غور کریں۔ ایک لیبل کے ساتھ مداخلت کا استعمال کئی چکروں والے معاملات میں کیا جاتا ہے، اس کے علاوہ، ایک دوسرے کے اندر گھوںسلا ہوتا ہے۔ اس صورت میں، سائیکلوں میں سے ایک (یا تمام سائیکل) کو لیبل کے ساتھ نشان زد کیا گیا ہے۔ اگلا، آپریٹر، breakلیبل کی نشاندہی کرنے کے ساتھ، مطلوبہ سائیکل میں خلل ڈالتا ہے۔ آئیے ایک مثال پر غور کریں جس میں ہمیں یہ سمجھنے کی ضرورت ہے کہ آیا کوئی منفی عنصر موجود ہے، لیکن صف میں نہیں، بلکہ میٹرکس میں:

public static void main(String[] args) {
   int[][] a = {
           {1, 2, 3},
           {-412, 12, 0},
           {1223, 474, -54}
   };

   boolean hasNegative = false;

   searchNegative:
       for (int i = 0; i < a.length; i++) {
           for (int j = 0; j < a[i].length; j++) {
               if (a[i][j] < 0) {
                   /*
                       Если использовать break без метки,
                       тогда прервется вложенный цикл for,
                       но внешний продолжит выполнять свои итерации
                       и поиск продолжится.

                       Поэтому мы "помечаем" внешний цикл меткой `searchNegative`
                       и прерываем внешний цикл оператором break совместно с нужной меткой.
                    */
                   hasNegative = true;
                   break searchNegative;
               }
           }
       }
}

تسلسل

آپریٹر کی continueبھی دو شکلیں ہیں - لیبل کے ساتھ اور بغیر:

continue; // форма оператора без метки
continue labelName; // форма оператора с меткой

آپریٹر کے برعکس break، جو لوپ کے باقی تمام تکرار کو روکتا ہے، آپریٹر continueموجودہ تکرار میں خلل ڈالتا ہے اور اگلے کو شروع کرنے کا سبب بنتا ہے۔ جاوا میں جمپ آپریٹرز - 2

یہ مفید ہو سکتا ہے اگر آپ کو ایسے عناصر پر کچھ آپریشن کرنے کی ضرورت ہو جو کچھ شرائط کو پورا کرتے ہوں۔ ہم کہتے ہیں کہ ہمارے پاس ایک تار ہے اور ہم حرف "m" سے شروع ہونے والے الفاظ کی تعداد گننا چاہتے ہیں:

public static void main(String[] args) {
    String sentence = "Мама мыла раму";
    String[] words = sentence.split(" ");

    int mWordsCount = 0;

    for (int i = 0; i < words.length; i++) {
        if ( ! words[i].toLowerCase().startsWith("м")) {
            /*
             Если слово не начинается с буквы м,
             то текущая итерация прервется и цикл
             ПРОДОЛЖИТ выполнение со следующей итерации
             */
            continue;
        }

        mWordsCount ++;
    }

    System.out.println("Кол-во слов, начинающихся с буквы М в предложении: " + "[" + sentence + "] = " + mWordsCount);
}

اس کوڈ پر عمل کرنے کے بعد کنسول میں درج ذیل آؤٹ پٹ آئے گا۔

Кол-во слов, начинающихся с буквы М в предложении: [Мама мыла раму] = 2

continueلیبل کے ساتھ آپریٹر بھی عناصر پر تکرار کرتے وقت استعمال ہوتا ہے۔ آئیے ایک میٹرکس کا تصور کریں جس میں ہمیں منفی عناصر کے ساتھ قطاروں کی تعداد گننے کی ضرورت ہے:

public static void main(String[] args) {
    int[][] a = {
            {1, 23, -1, 23, -12},
            {21, 21, 0, 23, 123, 45},
            {123, 3},
            {123, -5, 4, -3},
            {-1, -2, -3}
    };

    int rowsWithNegativeElementsCount = 0;

    rowsLoop:
    // Проходим по каждой строке
        for (int[] arr : a) {
            for (int number : arr) {
                if (number < 0) {
                    /*
                     Если в текущей строке найдется
                     хотя бы 1 отрицательный элемент,
                     тогда мы увеличим переменную счетчик,
                     и с помощью оператора continue rowsLoop
                     прервем текущую итерацию внешнего цикла и
                     принудительно начнем следующую
                     */
                    rowsWithNegativeElementsCount ++;
                    continue rowsLoop;
                }
            }
        }

    System.out.println("Rows With Negative Elements Count = " + rowsWithNegativeElementsCount);
}

اس کوڈ کا آؤٹ پٹ یہ ہوگا:

Rows With Negative Elements Count = 3

یہ کہنے کے قابل ہے کہ آپریٹرز break، continueاور returnایک ہی فعالیت کو حاصل کرنے کے لیے مختلف طریقوں سے استعمال کیا جا سکتا ہے۔ لہذا، آپ آخری مثال کو دوبارہ لکھ سکتے ہیں اور continueاستعمال کر سکتے ہیں break:

public static void main(String[] args) {
    int[][] a = {
            {1, 23, -1, 23, -12},
            {21, 21, 0, 23, 123, 45},
            {123, 3},
            {123, -5, 4, -3},
            {-1, -2, -3}
    };

    int rowsWithNegativeElementsCount = 0;

    for (int[] arr : a) {
        for (int number : arr) {
            if (number < 0) {
                rowsWithNegativeElementsCount ++;
                break;
            }
        }
    }

    System.out.println("Rows With Negative Elements Count = " + rowsWithNegativeElementsCount);
}

لیبل کے درمیان breakاور اس کے ساتھ فرق وہی ہے جو لوپ کی تکرار کو مکمل کرتا ہے جس میں یہ لکھا گیا ہے۔ اور ایک لیبل کے ساتھ، لیبل کے ساتھ نشان زد سائیکل کی موجودہ تکرار کو چھوڑ دیتا ہے۔ کچھ حالات میں، آپ ایک کو دوسرے سے بدل سکتے ہیں، اور پروگرام کی فعالیت میں سب کچھ وہی رہے گا۔ ہم ذیل میں اس کے بارے میں بات کریں گے کہ کس چیز کا انتخاب کرنا بہتر ہے (سپائلر: کوڈ پڑھنے کی اہلیت)۔ آپریٹر کو نہ صرف لیبل کے ساتھ بلکہ اس کے ساتھ بھی تبدیل کیا جا سکتا ہے ۔ اس سے ٹھیک پہلے آپ کو نیسٹڈ لوپ کو الگ طریقہ میں منتقل کرنے کی ضرورت ہے: continuebreakcontinuebreakcontinuereturn

public static void main(String[] args) {
    int[][] a = {
            {1, 23, -1, 23, -12},
            {21, 21, 0, 23, 123, 45},
            {123, 3},
            {123, -5, 4, -3},
            {-1, -2, -3}
    };

    int rowsWithNegativeElementsCount = 0;

    for (int[] arr : a) {
        if (arrayHasNegativeElements(arr)) {
            rowsWithNegativeElementsCount ++;
        }
    }

    System.out.println("Rows With Negative Elements Count = " + rowsWithNegativeElementsCount);
}

static boolean arrayHasNegativeElements(int[] array) {
    for (int number : array) {
        if (number < 0) {
            return true;
        }
    }

    return false;
}

ایک ہی چیز کو لکھنے کے بہت سارے طریقے۔ کون سا انتخاب کرنا ہے؟ صنعتی پروگرامنگ میں، اس مسئلے کا فیصلہ کوڈ کو سمجھنے میں آسانی سے کیا جاتا ہے۔ جتنا آسان لکھا جائے اتنا ہی اچھا ہے۔ جتنے زیادہ نیسٹڈ لوپس ہوں گے، کوڈ کو جاننا اتنا ہی مشکل ہوگا۔ خاص طور پر اگر لوپس کو مختلف نشانوں کے ساتھ نشان زد کیا گیا ہو، جو مداخلت اور تسلسل ( breakاور continue) میں استعمال ہوتے ہیں۔ اگر ٹیگز کا استعمال نہ کرنا ممکن ہو تو ایسا کرنا بہتر ہے۔ دوسری صورت میں، ممکن حد تک واضح اور خوبصورت لکھنے کی کوشش کریں.

کے پاس جاؤ

کچھ پروگرامنگ زبانوں میں ایک آپریٹر ہوتا ہے goto۔ عام طور پر یہ کوڈ پر عمل درآمد کو لیبل کے ساتھ نشان زد پروگرام کے کچھ حصے پر بھیجتا ہے۔ لیکن Java میں goto، کوئی کہہ سکتا ہے، یہ ہے اور یہ نہیں ہے۔ آئیے اس کا پتہ لگائیں۔ جاوا میں مطلوبہ الفاظ کی فہرست میں لفظ شامل ہے goto۔ تاہم، اس بیان کو بطور استعمال نہیں کیا گیا ہے۔ حقیقت یہ ہے کہ جاوا زبان کے خالق جیمز گوسلنگ نے ابتدائی طور پر JVM میں آپریٹر کے لیے تعاون شامل کیا تھا goto۔ تاہم بعد میں اس خصوصیت کو ختم کر دیا گیا۔ اس کی ایک وجہ یہ ہے کہ آپریٹر پر مشتمل کوڈ کے بلاکس gotoاتنے پڑھنے کے قابل نہیں تھے جتنے کوڈ کے بلاکس جو ایک جیسے کام انجام دیتے تھے لیکن بغیر goto، لیکن متبادل نقطہ نظر کے ساتھ ( break، continueکوڈ بلاک کو طریقوں میں رکھنا)۔ درحقیقت، دیگر تھے، جیسے:

آپریٹرز پر مشتمل کوڈ کو پڑھنے اور سمجھنے میں دشواری goto؛
کمپائلر کے لیے پیچیدہ کوڈ کی اصلاح (اور بعض اوقات ناممکن بھی)؛
کوڈ میں ٹھیک ٹھیک غلطیاں پیدا کرنے کے امکانات کو بڑھانا۔

یہ بہت سے لوگوں کے لئے کوئی راز نہیں ہے کہ کچھ پروگرامنگ زبانوں میں آپریٹر gotoکافی کامیابی سے کام کرتا ہے۔ تاہم، پروگرامرز اسے استعمال کرنے سے گریز کرتے ہیں۔ آپ Habré پر ایک مضمون میں اس کی وجوہات کے بارے میں پڑھ سکتے ہیں ۔ لیکن پھر اسے gotoمخصوص الفاظ کی فہرست میں کیوں چھوڑ دیا جائے؟ یہ آسان ہے: مستقبل کے لیے۔ اگر، مثال کے طور پر، پوری دنیا میں ڈویلپرز کے جاوا کوڈ میں، متغیرات، طریقے، یا کلاسز کو کہا جاتا ہے، gotoاگر یہ بیان جاوا کے مستقبل کے ورژن میں لوٹا دیا جاتا ہے، تو تمام پرانا کوڈ ٹوٹ جائے گا۔ اس طرح کے منظر نامے سے بچنے کے لیے، gotoیہ Java کلیدی الفاظ کی فہرست میں رہتا ہے، لیکن اس میں کوئی فعالیت نہیں ہے۔ شاید کسی دن gotoوہ ہماری صفوں میں واپس آجائے، لیکن اس کا امکان کم ہے۔

نتائج

ہم نے جاوا میں مختلف جمپ آپریٹرز کو دیکھا ہے:

return- طریقہ کی تکمیل، طریقہ سے ایک قدر واپس کرنا۔
- واپسی کی قدر کے ساتھ: وہ طریقے جو قدریں واپس کرتے ہیں۔
- واپسی کی کوئی قیمت نہیں: voidطریقے۔
break- سائیکلوں میں رکاوٹ، سوئچ کیس بلاکس۔
- ٹیگز کے ساتھ: مختلف گھونسلے کے چکر۔
- لیبل کے بغیر: بلاک کی سوئچ کیس شاخیں؛ اس لوپ میں خلل ڈالنا جس میں اسے بلایا گیا تھا۔
continue.
- ٹیگز کے ساتھ: مختلف گھونسلے کے چکر۔
- لیبل کے بغیر: اس لوپ کا تسلسل جس میں اسے بلایا گیا تھا۔
goto.
- مطلوبہ الفاظ کی فہرست میں ہے، لیکن استعمال نہیں کیا جاتا ہے۔

اس سب سے نتیجہ آسان ہے: بہتر ہے کہ ان آسان طریقوں کو ترجیح دی جائے جو کوڈ کو پڑھنے میں آسانی پیدا کریں۔ کوشش کریں کہ اپنے کوڈ کو کثیر سطحی لوپس کے ساتھ اوورلوڈ نہ کریں جو ایک دوسرے کے اندر بہت سارے نمبروں، رکاوٹوں اور تسلسل کے ساتھ گھونسلے ہیں۔

تبصرے

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION