Sunday, August 28, 2011

What are objects ?

इसके पहले की हम जावा के ऑब्जेक्ट की बात करे , में  आपका ध्यान हमारी ऱोज  काम में आने वाली चीज़े और उनके बनाने के तरीके के बारे में बात करना चाहूँगा । उदहारण के लिए आपके सामने रखे  कंप्यूटर को लीजिये । अब सोचिये की क्या इसको किसी एक व्यक्ति अथवा एक कंपनी ने बनाया है । अगर आप का उत्तर हा है तो में आपका बताना चाहता हूँ की ऐसा नहीं है । आपके कंप्यूटर के हर भाग को किसी दूसरी कंपनी ने बनाया है , और जो कम्पनी का नाम आपके कंप्यूटर पर लिखा है उसने तो उन सभी पार्ट्स को सिर्फ अस्सेम्ब्ल  किया है ।

अब आप में से कुछ लोग सोच रहे होंगे की इसका जावा के ऑब्जेक्ट से क्या कनेक्शन है ? 
अब सोचिये की अगर एक ही कंपनी कंप्यूटर के सारे हिसे खुद बनाये तो कंप्यूटर बनाना कितना मुश्किल होगा ! इसीलिए कंप्यूटर का हर ओज्बेक्ट (पार्ट ) अलग अलग बनता है , और फिर उसे जोड़ कर पूरा कंप्यूटर ।
येही काम ऑब्जेक्ट oriented भाषा में होता है , जहा अलग अलग ओब्जेक्ट्स को जोड़ कर प्रोग्राम लिखा जाता है । और एक ही बार लिखे गए कोड का कही बार प्रयोग किया जाता है ।

 object oriented technology को समझने के लिए ऑब्जेक्ट को समझना बहुत आवश्यक है,आप जब आपके चारो और देखेंगे तो पाएंगे की इसके कही उदहारण है जैसे टेबल ,मेज , कुर्सी ,कुत्ता , बिल्ली  ।

इन सभी ओजेक्ट्स में दो बात सबसे अहेम होती है, एक तो इनकी अपनी कुछ पहचान होती है एवं दूसरा इनका कुछ कार्य होता है. जैसे की बिल्ली का नाम होता है,रंग होता है, जाती  होती है ,कुछ.क्रियाय होती हैजैसे दोड़ना,कूदना ,एक तरीके से बोलना .  दुसरे उदाहरण के लिए आप  साइकल को ले सकते है उसमे गेअर होते है,  पेडल होते है, उसकी कुछ रफ़्तार होती है और ऐसे ही कुछ खास बाते जो सभी साइकल में सामान होती है

सॉफ्टवेर ऑब्जेक्ट भी बिलकुल असली जीवन के ऑब्जेक्ट की तरह होते है . इनकी भी अपनी  अलग पहचान(state) or क्रियाय (behaviour) होता है. यह ऑब्जेक्ट अपनी पहचान variable में स्टोर करता  है और अपना behavioral method(functions) के द्वारा उपयोग करता है

 software object को एक उदहारण के साथ समझिये :

असली ज़िन्दगी में cycle का software object में हम उसकी गति (speed) , gear , और बाकी सभी states को variable में स्टोर करेंगे . और behaviors जैसे गति बढाना ,gear बदलना इन सबको behaviour method के द्वारा काम में लेंगे | इसका प्रोग्राम आप यहाँ से देख सकते है.


Tuesday, August 23, 2011

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] );

   }
}
  

Saturday, August 20, 2011

What are Constructors ?

जावा में constructors हमेशा क्लास के नाम के ही होते है और उनका पहला अक्षर क्लास की ही तरह बड़ा होता है  | constructors कभी कोई value return नहीं करते है void भी नहीं  | Value return का मतलब जावा में नए लोग शायद समझे नहीं , इसको साधारण तरीके से ऐसे समझा जा सकता है की function में सारी फलावट करने के बाद जो उत्तर आता है उसको return value कहते है |
Constructor को समझने के लिए तीन बाते याद रखना बहुत जरूरी है :

  • यह एक प्रकार का फंक्शन होता है जो क्लास के इंस्टांस को शुरू करने में प्रयोग होता है ।
  • इसका कोई return टाइप नहीं होता 
  • इसको ओवरलोड किया जा सकता है जैसे एक ही नाम के दो या उससे अधिक constructor हो सकते है अलग अलग arguments के साथ 
