Code10x

JVM, Java bytecode को run करता है (एक virtual computer)। JRE = JVM + libraries, जो program run करने के लिए चाहिए। JDK = JRE + compiler और tools, जो code लिखने/compile करने के लिए चाहिए।

Java code एक बार compile होकर bytecode (.class file) बनता है, जो किसी भी OS पर JVM के through चल सकता है — बिना दोबारा लिखे।

Bytecode universal है, सिर्फ़ JVM OS-specific होती है। हर OS अपनी JVM install करता है जो same bytecode को समझ लेती है — इसी वजह से code portable रहता है।

Primitive types (int, char, boolean, etc.) directly value store करते हैं और fixed size के होते हैं। Reference types (String, Array, Object) memory address store करते हैं जो actual object की तरफ़ point करता है।

int एक primitive type है। Integer एक wrapper class है जो int को object की तरह use करने देती है (जैसे Collections में) — इस process को autoboxing कहते हैं।

int=0, double=0.0, boolean=false, char=(खाली), और object references (String etc) = null। Local variables की कोई default value नहीं होती, उन्हें initialize करना ज़रूरी है।

'==' reference (memory address) compare करता है — दो objects same जगह हैं या नहीं। '.equals()' content/value compare करता है — जैसे दो Strings का text same है या नहीं।

User से keyboard input लेने के लिए — जैसे Scanner sc = new Scanner(System.in); sc.nextInt();

Class एक blueprint/template है जो बताती है कि object के पास कौनसे fields (data) और methods (behavior) होंगे।

Object class का real instance है, जो अपनी खुद की values रखता है और memory में बनता है जब 'new' keyword use करते हैं।

Encapsulation, Abstraction, Inheritance, और Polymorphism।

Data (fields) को private रखकर getter/setter से access देना। इससे data safe रहता है और ग़लती से बाहर से change नहीं होता।

Car चलाते वक़्त सिर्फ़ steering/pedal use करते हो, engine की internal working की चिंता नहीं करनी पड़ती — complex चीज़ छुपी होती है, सिर्फ़ ज़रूरी interface दिखता है।

Code reusability — common properties/behavior एक parent class में लिखकर, child classes उसे reuse कर सकती हैं बिना दोबारा लिखे।

नहीं, एक class सिर्फ़ एक class को extend कर सकती है (diamond problem से बचने के लिए)। लेकिन एक class multiple interfaces implement कर सकती है।

Same class में same method नाम, पर different parameters (number/type) — जैसे add(int,int) और add(int,int,int)। ये compile-time polymorphism है।

Child class, parent class के method को same signature के साथ अपने तरीक़े से दोबारा define करती है। ये run-time polymorphism है।

Overloading same class में होता है (parameters अलग), compile-time पर decide होता है। Overriding parent-child में होता है (signature same), run-time पर decide होता है।

एक special method जो class के नाम जैसा होता है और object बनाते वक़्त (new से) automatically call होती है, ताकि initial values set हो सकें।

Same class में multiple constructors, different parameters के साथ — जिससे object को अलग-अलग तरीक़े से बनाया जा सके।

अगर तुम खुद कोई constructor नहीं लिखते, तो Java automatically एक खाली (no-argument) constructor दे देता है।

Current object को refer करने के लिए — जैसे जब constructor parameter और field का नाम same हो, this.name = name लिखते हैं।

Parent class के constructor, method या field को refer/call करने के लिए use होता है child class के अंदर से।

static member class का होता है, किसी single object का नहीं — सब objects उसे share करते हैं। Object बनाए बिना भी ClassName.member से access कर सकते हो।

क्योंकि static method किसी object से बंधा नहीं होता — वो class-level होता है, इसलिए 'this' (जो current object refer करता है) उसका कोई मतलब नहीं रहता।

final variable की value change नहीं हो सकती (constant)। final method को override नहीं किया जा सकता। final class को extend नहीं किया जा सकता।

एक class जिसे directly 'new' से object नहीं बना सकते। इसमें कुछ methods complete और कुछ abstract (बिना body के) हो सकते हैं — child class को abstract methods complete करने पड़ते हैं।

एक पूरा contract जिसमें (traditionally) सिर्फ़ method signatures होते हैं, कोई implementation नहीं। Class 'implements' keyword से interface follow करती है।

