Java Academy · पाठ

Records का परिचय

Records को संक्षिप्त immutable data holders के रूप में घोषित करें और उनके अपने-आप बनने वाले members को समझें।

पाठ 1, कुल 4 में से13 चरण

Records का परिचय, CoddyKit पर Java Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Java Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

रिकॉर्ड का परिचय

Java Records (Java 16+) अपरिवर्तनीय डेटा-वाहक वर्ग घोषित करने का संक्षिप्त तरीका हैं। ये अपने-आप बॉयलरप्लेट तैयार करते हैं: कंस्ट्रक्टर, गेटर, equals, hashCode और toString।

रिकॉर्ड घोषित करना

record कीवर्ड के बाद रिकॉर्ड का नाम और कॉम्पोनेंट सूची लिखें। प्रत्येक कॉम्पोनेंट एक private final फ़ील्ड और एक public एक्सेसर विधि बन जाता है।

record Point(double x, double y) {}

Point p = new Point(3.0, 4.0);
System.out.println(p.x());      // 3.0 (accessor, not getX())
System.out.println(p.y());      // 4.0
System.out.println(p);          // Point[x=3.0, y=4.0]
System.out.println(p.equals(new Point(3.0, 4.0))); // true

स्वतः तैयार होने वाले सदस्य

कंपाइलर प्रत्येक रिकॉर्ड के लिए अपने-आप ये सदस्य तैयार करता है: कैनोनिकल कंस्ट्रक्टर, public एक्सेसर, equals(), hashCode(), toString()। इन्हें हाथ से लिखने की आवश्यकता नहीं होती।

record Product(String name, double price, int stock) {}

Product p1 = new Product("Widget", 9.99, 100);
Product p2 = new Product("Widget", 9.99, 100);

System.out.println(p1.name());          // Widget
System.out.println(p1.price());         // 9.99
System.out.println(p1.equals(p2));      // true (structural)
System.out.println(p1.hashCode() == p2.hashCode()); // true
System.out.println(p1);                 // Product[name=Widget, price=9.99, stock=100]

रिकॉर्ड अपरिवर्तनीय होते हैं

रिकॉर्ड कॉम्पोनेंट final होते हैं। निर्माण के बाद आप उन्हें संशोधित नहीं कर सकते—रिकॉर्ड अपरिवर्तनीय मान ऑब्जेक्ट का रूप प्रस्तुत करते हैं।

record Money(long cents, String currency) {}

Money price = new Money(999, "USD");
// price.cents = 500; // Compile error — final field!

// To "update" a record, create a new one
Money discounted = new Money(price.cents() - 100, price.currency());
System.out.println(discounted); // Money[cents=899, currency=USD]

रिकॉर्ड केवल Object का विस्तार करते हैं

रिकॉर्ड अंतर्निहित रूप से java.lang.Record का विस्तार करते हैं और अन्य वर्गों का विस्तार नहीं कर सकते। वे इंटरफ़ेस लागू कर सकते हैं।

interface Describable { String describe(); }

record Circle(double radius) implements Describable {
    public String describe() {
        return String.format("Circle with radius %.1f", radius);
    }

    public double area() {
        return Math.PI * radius * radius;
    }
}

Circle c = new Circle(5.0);
System.out.println(c.describe()); // Circle with radius 5.0
System.out.printf("Area: %.2f%n", c.area()); // Area: 78.54

संग्रहों में रिकॉर्ड

रिकॉर्ड सभी कॉम्पोनेंट के आधार पर equals और hashCode को सही ढंग से लागू करते हैं, इसलिए वे Map की कुंजियों और Set के तत्वों के रूप में सही ढंग से काम करते हैं।

import java.util.*;

record Coordinate(int row, int col) {}

Map<Coordinate, String> grid = new HashMap<>();
grid.put(new Coordinate(0, 0), "Origin");
grid.put(new Coordinate(1, 2), "Target");

// Lookup with equal-valued record works correctly
System.out.println(grid.get(new Coordinate(0, 0))); // Origin
System.out.println(grid.get(new Coordinate(1, 2))); // Target

Set<Coordinate> visited = new HashSet<>();
visited.add(new Coordinate(3, 3));
System.out.println(visited.contains(new Coordinate(3, 3))); // true

DTO के रूप में रिकॉर्ड

REST API में डेटा ट्रांसफ़र ऑब्जेक्ट (DTO) के लिए रिकॉर्ड आदर्श होते हैं—वे व्यवहार के बिना परतों के बीच डेटा ले जाते हैं।

record CreateUserRequest(String email, String displayName, String plan) {}

record UserResponse(long id, String email, String displayName,
                    String plan, String createdAt) {}

// Simulating a service call
static UserResponse createUser(CreateUserRequest req) {
    long id = 42L;
    return new UserResponse(id, req.email(), req.displayName(),
        req.plan(), java.time.Instant.now().toString());
}

CreateUserRequest req = new CreateUserRequest("alice@example.com", "Alice", "PRO");
UserResponse resp = createUser(req);
System.out.println(resp);

रिकॉर्ड को विघटित करना