Constructor अलग अलग तरीके के parameter(जो function के bracket में लिखते है) ले सकता है | नीचे example में,हम दो constructors के बारे में जानेगे |

public class Constructor1 { //public(बहार से access हो सके ) क्लास का declaration जिसका नाम Constructor1 है

int length; // lenght variable integer type का होगा 
int breadth;
int height;
public int getVolume() {                 // volume निकालने का function
return (length * breadth * height);
}
Constructor1() {                        // बिना parameters का constructor
length = 10;
breadth = 10;
height = 10;
}
Constructor1(int l, int b, int h) { // तीन parameters int l,int b int h के साथ constructor 
length = l; //lenght variable mein l को store kar
breadth = b;
height = h;
}
public static void main(String[] args) {
Contructor1 contructorObj1, constructorObj2;
constructorObj1 = new Contructor1();
contructorObj2 = new Contructor1(10, 20, 30);


System.out.println("Volume of Constructor1 is : " + constructorObj1.getVolume());
System.out.println("Volume of Constructor1 is : " + constructorObj2.getVolume());
}
}

Thursday, August 18, 2011

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 का अंत 

Saturday, August 13, 2011

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);
    }
}

Friday, August 12, 2011

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");
				      }
							}
			}

Monday, August 8, 2011

What are Classes?

जावा एक object oriented भाषा है . इसको समझने के लिए पहले आपको क्लास को समझना जरूरी है . सबसे पहले में आपको यह बता दू की अंग्रेजी में ऑब्जेक्ट का मतलब होता है कोई वस्तु,  उदहारण के लिए आप किसी कुर्सी को ले सकते है , टेबल को , या पंखे को , कोई भी वस्तु जो आपके दिमाग में आये | आप पाएंगे की इन सभी ऑब्जेक्ट को आप कही अलग हिस्सों में बाट सकते है . जैसे टेबल कही प्रकार की हो सकती है , कितनी ही कंपनीयो द्वारा बनायीं जा सकती है | लेकिन इन सभी टेबलों में कुछ समानता भी है जैसे यह सभी टेबल के चार पैर है | इन सभी की लम्बाई और चोडाइ है | अब अगर हमे कोई प्रोग्राम बिना क्लास और ऑब्जेक्ट की मदद के बनाना हो तो हमें हर टेबल को अलग define करना होगा और उसकी साइज़ को बताने के लिए भी अलग integer declare करने होंगे |

पर चुकी हमारे पास जावा है , हमें ऐसा करने में कोई परेशानी नहीं होगी | इसको में आपको एक प्रोग्राम की मदद से समझिएगा | इस प्रोग्राम में हम object साइकिल के बारे में बात करेंगे और देखेंगे के कैसे एक साइकिल क्लास , उसके constructor एवं उसके method को प्रयोग में लाया जाता है |


public class Cycle {
 
    //  यहाँ हम जावा को बता रहे की हम तीन fields का प्रयोग करेंगे  
    //  cadence मतलब होता है की एक मिनट में साईकिल चलाने वाला कितने पैडल मार रहा है ।

    public int cadence; // यहाँ हम एक फिएल्ड को declare कर रहे है | और बता रहे है की वो पब्लिक है । 
    public int gear;
    public int speed;
 
    //  यह जावा का एक constructor है . इसके बारे में चर्चा बाद में करेंगे
    public Cycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }
 
    // इस क्लास के चार मेथड है, दो में हम field में संख्या संगृहीत करते है , और बाकि 
    //दो में स्पीड को बढाने , घटाने का काम करते है   
    public void setCadence(int newValue) {
        cadence = newValue;
    }
 
    public void setGear(int newValue) {
        gear = newValue;
    }
 
    public void applyBrake(int decrement) {
        speed -= decrement;
    }
 
    public void speedUp(int increment) {
        speed += increment;
    }
 
}
    

अलगी पोस्ट में इसी  बात को आगे discuss करेंगे




Saturday, August 6, 2011

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 इंटेरेस्ट का अंत 

LinkWithin

Related Posts Plugin for WordPress, Blogger...