Palindrome

Palindrome वो नंबर होता है जो आगे और पीछे से समान रूप से लिखा जा सकता है। जैसे 14441, इस नंबर को आप आगे से लिखे या पीछे से, इसकी वैल्यू वही रहेगी। जावा में इस प्रोग्राम को बनाने से हमे कहीं concepts सिखने को मिलते है, जैसे while loop, if else , % (डिवीज़न का remainder स्टोर करना ), डाटा टाइप के फायदे, और डिवीज़न।

Income Tax Calculator

हम आज यहाँ भारत सरकार के फाइनेंसियल ईयर (2014 -2015) के नए स्लैब के हिसाब से इनकम टैक्स फलाएंगे।   इनकम टैक्स के कही प्रकार का स्लैब होते है पर प्रोग्राम को आसान और समझने लायक बनाने के लिए हम सिर्फ जनरल स्लैब लेंगे । जावा में कठिन से कठिन काम को भी आसानी से किया जा सकता है ।

Simple Interest Calculation with Applet

आज हम जिस प्रोग्राम को डिस्कस करने जा रहे है इसे आपने कही पुराने फीचर मोबाइल फ़ोन में देखा होगा। यह प्रोग्राम  आसान होते हुए भी जावा एप्लेट को समझने के लिए सबसे उपयुक्त है।

Hello Program Part 2

हमने अपनी पहली पोस्ट में देखा की हम हेल्लो वर्ल्ड को टर्मिनल पर किस प्रकार प्रिंट करा सकते है । आईये अब हम देखते है की इस प्रोग्राम को थोडा और interactive किस प्रकार बनाया जा सकता है ।

star problem in java

जब भी हम कंप्यूटर की किसी नयी भाषा को सीखते है तो उस भाषा को पढ़ाने वाले गुरूजी हमे तारो की समस्या का सवाल पूछना नहीं भूलते । आज हम देखेंगे की इस समस्या का समाधान क्या है और इसको देखते ही झट से कैसे हल किया जा सकता है ।

Finding a integer in Array

/**
 * हम इस प्रोग्राम में एक अर्रे A में N integer को सर्च करेंगे, अगर N हमे अर्रे में नहीं मिला तो
 * हम -1 को return करेंगे अन्यथा अगर N अर्रे में है तो हमे जहा अर्रे मिला उसका index को return
 * करेंगे, index i की वोह पहली value है जो A[i] == N condition को satisfy करती है.
 */

Fibonacci Series

हम यहाँ पर पहले 50 नम्बरों की fibonacci series को प्रिंट कराएँगे | जैसा की आप ऊपर देख सकते है,

fibonaaci series में पहले और दुसरे नंबर का जोड़ तीसरा नंबर होता है | इस प्रोग्राम को बनाने के लिए

हमे while लूप का उसे करना पड़ेगा | यहाँ पर हम पहले दो नंबर declare करेंगे और फिर उससे तीसरा नंबर 

निकालेंगे | इसी प्रकार हम पूरी series बना लेंगे | 

Reverse the string using string buffer

हमने स्ट्रिंग को उपयोग करके देख लिया है , अब अगर हम इसी स्ट्रिंग को उल्टा करना चाहे तोह हमे जावा के language package का दूसरा हिस्सा स्ट्रिंग बफर को काम में लेना पड़ेगा | जावा में स्ट्रिंग और स्ट्रिंग बफर language  पैकेज में आते  है | स्ट्रिंग को में आपको पहले ही समझा चूका हूँ एवं उसके उदहारण भी आपको दे चूका हूँ , अब हम स्ट्रिंग बफर का उपयोग करे स्ट्रिंग को उल्टा करेंगे |

// क्लास के नाम का declaration 

