Theory
6000 Books, हर एक की 5 Variables
Unit 1 में, BookBridge ने एक book को loose variables में store किया: title, section, copies, price, available।
College library में लगभग 6000 books हैं। Unit 1 style follow करते हुए, यह 30000 variables है, title47 को copies47 से जोड़ने वाला कुछ नहीं सिवाय उन्हें naming करने में आपकी discipline के।
एक book के facts together belong करते हैं। Togetherness के लिए Java की unit class है, और यह lesson आख़िरकार BookBridge को उसका Book देता है।
Theory
Index Card Template
Old libraries हर book के लिए एक index card रखती थीं: एक printed template (Title: ___, Copies: ___) और हज़ारों filled-in cards।
एक class printed template है: यह list करता है हर book के पास क्या facts हैं, पर खुद कोई book नहीं है। एक object एक filled card है: एक real book के लिए real values। Template एक बार print करना और कई cards stamp करना exactly class Book एक बार है, new Book() कई बार।
Theory
Class और Field, Formally
एक class एक user-defined blueprint है जो data और उस पर काम करने वाले methods को group करता है। Data slots को fields (या instance variables) कहा जाता है।
class Book {
String title;
int copies;
}
new से एक object create कीजिए, dot operator से इसके fields तक पहुँचिए:
Book b1 = new Book();
b1.title = "Let Us C";
BCA304 veterans के लिए note: Java में class के closing brace के बाद कोई semicolon नहीं; C++ ने एक demand किया।
Practical
एक Template से दो Cards
class Book {
String title; // fields: every Book gets its own
int copies;
}
public class BookBridge {
public static void main(String[] args) {
Book b1 = new Book();
b1.title = "Let Us C";
b1.copies = 5;
Book b2 = new Book();
b2.title = "Java Complete Reference";
b2.copies = 2;
b2.copies = b2.copies - 1; // issue one copy of b2 only
System.out.println(b1.title + " | " + b1.copies);
System.out.println(b2.title + " | " + b2.copies);
}
}
Theory
हर Object अपने Fields Owns करता है
Listing run कीजिए: b1 अभी भी 5 copies दिखाता है, b2 1 दिखाता है। b2 की copy issue करना सिर्फ़ b2 की copies field को touch करता है।
यही rule है: हर new instance fields का एक fresh, independent set allocate करता है। Class एक बार load होती है; data per object multiply होता है।
तो "3 Books create करने के बाद कितने title variables exist करते हैं?" का एक precise answer है: 3, हर object के अंदर एक, plus class खुद में 0।
Quiz
BookBridge 3 Book objects create करता है। Memory में title field की कितनी separate copies exist करती हैं?
- 1, सारे Book objects से shared
- 3, हर object के अंदर एक
- 0 जब तक title को एक value assign न किया जाए
- यह depend करता है कौन सा constructor इस्तेमाल हुआ
Show the answer
3, हर object के अंदर एक
Instance fields objects की होती हैं, तो 3 objects का मतलब है 3 independent title slots; एक बदलना दूसरों को कभी disturb नहीं करता। Option A एक static field describe करता है, जिससे आप इस unit में बाद में मिलेंगे। Option C assignment को allocation से confuse करता है: slot new के moment से exist करता है, एक default value hold करते हुए। Constructors (option D) initial values decide करते हैं, कितने fields exist करते हैं यह नहीं।
Think first
वह Field जो आपने कभी Set नहीं किया
Book b = new Book(); System.out.println(b.copies); आपने कभी copies assign नहीं किया। Tap करने से पहले: error, garbage value, या कुछ और?
Show the answer
यह 0 print करता है। Java हर field को एक automatic default देता है: numeric types के लिए 0, boolean के लिए false, String जैसी references के लिए null (तो b.title null print करेगा)। दो contrasts marks के लायक हैं: C ने आपको garbage दिया, और Java के methods के अंदर के local variables को कोई default NAHI मिलता; assign करने से पहले एक इस्तेमाल करना एक compile error है। Fields defaults के साथ born होते हैं, locals empty born होते हैं।
Watch out
Blueprint Building नहीं है
class Book { ... } लिखना books के लिए कोई memory allocate नहीं करता। Students "एक class define करना एक object create करता है" लिखते हैं और mark खो देते हैं: class सिर्फ़ plan है; fields के लिए memory हर new पर appear होती है।
दूसरा trap: Book b; अकेले एक reference declare करता है जो कहीं point नहीं करता (null)। b = new Book(); से पहले b.title touch करना happily compile होता है और फिर runtime पर एक NullPointerException throw करता है, Java का सबसे famous crash।
Theory
Card को अगला एक Front Desk मिलता है
अभी कोई भी code किसी भी card पर scribble कर सकता है: b1.copies = -50; happily compile होता है। एक real library अपने records guard करती है: आप एक change request करते हैं और system rules apply करता है। वह guarding अगले 2 lessons हैं: access controls decide करते हैं कौन एक field touch कर सकता है, और constructors ensure करते हैं कि कोई Book कभी half-filled born न हो। BCA304 का CanteenTill same path follow करता था: पहले data, फिर protection।
Summary
Key takeaways
- एक class related data (fields) और behaviour को एक blueprint में group करता है; एक object इसका एक live instance है।
- class Book { String title; int copies; } template define करता है; new Book() एक fresh object stamp करता है।
- हर object हर instance field की एक independent copy owns करता है।
- Fields को automatic defaults मिलते हैं (0, false, null); local variables को कुछ नहीं मिलता।
- एक declared पर unassigned reference null है; इसे इस्तेमाल करना NullPointerException throw करता है।
- Java में class brace के बाद कोई semicolon नहीं, C++ के विपरीत।
- Memory hook: class printed card है, new एक fresh copy stamp करता है।