ஜாவாவில் System.exit().

ஜாவாவில் உள்ள சிஸ்டம் கிளாஸ், சிஸ்டம் ஒன்றைக் கையாளும் புலங்கள் மற்றும் முறைகளைக் கொண்டுள்ளது அவற்றில் ஒன்று, தற்போது இயங்கும் ஒரு புரோகிராம் அல்லது ஜேவிஎம் நிகழ்வை நீங்கள் நிறுத்த வேண்டியிருக்கும் போது, ​​ஜாவா மொழியில் பயன்படுத்தப்படும் System.exit () முறை. வெளியேறும் முறைக்கு கீழே செருகப்பட்ட எந்த வரியும் அணுக முடியாததாக இருக்கும் மற்றும் செயல்படுத்தப்படாது.

System.exit() முறையின் தொடரியல்

System.exit() முறையின் தொடரியல் பின்வருமாறு.

public void static(int status)

எனவே இது ஒரு நிலையான முறை என்பதை நீங்கள் காணலாம். உண்மையில், கணினி வகுப்பில் உள்ள அனைத்து முறைகளும் நிலையான முறைகள். exit () முறை ஒரு முழு எண்ணை ஒரு வாதமாக எடுத்துக்கொண்டு எதையும் தராது. எனவே நீங்கள் வெளியேறும் முறையை System.exit(i) என அழைப்பீர்கள், அங்கு i ஒரு முழு எண். இந்த முழு எண் "வெளியேறும் நிலை" என்று அழைக்கப்படுகிறது மற்றும் பூஜ்ஜியம் அல்லது பூஜ்ஜியமற்ற உறுப்பு ஆகும். நிலை பூஜ்ஜியமாக இருந்தால் — வெளியேறு(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 முறை எதையும் தராது, ஏனெனில் பயன்பாடு வெளியேறும்() முறைக்கு கீழே எந்த குறியீட்டையும் இயக்காது . எக்சிட்() முறையின் நிஜ உலகப் பயன்பாடுகளையும் நாங்கள் விவாதிக்கிறோம் . இருப்பினும், ஜாவா சமூகம் உங்களுக்கு வேறு விருப்பங்கள் இருக்கும் வரை வெளியேறும் முறையைப் பயன்படுத்துவதை ஊக்கப்படுத்துகிறது.