class ReverseString { 

// स्ट्रिंग को उल्टा करने के लिए हम revereIt नाम का function declare करेंगे , जिसमे 

//आर्गुमेंट इनपुट हम स्ट्रिंग ही देंगे , आर्गुमेंट का नाम हमने source रखा है |
    public static String reverseIt(String source) {

//अब दो variable declare करेंगे एक तोह i एवं दूसरा len जो स्ट्रिंग की लम्बाई को स्टोर करेंगा 
        int i, len = source.length();

 // यहाँ पर हम नया स्ट्रिंग बफर dest बनायेंगे जिसके लम्बाई हमारे पूरानी स्ट्रिंग जितनी ही होगी 
        StringBuffer dest = new StringBuffer(len);
//अब फॉर लूप की सहायता से हम एक एक करके पूरानी स्ट्रिंग्स के सभी char को नयी स्ट्रिंग में अपेंड करेंगे  
        for (i = (len - 1); i >= 0; i--) {
            dest.append(source.charAt(i));
        }

//यहाँ से नहीं स्ट्रिंग को function को return कर देंगे |
        return dest.toString();
    }
}

यह प्रोग्राम नए लोगो को शुरू में थोडा मुश्किल लग सकता है , इसीलिए में कहूँगा की वो पहले इस ब्लॉग 

के दुसरे पोस्ट पढ़े और फिर दुबारा इस इसे देखे तो उन्हें काफी कुछ समझ में आने लगेगा |

String Concatenation

दो स्ट्रिंग्स को जोड़ने के काम को स्ट्रिंग concatenation कहते है | वैसे जावा operators(-, *, /) को सीधा स्ट्रिंग्स पर कार्य करने की इज़ाज़त नहीं देता पर स्ट्रिंग को जोड़ने के लिए इसमें + का इस्तमाल करने की हमे छुट है | इससे स्ट्रिंग को जोड़ना हमारे लिए बहुत आसान हो जाता है | आप में से कही लोग को लग रहा होगा की स्ट्रिंग को जोड़ने में इतना खास क्या है की जावा ने हमे इससे जोड़ने की छुट दी | अगर आप रोज़ कंप्यूटर पर काम करने वालो में है तोह आपने देखा होगा की कही सॉफ्टवेर हम से पहला और अंतिम नाम अलग अलग पूछते है और जब स्टोर करते है तोह एक साथ कर देते है | ऐसे है बहुत सारे सॉफ्टवेर इसका बहुत ज्यादा बार उपयोग करते है |

Functions in Java

functions का नाम सुनते ही काफी विद्यारती डर जाते है | जबकि इनको आपका काम आसान करने के लिए बनाया गया है | function को आप एक ऐसी मशीन समझ सकते है जो सिर्फ एक काम करना जानती है | वोह काम कुछ भी हो सकता है | जैसे कोई मशीन सिर्फ दो नंबर को जोड़ना जानती हो , तोह जब भी आप उसे दो नंबर देंगे वैसे ही वोह आपको उसे जोड़ कर बता देगी | लेकिन चुकी मशीन तोह मशीन ही होती है , दो नंबर को जोड़ने वाली मशीन को तीसरा नंबर देने पर उसको नहीं पता होता की क्या करना है ? इसीलिए जावा ने हमे कहा की लीजिये हम यह आप पर छोड़ते है की आपको कैसी मशीन बनानी है | आप जैसे छाए वैसे मशीन बनाये | और उस मशीन का नाम जावा ने function दे दिया | 

इसके साथ जावा ने हमे यह ताकत भी दी की हम चाहे तोह इस मशीन का इस्तमाल किसी को भी करने दे (public) , और अगर चाहे तोह इसको सिर्फ कुछ अन्दर के लोगो को (private, protected) |

आप में से काफी लोग सोच रहे होगे की आखिर हमे मशीन की आवश्यकता ही क्या है ?

हमे इसके जरूरत इसलिए है की बार बार एक ही काम करने के लिए हमे कंप्यूटर को बार बार कोड लिख कर समझाना पड़ता है | इससे हमारा प्रोग्राम बहुत बड़ा हो जाता है अथवा उसको समझने में भी परेशानी होने लगती है | ऐसे जगह अगर सिर्फ एक बार लिखा गया function हमारा काम संभाल ले तोह हमे बार बार लिखने की झंझट से छुटकारा मिल सकता है | 

हम यहाँ दो उधाहरण देखेंगे , एक तो हमेशा हमारी दी हुई संख्या को +ve कर देगा और दूसरा हमे यह बताएगा की नंबर prime है या नहीं ?

