जावा क्या है और प्रोग्राम कैसे चलता है
जावा 1995 में बनी एक सामान्य-उपयोग भाषा है। मुख्य विचार: एक बार लिखो, कहीं भी चलाओ।
- सोर्स कोड
Hello.javaफ़ाइल में लिखो। - कंपाइलर
javacउसे बाइटकोड (Hello.class) बनाता है। - JVM (जावा वर्चुअल मशीन) बाइटकोड को किसी भी कंप्यूटर पर चलाती है।
public class Hello {
public static void main(String[] args) {
System.out.println("Hello, world");
}
}हर प्रोग्राम main से शुरू होता है। हर कथन (statement) के अंत में सेमीकोलन; ब्लॉक { } में। जावा केस-सेंसिटिव है: Age और age अलग नाम हैं। टिप्पणी: // एक पंक्ति, /* कई पंक्तियाँ */।
डेटा टाइप, वेरिएबल और स्थिरांक
वेरिएबल मेमोरी में नाम वाला डिब्बा है। उपयोग से पहले टाइप बताना ज़रूरी: int marks = 85;
| टाइप | क्या रखता है | आकार |
|---|---|---|
| byte, short, int, long | पूर्ण संख्याएँ | 1, 2, 4, 8 बाइट |
| float, double | दशमलव | 4, 8 बाइट |
| char | एक यूनिकोड अक्षर, जैसे 'A' | 2 बाइट |
| boolean | true या false | - |
ये 8 प्रिमिटिव टाइप हैं। String, ऐरे और ऑब्जेक्ट रेफ़रेंस टाइप हैं। final वेरिएबल स्थिरांक है: final double PI = 3.14159;। नाम: अक्षर, _ या $ से शुरू, बीच में स्पेस नहीं, class जैसा कीवर्ड नहीं।
टाइप कास्टिंग: छोटे से बड़ा अपने आप (double d = 5;); बड़े से छोटा कास्ट से (int n = (int) 7.9; = 7)।
ऑपरेटर
- अंकगणितीय: + − * / %। पूर्णांक भाग में दशमलव हट जाता है:
7 / 2= 3;7 % 2(शेषफल) = 1। - तुलनात्मक: == != < > <= >= का उत्तर boolean।
- तार्किक: && (और), || (या), ! (नहीं)।
- असाइनमेंट: =, +=, -=, *=, /=।
- इन्क्रीमेंट:
i++पहले उपयोग फिर 1 जोड़ता है;++iपहले जोड़ता है। - टर्नरी:
result = (marks >= 33) ? "Pass" : "Fail";
प्राथमिकता: * / % पहले, फिर + −; साफ़ रखने को कोष्ठक लगाओ।
नियंत्रण प्रवाह: if, switch और लूप
if (marks >= 90) grade = 'A';
else if (marks >= 75) grade = 'B';
else grade = 'C';switch कई तय मानों में से एक चुनता है (break से रुको, वरना अगला case भी चलेगा)।
- for: जब पता हो कितनी बार:
for (int i = 0; i < 5; i++)। - while: पहले जाँचता है, शून्य बार भी चल सकता है।
- do…while: कम से कम एक बार चलता है, बाद में जाँचता है।
breakलूप से बाहर;continueअगले चक्कर पर।
उदाहरण: 1 से 10 का योग: int s = 0; for (int i = 1; i <= 10; i++) s += i; = 55।
ऐरे और स्ट्रिंग
ऐरे एक टाइप के कई मान रखता है: int[] m = {70, 85, 92}; या new int[3]। इंडेक्स 0 से, आख़िरी इंडेक्स m.length − 1। उससे आगे जाने पर ArrayIndexOutOfBoundsException। 2-D ऐरे एक तालिका है: int[][] t = new int[3][4];।
String टेक्स्ट वाला ऑब्जेक्ट है। स्ट्रिंग अपरिवर्तनीय (immutable) है: मेथड नई स्ट्रिंग लौटाते हैं।
length(),charAt(i),substring(a, b),indexOf("x")toUpperCase(),trim(),concat()या +- टेक्स्ट की तुलना
equals()से, == से नहीं।
लूप में बहुत जोड़ना हो तो StringBuilder।
OOP और क्लास डिज़ाइन
क्लास एक नक्शा है जिसमें फ़ील्ड (डेटा) और मेथड (काम) होते हैं। ऑब्जेक्ट उससे new से बनी एक चीज़ है।
class Student {
private String name; private int marks;
Student(String n, int m) { name = n; marks = m; } // कंस्ट्रक्टर
boolean passed() { return marks >= 33; }
}
Student s = new Student("Asha", 60);- एनकैप्सुलेशन: फ़ील्ड
private, बाहर के लिए getter/setter। - इनहेरिटेंस:
class Topper extends Studentकोड दोबारा उपयोग। - पॉलिमॉर्फ़िज़्म: ओवरलोडिंग (एक नाम, अलग पैरामीटर) और ओवरराइडिंग (बच्चा क्लास पैरेंट का मेथड बदले)।
- एब्स्ट्रैक्शन: abstract क्लास और interface "क्या" बताते हैं, "कैसे" नहीं।
staticसदस्य क्लास का होता है, हर ऑब्जेक्ट का नहीं;this= वर्तमान ऑब्जेक्ट।
एक्सेप्शन और असर्शन
एक्सेप्शन रन-टाइम पर होने वाली गड़बड़ी है, जैसे पूर्णांक को शून्य से भाग या गायब फ़ाइल खोलना। उसे सँभालो ताकि प्रोग्राम न टूटे:
try { int r = a / b; }
catch (ArithmeticException e) { System.out.println("शून्य से भाग नहीं"); }
finally { System.out.println("Done"); }चेक्ड एक्सेप्शन (जैसे IOException) पकड़ना या throws से घोषित करना ज़रूरी; अनचेक्ड (जैसे NullPointerException) प्रोग्रामिंग गलती से। throw से खुद भी फेंक सकते हो।
असर्शन टेस्टिंग में जाँचता है कि जो सच होना चाहिए वह सच है: assert marks >= 0 : "marks negative";। ये डिफ़ॉल्ट बंद रहते हैं, java -ea से चालू; उपयोगकर्ता इनपुट जाँचने में इनका उपयोग नहीं।
रैपर क्लास और थ्रेड
रैपर क्लास प्रिमिटिव को ऑब्जेक्ट में लपेटती हैं: int → Integer, double → Double, char → Character, boolean → Boolean। ArrayList<Integer> जैसे संग्रह को ऑब्जेक्ट चाहिए। जावा अपने आप बदलती है (ऑटोबॉक्सिंग, अनबॉक्सिंग)। उपयोगी: Integer.parseInt("42"), Double.parseDouble("2.5"), Character.isDigit(c)।
थ्रेड एक प्रोग्राम के अंदर काम का अलग रास्ता है, जैसे फ़ाइल डाउनलोड होती रहे और स्क्रीन भी चलती रहे। Thread को extend करो या Runnable implement करो, फिर start() (न कि run())। अवस्थाएँ: new → runnable → running → waiting/blocked → terminated। साझा डेटा पर synchronized एक समय में एक ही थ्रेड को बदलने देता है।
खुद करके देखो
3D में n = 6 करो और देखने से पहले arr[5] का अनुमान लगाओ (25)। फिर जावा वाले कंप्यूटर पर for लूप से 7 का पहाड़ा छापो, और break से 7 × 5 पर रोक दो।
मुख्य सूत्र और परिभाषाएँ
- कंपाइल और रन: javac Hello.java → java Hello
- ऐरे इंडेक्स: 0 से length − 1
- पूर्णांक भाग: 7 / 2 = 3; 7 % 2 = 1
- for (शुरुआत; शर्त; बदलाव) { काम }
- ऑब्जेक्ट: ClassName obj = new ClassName(args);
- try { … } catch (Type e) { … } finally { … }
- ऑटोबॉक्सिंग: int → Integer; Integer.parseInt("12") → 12
हल किए गए उदाहरण
1. यह क्या छापेगा? int a = 17, b = 5; System.out.println(a / b + " " + a % b);
पूर्णांकों में a / b = 3 (दशमलव हटा) और a % b = 2। आउटपुट: 3 2।
2. 2 से 20 तक की सभी सम संख्याएँ जोड़ने वाला लूप लिखो।
int s = 0; for (int i = 2; i <= 20; i += 2) s += i; योग 2 + 4 + … + 20 = 110।
3. int[] m = {45, 88, 67, 91, 30} में सबसे बड़ा मान ढूँढो।
int max = m[0]; for (int i = 1; i < m.length; i++) if (m[i] > max) max = m[i]; क्रम: 45 → 88 → 88 → 91 → 91। उत्तर 91।
4. String s = "Java"; System.out.println(s.charAt(4)); से क्या होगा?
मान्य इंडेक्स 0 से 3 हैं, इसलिए charAt(4) रन-टाइम पर StringIndexOutOfBoundsException देगा।
5. BankAccount क्लास बनाओ: private balance, जमा करने और निकालने का मेथड, शून्य से नीचे नहीं।
class BankAccount { private double balance; void deposit(double x) { if (x > 0) balance += x; } boolean withdraw(double x) { if (x <= balance) { balance -= x; return true; } return false; } double getBalance() { return balance; } } private balance और जाँच = एनकैप्सुलेशन।
6. "250" को संख्या बनाकर 50 जोड़ो और छापो, गलत इनपुट सँभालो।
try { int n = Integer.parseInt("250"); System.out.println(n + 50); } catch (NumberFormatException e) { System.out.println("संख्या नहीं"); } आउटपुट 300।
आम गलतियाँ
- स्ट्रिंग की तुलना == से करना: == देखता है कि ऑब्जेक्ट एक ही है या नहीं, टेक्स्ट नहीं। equals() लगाओ।
- arr[arr.length] को आख़िरी मान समझना: आख़िरी इंडेक्स length − 1 है।
- 7 / 2 = 3.5 समझना: दो int का उत्तर 3 है। 7.0 / 2 लिखो।
- थ्रेड पर start() की जगह run() बुलाना: run() उसी थ्रेड में चलता है।