జావాలో System.exit().

జావాలోని సిస్టమ్ క్లాస్ సిస్టమ్‌ను హ్యాండిల్ చేయడానికి ఫీల్డ్‌లు మరియు పద్ధతులను కలిగి ఉంది వాటిలో ఒకటి System.exit ( ) పద్ధతి మీరు ప్రస్తుతం అమలులో ఉన్న ప్రోగ్రామ్‌ను లేదా JVM ఉదాహరణను ముగించాల్సినప్పుడు జావా భాషలో ఉపయోగించబడుతుంది. నిష్క్రమణ పద్ధతికి దిగువన చొప్పించిన ఏదైనా లైన్ అందుబాటులో ఉండదు మరియు అమలు చేయబడదు.

System.exit() పద్ధతి యొక్క సింటాక్స్

System.exit() పద్ధతి యొక్క సింటాక్స్ క్రింది విధంగా ఉంటుంది.

public void static(int status)

కాబట్టి ఇది స్టాటిక్ పద్ధతి అని మీరు చూడవచ్చు. వాస్తవానికి, సిస్టమ్ క్లాస్‌లోని అన్ని పద్ధతులు స్టాటిక్ పద్ధతులు. నిష్క్రమణ () పద్ధతి పూర్ణాంకాన్ని ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది మరియు ఏమీ ఇవ్వదు. కాబట్టి మీరు నిష్క్రమణ పద్ధతిని System.exit(i) గా పిలుస్తారు, ఇక్కడ i పూర్ణాంకం. ఈ పూర్ణాంకాన్ని "నిష్క్రమణ స్థితి" అని పిలుస్తారు మరియు ఇది సున్నా లేదా సున్నా కాని మూలకం కావచ్చు. స్థితి సున్నా అయితే — exit(0) , ప్రోగ్రామ్ విజయవంతమైన ముగింపును కలిగి ఉంటుంది. జీరో కాని స్థితి — నిష్క్రమణ(1) JVM యొక్క అసాధారణ ముగింపును సూచిస్తుంది.

System.exit() పద్ధతికి ఉదాహరణ

సున్నా మరియు సున్నా కాని పూర్ణాంకాల హోదాతో నిష్క్రమణ() పద్ధతి యొక్క రెండు సాధారణ ఉదాహరణలను చూద్దాం . మా మొదటి ఉదాహరణలో, రంగుల శ్రేణిపై లూప్ ఉంది. లూప్ "ఆకుపచ్చ"ని కలిసినప్పుడు, అప్లికేషన్‌ను ముగించాల్సిన అవసరం ఉంది.

import java.lang.*;

class Main {
  public static void main(String[] args) {
    String colors[]= {"red","blue","green","black","orange"};
    for(int i=0;i<colors.length;i++)  {
      System.out.println("Color is "+colors[i]);
      if(colors[i].equals("green")) {
        System.out.println("JVM will be terminated after this line");
        System.exit(0);
      }
    }
  }
}

కింది అవుట్‌పుట్ ప్రదర్శించబడుతుంది. టెర్మినల్ అవుట్‌పుట్‌లో ఎటువంటి నిష్క్రమణ కోడ్‌ను చూపలేదు ఎందుకంటే మేము సున్నాని స్టేటస్‌గా ఉపయోగించాము. సున్నా విజయవంతమైన ముగింపును సూచిస్తుంది కాబట్టి, నిష్క్రమణ కోడ్‌ను ముద్రించాల్సిన అవసరం లేదు. కాబట్టి మన తదుపరి ఉదాహరణలో ధనాత్మక పూర్ణాంకాన్ని స్థితిగా ఉపయోగించుకుందాం. ఈ ఉదాహరణలో, మేము 0 మరియు 10 మధ్య యాదృచ్ఛిక సంఖ్యలను రూపొందించే లూప్‌ను సృష్టిస్తాము. ఉత్పత్తి చేయబడిన సంఖ్య 2,3 లేదా 7 అయితే, అప్లికేషన్‌ని ముగించాలి మరియు అది ఏ సంఖ్యను రద్దు చేస్తుందో ప్రింట్ చేయాలి. దిగువ కోడ్ చూడండి.

import java.lang.*;
import java.util.Random;