public class Functions {  // यहाँ हम क्लास का नाम Functions दे रहे है , आप नाम अपनी पसंद का भी रख सकते है 

    // इनटीजर variable  की absolute value (किसी भी integer की absolute value हमेशा +ve होगी ) निकालना    

       public static int abs(int x) {    // पब्लिक का मतलब बहार से भी एक्सेस कर सकते है , static मतलब

                                                   // fixed , int इसका return टाइप है , abs funtion का नाम , (int x) इसका

                                                   // argument 

        if (x < 0) return -x;       // अगर x की value 0 से कम है तो x को minus "-" से गुना करके return करो

        else       return  x;        // नहीं तोह जो x है वही value return करो
    }

    // double value variable  की absolute value (overloading)
    public static double abs(double x) {
        if (x < 0) return -x;
        else       return  x;
    }

    // if else की मदद से value return करना साथ ही हम function में फॉर लूप का प्रयोग भी देखेंगे 
    public static boolean isPrime(int N) { // इस function से हम यह पता लगायेंगे की क्या N Prime है ?
        if (N < 2) return false;        // दो से कम है तोह false return करो क्यों की फिर x prime नहीं हो सकता
        for (int i = 2; i <= N/i; i++)     // फॉर लूप  यहाँ से समझे 
            if (N % i == 0) return false; // अगर n को इ की किसी भी value से भाग दिया जा सके तोह वोह prime
                                                      // नहीं होगा
        return true; // अथवा होगा
    }

Average

/*************************************************************************
 *  कमांड कमांड प्रोम्प्ट या टर्मिनल पर लिखे जायेंगे 

 *  कमपाइल करने का कमांड  :  javac Average.java
 *  Execution के लिए कमांड :    java Average < data.txt
 * 

 *  निर्भरता : यह प्रोग्राम में इन दोनों फइल को इम्पोर्ट करना होगा StdIn.java StdOut.java
 *  
 *  क्रम में दिए गए real numbers को जोड़ना, और उनका average फलाना |
 *
 *  % java Average
 *  10.0 5.0 6.0
 *  3.0 7.0 32.0
 *  <Ctrl-d>
 *  Average is 10.5

 *  यहाँ <Ctrl-d> unix की फाइल का अंत बताता है |
 *  विंडो में <Ctrl-z> काम आएगा |
 *
 *************************************************************************/

public class Average {  // बहार से एक्सेस(public) हो सकने वाली क्लास का नाम , पहला अक्षर

                        // हमेशा बड़ा आएगा 
    public static void main(String[] args) { // इसको रटना है, यह प्रोग्राम का मुख्य द्वार है|  
        int count = 0;       // यह याद रखेगा की हमने कुल कितनी संक्या डाली है , अभी इसको 

                             // शुन्य किया है |   
        double sum = 0.0;    // यह डाली गयी संख्या का जोड़ करेगा , double यहाँ int से दुगनी क्षमता  
                             // वाली संक्या को स्टोर करने के लिए उपयोग किया गया है

                             // इसके बारे में डाटा टाइप के पाट में बात करेंगे

    
        // यहाँ हम डाटा को पढेंगे और फलावट करेंगे 
        while (!StdIn.isEmpty()) {
            double value = StdIn.readDouble(); // संक्या को फाइल से पढते हुए 
            sum += value; // उस संख्या को सम में डालते हुए , यहाँ लिखा हुआ आदेश(instruction)

                          // sum = sum + value; का छोटा स्वरुप है  
            count++;      // यह काउंट=काउंट + 1  का छोटा रूप , इससे हम टोटल संक्या का पता 

                          // लगा लेंगे , जैसे पहली संक्या जुड़ेगी तोह यह अपने आप १ हो जायेगा  
        }

        // average की फलावट 
        double average = sum / count; // कुल जोड़ को कुल संक्या से फलाने से average निकलेगा 

        // average को स्क्रीन पर प्रिंट करने का तरीका 
        StdOut.println("Average is " + average); // यह Average is 10.5 प्रिंट  करेगा 
    }
}

One Dimensional Array

/*
 *  =============================================================
 *  DemoArrays1.java: नम्बर और स्ट्रिंग्स के one-dimentional अर्रays की जावा में  विशेषताए 
 *                     
 *
 *  याद रखे : Array एक structure होता है जो सामान datatype की बहुत सारी value खुद 

*  में स्टोर कर सकता है  *
 *  =============================================================
 */

import java.text.*;       

public class DemoArrays1 {   // क्लास का declaration ,