अगर completely unrelated classes के बीच common behavior चाहिए (contract) तो Interface। अगर related classes के बीच कुछ common code share करना है तो Abstract class।

default और static methods add हो गए, जिनकी body हो सकती है — पहले interface में सिर्फ़ abstract methods ही allowed थे।

Program run होते वक़्त आने वाली एक unexpected problem/error, जैसे divide by zero या invalid array index — जो अगर handle ना हो तो program crash कर देती है।

Checked exceptions compile-time पर check होती हैं और handle करना ज़रूरी है (जैसे IOException)। Unchecked exceptions run-time पर आती हैं और handle करना optional है (जैसे NullPointerException)।

try में risky code लिखते हैं। अगर error आए, matching catch block उसे handle करता है। finally block हमेशा चलता है, error आए या ना आए।

throw एक exception को manually 'फेंकने' (raise करने) के लिए use होता है method के अंदर। throws method signature में बताता है कि ये method कौनसी exceptions दे सकता है।

जब तुम किसी null reference (जिसमें कोई object नहीं है) पर method call करने या field access करने की कोशिश करते हो।

बहुत rare cases में — जैसे अगर JVM खुद crash हो जाए (System.exit() call हो जाए try block में), तभी finally skip होता है।

Exception class (या RuntimeException) को extend करके अपनी class बनाते हैं — जैसे class InsufficientBalanceException extends Exception।

एक resizable (dynamic size) list जो List interface implement करती है — order maintain करती है, duplicates allow करती है, index से access होता है।

Array का size fixed होता है और primitive types भी store कर सकता है। ArrayList का size dynamically बढ़/घट सकता है, लेकिन सिर्फ़ objects store करता है।

Set interface implement करता है, सिर्फ़ unique values store करता है (duplicates automatically ignore हो जाते हैं), order guarantee नहीं होता।

Key-value pairs store करता है। हर key का hashcode calculate करके वो decide करता है value कहाँ store होगी, इसलिए key से value ढूँढना बहुत fast होता है।

List ordered है, duplicates allow करता है। Set सिर्फ़ unique values रखता है। Map key-value pairs में data store करता है।

ArrayList array-based है, random access (index से) fast है। LinkedList nodes की chain है, बीच में insert/delete fast है लेकिन random access slow है।

एक object जो Collection (List, Set, etc) के elements को एक-एक करके traverse करने देता है, hasNext() और next() methods के साथ।

Program के execution का एक independent flow/path — Java program कम से कम एक thread (main thread) में चलता है, और extra threads बनाकर parallel काम किया जा सकता है।

Thread class को extend करके, या Runnable interface को implement करके — दोनों में run() method लिखते हैं और start() से thread चलाते हैं।

start() एक नया thread बनाता है और उसमें run() को execute करता है (parallel)। Directly run() call करने से कोई नया thread नहीं बनता, वो normal method call जैसा ही चलता है (same thread में)।

जब multiple threads same data को एक साथ modify करने की कोशिश करें, तो synchronized एक वक़्त में सिर्फ़ एक thread को उस code block/method में आने देता है — data corrupt होने से बचाता है।

Security, thread-safety और performance के लिए — String Pool में same value के Strings share हो सकते हैं सिर्फ़ तभी जब वो change ना हो सकें। इससे memory भी बचता है।

String immutable है। StringBuilder mutable है but thread-safe नहीं (fast, single-thread के लिए best)। StringBuffer भी mutable है और thread-safe है (synchronized, थोड़ा slow)।

Widening छोटे type को बड़े में automatically convert करता है (जैसे int->double), कोई loss नहीं। Narrowing बड़े को छोटे में manually cast करना पड़ता है (जैसे double->int), data (decimal) खो सकता है।

Primitive type (जैसे int) को automatically उसके wrapper class object (Integer) में convert करना, जैसे Collections में primitive store करने के लिए।

Method को variable की value की copy मिलती है, original variable change नहीं होता। Objects के case में reference की copy मिलती है, इसलिए object के अंदर के changes दिखते हैं, पर reference खुद reassign नहीं होता।

Recursion में method खुद को call करता है। Base case वो condition है जहाँ recursion रुकता है — अगर ना हो तो StackOverflowError आ जाएगा (infinite calls)।