रिकॉर्ड पैटर्न मिलान के साथ अच्छी तरह काम करते हैं। आप उन्हें switch अभिव्यक्तियों में विघटित कर सकते हैं (Java 21+)।

sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
record Triangle(double base, double height) implements Shape {}

static double area(Shape s) {
    return switch (s) {
        case Circle(double r)            -> Math.PI * r * r;
        case Rectangle(double w, double h) -> w * h;
        case Triangle(double b, double h) -> 0.5 * b * h;
    };
}

System.out.printf("%.2f%n", area(new Circle(5)));         // 78.54
System.out.printf("%.2f%n", area(new Rectangle(4, 6)));   // 24.00

रिकॉर्ड का सीरियलाइज़ेशन

घोषणा में Serializable लागू करने पर रिकॉर्ड स्वाभाविक रूप से सीरियलाइज़ किए जा सकते हैं। वे JSON लाइब्रेरी (Jackson, Gson) के साथ बिना अतिरिक्त व्यवस्था के अच्छी तरह काम करते हैं।

// With Jackson (add @JsonProperty if needed)
import com.fasterxml.jackson.databind.ObjectMapper;

record OrderSummary(String orderId, double total, String status) {}

ObjectMapper mapper = new ObjectMapper();
OrderSummary order = new OrderSummary("ORD-001", 149.99, "SHIPPED");

String json = mapper.writeValueAsString(order);
System.out.println(json);
// {"orderId":"ORD-001","total":149.99,"status":"SHIPPED"}

OrderSummary restored = mapper.readValue(json, OrderSummary.class);
System.out.println(order.equals(restored)); // true

नेस्टेड रिकॉर्ड

रिकॉर्ड में अन्य रिकॉर्ड को कॉम्पोनेंट के रूप में रखा जा सकता है, जिससे समृद्ध अपरिवर्तनीय ऑब्जेक्ट ग्राफ़ बनाए जा सकते हैं।

record Address(String street, String city, String country) {}
record Customer(long id, String name, Address address) {}

Address addr = new Address("123 Main St", "New York", "US");
Customer customer = new Customer(1L, "Alice", addr);

System.out.println(customer.name());              // Alice
System.out.println(customer.address().city());   // New York
System.out.println(customer);                    // Customer[id=1, name=Alice, address=Address[street=123 Main St, city=New York, country=US]]

रिकॉर्ड की सीमाएँ

रिकॉर्ड पर लागू कुछ प्रतिबंधों का ध्यान रखें:

  • अन्य वर्गों का विस्तार नहीं कर सकते (अंतर्निहित रूप से Record का विस्तार करते हैं)
  • कॉम्पोनेंट हमेशा final होते हैं—परिवर्तनशील स्थिति नहीं रखी जा सकती
  • कॉम्पोनेंट सूची के बाहर इंस्टेंस फ़ील्ड घोषित नहीं कर सकते
  • abstract नहीं हो सकते
// Records CAN have static fields and methods
record Temperature(double celsius) {
    static final double ABSOLUTE_ZERO = -273.15;

    public double toFahrenheit() {
        return celsius * 9.0/5.0 + 32;
    }

    public static Temperature fromFahrenheit(double f) {
        return new Temperature((f - 32) * 5.0/9.0);
    }
}
System.out.println(Temperature.fromFahrenheit(98.6)); // Temperature[celsius=37.0]

त्वरित जाँच

Java कंपाइलर रिकॉर्ड के लिए कौन-से सदस्य अपने-आप तैयार करता है?

पुनरावृत्ति: रिकॉर्ड का परिचय

मुख्य बातें:

  • रिकॉर्ड कम से कम बॉयलरप्लेट के साथ अपरिवर्तनीय डेटा-वाहक घोषित करते हैं
  • अपने-आप तैयार होने वाले सदस्य: कैनोनिकल कंस्ट्रक्टर, एक्सेसर, equals, hashCode और toString
  • कॉम्पोनेंट final होते हैं—डिज़ाइन के अनुसार रिकॉर्ड अपरिवर्तनीय होते हैं
  • रिकॉर्ड इंटरफ़ेस लागू कर सकते हैं, लेकिन वर्गों का विस्तार नहीं कर सकते
  • DTO, मान ऑब्जेक्ट और API प्रतिक्रियाओं के लिए बिल्कुल उपयुक्त
  • संरचनात्मक समानता के कारण HashMap की कुंजियों और HashSet के तत्वों के रूप में सही ढंग से काम करते हैं
शुरुआत निःशुल्क

एआई शिक्षक के साथ Java सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
104
पाठ
374

अक्सर पूछे जाने वाले प्रश्न

क्या “Records का परिचय” पाठ निःशुल्क है?

हाँ—“Records का परिचय” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Java Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Records का परिचय” में मैं क्या सीखूँगा?

Records को संक्षिप्त immutable data holders के रूप में घोषित करें और उनके अपने-आप बनने वाले members को समझें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Java Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Java Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Java Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“Records का परिचय” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Java Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Java Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. Records का परिचय
  2. Compact Constructors और Validation
  3. Records में Custom Methods
  4. Records बनाम Classes बनाम Lombok
← Java Academy पर वापस जाएँ