   // Constructor  method.

   public DemoArrays1() {};

   // Define NoColums to be a "constant" .... (see use below)

   public final static int NoColumns = 10;

   // main method : यहाँ से ही प्रोग्राम के execution की शुरुवात होती है.मेने तोह इसको रट लिया है
   // क्यों की हर प्रोग्राम में इसकी आवश्यकता पड़ती है
   public static void main ( String [] args ) {
       int i;

       // [a] सबसे पहले हम single dimensional array बनायेंगे और उसमे 

//     ५(5) integers भरेंगे 

       int [] iA  = new int[5];
       for ( i = 0; i <= 4; i = i + 1)
            iA [i] = i;

       // [b] iA में स्टोर संख्याओ को प्रिंट करो  

       System.out.println("Array: iA");
       for ( i = 0; i <= 4; i = i + 1) // इ को 0 करो और उसमे तब तक एक को जोड़ो जब तक 

// इ 4 के बराबर या उससे कम हो 

System.out.println( iA [i] );

       // [c] iA की lenght का पता लगाओ और print करो

       System.out.println("");
       System.out.println("Length of iA = " + iA.length );

       // [d] Create and initialize a one dimensional array of
       //     twenty floating point nos ....

       float [] fA  = new float[ 45 ];
       for ( i = 0; i < fA.length; i = i + 1)
            fA [i] = (float) i;

       // [e] "fA" को  six columns में जमा के उसके contents को प्रिंट करो...


       System.out.println("");
       System.out.println("Array: fA (standard printout)");
       for ( i = 1; i <= fA.length; i = i + 1) {
             System.out.print(" " + fA[i-1] );
             if (i % NoColumns == 0 || i == fA.length ) 
                 System.out.println("");
       }

       // [f] "fA" के contents का six columns में प्रिंट  
       

       DecimalFormat formatOutput = new DecimalFormat ("00.00");

       System.out.println("");
       System.out.println("Array: fA (formatted output)");
       for ( i = 1; i <= fA.length; i = i + 1) {

             // array element को Format और print करते हुए  ....

             String output1 = formatOutput.format( fA [i-1] );
             System.out.print(" " + output1 );

             // end of लाइन को प्रिंट करो ....

             if (i % NoColumns == 0 || i == fA.length ) 
                 System.out.println("");
       }

       // [g] अक्षरों का array बना कर उसे प्रिंट करो

       String [] saNames = { "Coronet Peak",
                                 "Heavenly",
                                     "Vail",
                       "Whistler/Blackcomb" };

       System.out.println("");
       System.out.println("Length of saNames = " + saNames.length );

       System.out.println("");
       System.out.println("Array: saNames");
       for ( i = 0; i < saNames.length; i = i + 1)
            System.out.println( saNames [i] );

   }
}
  

Calculating time for Mathematical operation

प्रोग्राम को समझने के लिए कुछ गणीत के फोर्मुले आना आवश्यक है जैसे किसी भी त्रिकोण की

hypotenuse निकालने का फ़ॉर्मूला है बाकि दो sides का square करना . दूसरा फ़ॉर्मूला sin thetaऔर cos theta के square का जोड़ 1 होता है.

/**
 * यह प्रोग्राम कुछ Mathematical प्रॉब्लम को फलायेगा और उसका उत्तर स्क्रीन पर 
 * दिखायेगा .  इसके बाद यह बताएगा की कंप्यूटर ने टास्क करने में कितना समय 

* लिया.
 */

public class TimedComputation {
   