अगर case के बाद break ना लगाएं, तो control अगले case में भी चला जाता है, चाहे वो match ना करे — इसको fall-through कहते हैं।

int[][] grid = new int[3][4]; से 3 rows और 4 columns का grid बनता है, grid[row][col] से access होता है।

HashMap/HashSet correctly काम करने के लिए — अगर दो objects equals() से equal हैं, तो उनका hashCode() भी same होना चाहिए, वरना Collections में unexpected behavior आ सकता है।

ClassName@hashcode जैसा (जैसे Point@1b6d3586) — इसलिए usually override करके readable format दिया जाता है।

Static nested class outer object के बिना भी बना सकते हो (independent)। Inner (non-static) class को outer class के एक object की ज़रूरत होती है, और वो outer के instance members access कर सकती है।

जब एक class की सिर्फ़ एक बार, तुरंत ज़रूरत हो (जैसे event listener) — नाम दिए बिना, inline define कर देते हैं।

Type-safety मिलती है — सिर्फ़ predefined constants ही allowed होते हैं, ग़लत/random values compile-time पर ही reject हो जाते हैं।

Type-safety और code reusability — एक ही class/method कई types के साथ काम कर सकता है, और ग़लत type डालने पर compiler तुरंत error देता है।

अगर कोई modifier ना लिखो, तो member सिर्फ़ उसी package के अंदर accessible होता है, बाहर के package से नहीं।

Related classes का group/folder — code organize करता है और naming conflicts से बचाता है (जैसे java.util, java.io)।

Comparable (compareTo method) class के अंदर define होता है और उसकी "natural ordering" बताता है। Comparator (compare method) class के बाहर लिखा जाता है और custom/multiple orderings देने देता है।

First-In-First-Out — जो element सबसे पहले add हुआ वही सबसे पहले remove होता है, जैसे एक ticket line।

एक छोटा, नाम-less function जो एक functional interface (सिर्फ़ एक abstract method वाला interface) को तुरंत implement करता है — जैसे (a, b) -> a + b।

Collections पर filter, map, sort जैसे operations को chain करके, बिना manual loops लिखे, छोटे और readable code में लिख सकते हैं।

एक interface जिसमें सिर्फ़ एक ही abstract method हो — जैसे Runnable, Comparator। ये lambda expressions के target type होते हैं।

Resource (जैसे file, connection) को automatically close कर देता है जब try block खत्म होता है, चाहे error आए या ना आए — manually close() call करने की ज़रूरत नहीं।

File को line-by-line, fast तरीक़े से पढ़ने के लिए — ये internal buffering करता है जो बार-बार disk read करने से better performance देता है।

एक ही catch block में '|' operator से multiple exception types पकड़ना, जैसे catch (IOException | SQLException e) { } — code duplication कम करता है।

बड़े projects में specific error types को organize करने के लिए — जैसे एक base AppException से PaymentException, LoginException जैसी specific exceptions बनती हैं, जिन्हें अलग-अलग या एक साथ catch किया जा सकता है।

New, Runnable, Running, Waiting/Blocked, और Terminated।

जब दो (या ज़्यादा) threads एक-दूसरे के पास जो resource है उसका इंतज़ार करते रह जाते हैं, और कोई भी आगे नहीं बढ़ पाता — program हमेशा के लिए अटक जाता है।

एक thread pool manager जो threads को manually बनाने/manage करने के बजाय, ready threads को reuse करता है — better resource management देता है।

Stack method calls और local variables store करती है (fast, auto-clean)। Heap objects store करती है (जो 'new' से बनते हैं), और ये तब तक रहते हैं जब तक कोई reference use ना करे।

जब उस object की कोई reference (किसी भी variable से) बची ना हो — तब वो "unreachable" हो जाता है और GC eligible बन जाता है।

Class पहली बार load होते ही सिर्फ़ एक बार चलता है — object बनाने से पहले भी, static variables initialize करने के लिए use होता है।

Object को bytes के stream में convert करना (जैसे file में save करने या network पर भेजने के लिए) — class को Serializable interface implement करना पड़ता है। वापस object बनाने को deserialization कहते हैं।

int, char, String, और enum जैसे types पर — Java 7+ में String भी switch में use हो सकती है।

जैसे एक chessboard या spreadsheet — rows और columns दोनों चाहिए, जैसे seating chart या tic-tac-toe board।