class Main {
  public static void main(String[] args) {
    System.out.println("program will be terminated when values are 2, 3, or 7");
    int i;
    Random number=new Random();
    while(true){
      i = number.nextInt(11);
      System.out.println("Random Number is "+i);
      if(i==2||i==3||i==7){
        System.out.println("Value is "+ i + " your program will be terminated now");
        System.exit(i);
      }
    }
  }
}

నేను కోడ్‌ని అమలు చేసినప్పుడు, నాకు ఈ క్రింది అవుట్‌పుట్ వచ్చింది. మీరు చూడగలిగినట్లుగా, సంఖ్య 3 అప్లికేషన్ యొక్క అసాధారణ ముగింపుకు కారణమైంది. ఇప్పుడు, స్థితి కోడ్‌ను ఎలా సమర్థవంతంగా ఉపయోగించవచ్చో చూద్దాం.

స్థితి కోడ్‌ను ఎలా సమర్థవంతంగా ఉపయోగించాలి

మీరు కమాండ్-లైన్ ఇంటర్‌ఫేస్ (CLI) ద్వారా జావా ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు స్థితి కోడ్ సాధారణంగా ముఖ్యమైనది. ఇతర ప్రామాణిక సాధనాలు, ప్రోగ్రామ్‌లు లేదా ఆపరేటింగ్ సిస్టమ్‌లతో కమ్యూనికేట్ చేయడానికి ఈ ప్రోగ్రామ్‌ను ఉపయోగించాలనే ఉద్దేశ్యం మీ ఉద్దేశం అయితే స్టేటస్ కోడ్‌ని ఉపయోగించడం ప్రయోజనకరంగా ఉంటుంది. ప్రోగ్రామ్ ఆపరేటింగ్ సిస్టమ్‌తో కమ్యూనికేట్ చేయడానికి ఉద్దేశించినట్లయితే, మీరు ఆపరేటింగ్ సిస్టమ్‌కు నిర్దిష్ట స్థితి కోడ్‌లను ఉపయోగించవచ్చు. ఉదాహరణకు, 128 అనేది UNIXలో "నిష్క్రమించడానికి చెల్లని వాదన"ని వివరించడానికి ప్రామాణిక స్థితి కోడ్.

System.exit పద్ధతిని ఎప్పుడు ఉపయోగించాలి

ప్రోగ్రామ్‌లో అసాధారణ పరిస్థితి ప్రదర్శించబడినప్పుడు System.exit యొక్క సాధారణ ఉపయోగాలలో ఒకటి మరియు మీరు తదుపరి సమస్యలను కలిగించకుండా వెంటనే ప్రోగ్రామ్‌ను ముగించాలి. ప్రధాన పద్ధతిలో కాకుండా ప్రోగ్రామ్‌ను ముగించాల్సిన అవసరం ఉన్నప్పుడు మరొక ఉపయోగం. జావాలో "షట్ డౌన్ హుక్స్" అని పిలువబడే ఒక ప్రత్యేక నిర్మాణం ఉంది, ఇది JVM యొక్క ముగింపుకు ముందు అమలు చేయవలసిన కోడ్ స్నిప్పెట్‌ను ప్లగ్ చేయడానికి డెవలపర్‌లను అనుమతిస్తుంది. క్లీన్ అప్ ఆపరేషన్స్ చేయడానికి ఇవి ప్రత్యేకంగా ఉపయోగపడతాయి. అటువంటి సందర్భాలలో షట్డౌన్ హుక్స్ కాల్ చేయడానికి System.exit పద్ధతి ఉపయోగించబడుతుంది.

ముగింపు

ఈ వ్యాసంలో, మేము System.exit() పద్ధతిని వివరంగా నేర్చుకున్నాము. జావాలో System.exit అంటే JVMని ముగించడానికి ఒక మార్గం . System.exit పద్ధతి దేనినీ తిరిగి ఇవ్వదు ఎందుకంటే అప్లికేషన్ exit() పద్ధతికి దిగువన ఏ కోడ్‌ను అమలు చేయదు . మేము exit() పద్ధతి యొక్క వాస్తవ-ప్రపంచ ఉపయోగాలను కూడా చర్చిస్తాము . అయినప్పటికీ, మీకు ఇతర ఎంపికలు ఉన్నంత వరకు జావా సంఘం నిష్క్రమణ పద్ధతిని ఉపయోగించడాన్ని నిరుత్సాహపరుస్తుంది.