   public static void main(String[] args) {
   
      long startTime; // प्रोग्राम शुरू होने का समय, in milliseconds.
      long endTime;   // समय जब फलवत पूरी हो चुकी होगी , in milliseconds.
      double time;    // दोनो के बीच का समय, in seconds.
      
      startTime = System.currentTimeMillis();
      
      double width, height, hypotenuse;  // त्रिकोन की sides 
      width = 40.0;
      height = 15.0;
      hypotenuse = Math.sqrt( width*width + height*height ); // सबसे लम्बी 

// लाइन जिसे hypotenuse कहते है की फलावट 
      System.out.print("A triangle with sides 40 and 15 has hypotenuse ");
      System.out.println(hypotenuse);
      
      System.out.println("\nMathematically, sin(x)*sin(x) + "
                                       + "cos(x)*cos(x) - 1 should be 0.");
      System.out.println("Let's check this for x = 1:");
      System.out.print("      sin(1)*sin(1) + cos(1)*cos(1) - 1 is ");
      System.out.println( Math.sin(1)*Math.sin(1) 
                                        + Math.cos(1)*Math.cos(1) - 1 );
      System.out.println("(There can be round-off errors when" 
                                      + " computing with real numbers!)");
      
      System.out.print("\nHere is a random number:  ");
      System.out.println( Math.random() );
      
      endTime = System.currentTimeMillis();
      time = (endTime - startTime) / 1000.0;
      
      System.out.print("\nRun time in seconds was:  ");
      System.out.println(time);
   
   } //  main() का अंत
   
} //  class TimedComputation का अंत 

Leap Year Program

/*************************************************************************
 *  Compilation:  javac LeapYear.java
 *  Execution:    java LeapYear N
 *  

 *  प्रिंट true अगर N लीप इयर है तोह वरना false प्रिंट करो 

 *  माना के N >= 1582, Gregorian कैलेंडर के अनुसार .
 *
 *  % java LeapYear 2004
 *  true
 *
 *  % java LeapYear 1998
 *  false
 *************************************************************************/ 

public class LeapYear {   // सबसे पहले पब्लिक क्लास लीप इयर को शुरू करो, याद रखो क्लास का पहला अक्षर बड़ा hoga
    public static void main(String[] args) {    // प्रोग्राम का द्वार रट लो इस कमांड को

        int year = Integer.parseInt(args[0]); //   साल integer है, और console से integer array को parse करो

         boolean isLeapYear; // boolean true और false का datatype है 

          // लीप इयर को फलाने का तरीका है की वोह साल ४ से जाना चाहिए पर १०० से नहीं जाए 

         //जब तक की वोह ४०० से भी नहीं जाता हो   

         // divisible by 4 , चेक करो की यह चार से divide होता है या नहीं 

        isLeapYear = (year % 4 == 0);

 // divisible by 4 and not 100,चार से हो तोह १०० से नहीं होना चाहिए     

        isLeapYear = isLeapYear && (year % 100 != 0);

 // divisible by 4 and not 100 unless divisible by 400, अगर १०० से है तोह ४०० से भी हो   

        isLeapYear = isLeapYear || (year % 400 == 0);

        System.out.println(isLeapYear);
    }
}

Using Loops in Java

 जावा में लूप्स एक बहुत ही महत्वपूर्ण विषय है | इसको समझने के लिए हम दो प्रोग्राम देखेंगे एक वोह जो हम बिना लूप के बनायेंगे और दूसरा वोह जहा हम लूप का प्रयोग करेंगे |  इन दोनों प्रोग्राम्स को देखने के बाद आप खुद मानेगे की लूप कितने आवश्यक है|

/*************************************************************************
 *
 *  यहाँ "Hello, World" को दस बार प्रिंट करना है | आपको येही प्रोग्राम लूप की मदद 
  *  से आसानी से प्रिंट करना इसके बाद में बतओंगा.
 *************************************************************************/

public class TenHelloWorlds    {    // यहाँ हमने पब्लिक क्लास (पब्लिक का मतलब इसको बहार से 

                                      // से भी एक्सेस कर सकते है
 
    public static void main(String[] args)    {   // प्रोग्राम का मुख्य द्वार , रट लो इसको 
        System.out.println("Hello, World");// (System.out)Console पर प्रिंट करो(print)

                                           //  और लाइन बदलो(ln) 
        System.out.println("Hello, World");
        System.out.println("Hello, World");
        System.out.println("Hello, World");
        System.out.println("Hello, World");
        System.out.println("Hello, World");
        System.out.println("Hello, World");
        System.out.println("Hello, World");
        System.out.println("Hello, World");
        System.out.println("Hello, World");
    }

}

  ऊपर प्रोग्राम में आपने देखा आपने दस बार प्रिंट करने के लिए दस बार कमांड लिखा | 

अब सोचिये अगर हज़ार बार प्रिंट करना हो तो क्या करेंगे?? क्या हज़ार बार इस कमांड को लिखेंगे !! 

नहीं अब लूप का उपयोग देखिये :

public class TenHelloWorlds    {    // यहाँ हमने पब्लिक क्लास (पब्लिक का मतलब इसको बहार से 

                                     // से भी एक्सेस कर सकते है
    public static void main(String[] args)    {   // प्रोग्राम का मुख्य द्वार , रट लो इसको        
        for (int i = 0; i < 10; i++) {      // i को 0 से शुरू करो, चेक करो दस से कम है 

                                            // या नहीं??
        System.out.println("Hello, World"); // हां है तोह प्रिंट करो,और ऊपर जाओ 
  
                                       }
    }

} 

इस प्रोग्राम को समझने के लिए आपको फॉर लूप को समझना होगा , फॉर लूप को ध्यान से देखिये| तीन चीज़ लिखी 

है इसमें | सबसे पहले int i = 0 ( मतलब इ एक integer है और उसकी value zero है| दूसरी i < १० ,

यह इ पर condition है की वोह दस से ज्यादा नहीं हो सकता | और तीसरा i++ , जिसे हम i= i+ 1 भी कह   सकते है,   का मतलब जब लूप ख़तम हो जाये 

 तब इ में एक plus करो और फिर condition( i < 10 वाली )चेक करो|

public class HelloWorld {

		public static void main(String[] args) {
		
		for(int i=0;i<10;i++) {
		System.out.println("Hello,World");
				      }
							}
			}

Compute the amount of interest

/**
 * निचे दी गयी क्लास १७००० ( 17000) रुपये को ०.०७ (0.07)के ब्याज दर पर दिए गए 
 * क़र्ज़ के एक साल के ब्याज की फलावट करती है 
 * इसका उत्तर output पर प्रिंट होगा |
 */
 
public class Interest {
   
   public static void main(String[] args) {
   
       /* सबसे पहले कंप्यूटर को variables की जानकारी देना इसे अंग्रेजी में declare the variables भी कहते है */
   
       double principal;     // कितना रूपया ब्याज पर दिया है उसकी संख्या 
       double rate;          // सालाना ब्याज दर 
       double interest;      // सालाना ब्याज 
       
       /* यहाँ फलावट होगी  */
       
       principal = 17000;
       rate = 0.07;
       interest = principal * rate;   // ब्याज को फल रहे है 
       
       principal = principal + interest;
             // एक साल के ब्याज को मूल के साथ जोड़ रहे है .
             // (Note: यहाँ कुल पैसा अब पिछले साल के पैसे से ज्यादा होगा.
             // हमने पिछले साल के पैसे की जगह अब उसके जोड़ को यहाँ स्टोर कर दिया है )
       /* आये हुए उतर का output */
             
       System.out.print("The interest earned is $");
       System.out.println(interest);
       System.out.print("The value of the investment after one year is $");
       System.out.println(principal);
                      
   } // main() function का अंत 
      
} //  class इंटेरेस्ट का अंत 

Quadratic Equation Java Program

कमांड्स जो इस प्रोग्राम को चलाने में काम आएगी :

इस प्रोग्राम को compile करने के लिए : javac Quadratic.java
Execute करने के लिए  :   java Quadatic b c ( b और c  की जगह कोई दो इन्टिजर डाले जैसे 3 5 )

प्रोग्राम की कोडिंग समझने के लिए आपको पहले quadratic equation के रूट को सोल्व करने का फ़ॉर्मूला पता होना आवश्यक है |

अगर हम किसी equation के दो root Alpha or Beta को मानते है तो वो इस प्रकार होंगे :

Alpha = -b + Sqrt of ( b²-4ac/ 2a)
Beta = -b - Sqrt of ( b²-4ac/ 2a)

इस प्रोग्राम को सरल बनाने के लिए हम a  की वैल्यू 1 ले रहे है । इसके परिणाम  स्वरुप अब हमारी  equation अब इस प्रकार हो जाएगी :
-b  +/- Sqrt of ( b²-4 * 1 *c/ 2 * 1) => -b  +/- Sqrt of ( b²-4c/ 2)

अब इस equation  के अनुसार हमे दो वेरिएबल की वैल्यू चाहिए , एक b और दूसरा c

हम यहाँ दो प्रोग्राम बनायेंगे एक जहा हम इन दोनों (b ,c ) की वैल्यू प्रोग्राम में ही डालेंगे और दूसरा जहा इनकी वैल्यू हम यूजर से मांगेगे ।

सिखने योग्य बाते :
1. मैथ क्लास का प्रयोग
2.वेरिएबल डिक्लेरेशन
3.टर्मिनल से वैल्यू प्राप्त करना
4.sqrt()  फंक्शन का प्रयोग
5.स्क्रीन पर वैल्यू प्रिंट करना

पहला प्रोग्राम :


public class Quadratic {

public static void main(String[] args) {
double b = 3; // यहाँ वैल्यूज हम प्रोग्राम में डाल  रहे है
double c = 5;

double discriminant = b*b - 4.0*c;
double sqroot = Math.sqrt(discriminant);

double root1 = (-b + sqroot) / 2.0;
double root2 = (-b - sqroot) / 2.0;

System.out.println(root1);
System.out.println(root2);
}
}


दूसरा प्रोग्राम  :

public class Quadratic {

public static void main(String[] args) {
double b = Double.parseDouble(args[0]); // यहाँ वैल्यूज यूजर से मांग रहे है
double c = Double.parseDouble(args[1]);

double discriminant = b*b - 4.0*c;
double sqroot = Math.sqrt(discriminant);

double root1 = (-b + sqroot) / 2.0;
double root2 = (-b - sqroot) / 2.0;

System.out.println(root1);
System.out.println(root2);
}
}

Integer Multiplication and Division

public class IntOps { 

    public static void main(String[] args) {
        int a = Integer.parseInt(args[0]);
        int b = Integer.parseInt(args[1]);
        int sum  = a + b;
        int prod = a * b;
        int quot = a / b;
        int rem  = a % b;

        System.out.println(a + " + " + b + " = " + sum);
        System.out.println(a + " * " + b + " = " + prod);
        System.out.println(a + " / " + b + " = " + quot);
        System.out.println(a + " % " + b + " = " + rem);
        System.out.println(a + " = " + quot + " * " + b + " + " + rem);
    }
}

सबसे पहली लाइन क्लास का नाम देने का काम कर रही है , साथ ही यह भी स्पष्ट कर रही है की यह क्लास 

पब्लिक क्लास होगी |

दूसरी लाइन में main function को define किया गया है , जो हमे हर प्रोग्राम में करना ही होगा | 

यह java को यह बताता है की प्रोग्राम का स्टार्ट कहा से है | 

तीसरी लाइन में integer ka input ko a में स्टोर कर रहे है और लाइन ४ में दुसरे integer को बी में 

स्टोर कर रहे है |

यह इनपुट हम प्रोग्राम को execute करते वक़्त ही दे देते है | निचे आपको इसका उदहारण भी देकने को मिलेगा|

बाकी program तो बहुत आसान है | मेरी राय में यह आपको देखते ही समझ में आ जायेंगा | sum में इसको 

जोड़ा जा रहा है | prod में इसका प्रोडक्ट लिया जा रहा है |

System.out.println कमांड प्रोग्राम को डिस्प्ले करने में use होती है |  

इस प्रोग्राम का आउटपुट इस प्रकार होगा :

 *  कमांड लाइन पर जाकर javac से इसको compile करना 

और फिर  java IntOps 1234 99 <----(value के साथ)
 *  1234 + 99 = 1333
 *  1234 * 99 = 122166
 *  1234 / 99 = 12
 *  1234 % 99 = 46
 *  1234 = 12 * 99 + 46
 * 
 *  % java IntOps 10 -3
 *  10 + -3 = 7
 *  10 * -3 = -30
 *  10 / -3 = -3
 *  10 % -3 = 1
 *  10 = -3 * -3 + 1
 *