levels of precedence of operators in java

 In Java, operators have different levels of precedence, which determines the order in which they are evaluated in an expression. Here's a general overview of operator precedence in Java, listed from highest to lowest precedence:

1. **Postfix operators:**

   - `expr++` (Post-increment)

   - `expr--` (Post-decrement)

2. **Unary operators:**

   - `++expr` (Pre-increment)

   - `--expr` (Pre-decrement)

   - `+expr` (Unary plus)

   - `-expr` (Unary minus)

   - `!expr` (Logical NOT)

   - `~expr` (Bitwise NOT)

   - `(type) expr` (Type cast)

3. **Multiplicative operators:**

   - `*` (Multiplication)

   - `/` (Division)

   - `%` (Modulus)

4. **Additive operators:**

   - `+` (Addition)

   - `-` (Subtraction)

5. **Shift operators:**

   - `<<` (Left shift)

   - `>>` (Right shift with sign extension)

   - `>>>` (Right shift with zero extension)

6. **Relational operators:**

   - `<` (Less than)

   - `>` (Greater than)

   - `<=` (Less than or equal to)

   - `>=` (Greater than or equal to)

   - `instanceof` (Type comparison)

7. **Equality operators:**

   - `==` (Equal to)

   - `!=` (Not equal to)

8. **Bitwise AND:**

   - `&`

9. **Bitwise XOR:**

   - `^`

10. **Bitwise OR:**

    - `|`

11. **Logical AND:**

    - `&&`

12. **Logical OR:**

    - `||`

13. **Conditional (Ternary) operator:**

    - `? :`

14. **Assignment operators:**

    - `=`

    - `+=`

    - `-=`

    - `*=`

    - `/=`

    - `%=`

    - `&=`

    - `^=`

    - `|=`

    - `<<=`

    - `>>=`

    - `>>>=`

Operators with higher precedence are evaluated before those with lower precedence. Parentheses `( )` can be used to override the default precedence and explicitly specify the order of evaluation. For example, expressions inside parentheses are always evaluated first.

Understanding operator precedence is important for writing correct and predictable expressions in Java.

operators in java

 In Java, operators are symbols that perform operations on variables and values. Here are some of the commonly used operators in Java:

1. **Arithmetic Operators:**

   - Used to perform mathematical operations.

   - `+` (Addition), `-` (Subtraction), `*` (Multiplication), `/` (Division), `%` (Modulus)

   Example:

   ```java

   int a = 10, b = 20;

   int sum = a + b; // 30

   int difference = a - b; // -10

   int product = a * b; // 200

   int quotient = b / a; // 2

   int remainder = b % a; // 0

   ```

2. **Comparison (Relational) Operators:**

   - Used to compare two values.

   - `==` (Equal to), `!=` (Not equal to), `>` (Greater than), `<` (Less than), `>=` (Greater than or equal to), `<=` (Less than or equal to)

   Example:

   ```java

   int x = 5, y = 10;

   boolean isEqual = (x == y); // false

   boolean isNotEqual = (x != y); // true

   boolean isGreaterThan = (x > y); // false

   ```

3. **Logical Operators:**

   - Used to perform logical operations.

   - `&&` (Logical AND), `||` (Logical OR), `!` (Logical NOT)

   Example:

   ```java

   boolean condition1 = true, condition2 = false;

   boolean resultAnd = (condition1 && condition2); // false

   boolean resultOr = (condition1 || condition2); // true

   boolean resultNot = !condition1; // false

   ```

4. **Assignment Operators:**

   - Used to assign values to variables.

   - `=` (Assignment), `+=` (Add and assign), `-=` (Subtract and assign), `*=` (Multiply and assign), `/=` (Divide and assign), `%=` (Modulus and assign)

   Example:

   ```java

   int num = 5;

   num += 3; // num is now 8 (5 + 3)

   num -= 2; // num is now 6 (8 - 2)

   ```

5. **Increment and Decrement Operators:**

   - Used to increase or decrease the value of a variable by 1.

   - `++` (Increment), `--` (Decrement)

   Example:

   ```java

   int count = 10;

   count++; // count is now 11

   count--; // count is now 10

   ```

6. **Conditional (Ternary) Operator:**

   - Provides a concise way to implement a simple if-else statement.

   - `? :` (Conditional Operator)

   Example:

   ```java

   int a = 5, b = 10;

   int max = (a > b) ? a : b; // max is 10

   ```

These are some of the fundamental operators in Java. Understanding how to use them is crucial for writing effective and expressive code.

Type Casting (Type Conversion) in Java जावा में टाइप कास्टिंग (टाइप कन्वर्शन)

Under type casting, a data type is converted into another data type within a specific statement or expression. In Java, there are two types of type casting:

टाइप कास्टिंग के अंतर्गत किसी विशेष स्टेटमेंट या एक्सप्रेशन में एक डेटाटाइप को दुसरे डेटाटाइप में परिवर्तित किया जाता है। जावा में निम्न दो प्रकार की टाइप कास्टिंग होती है-

a) Widening Casting (Implicitly): Converting a smaller data type to a larger data type is called widening casting or implicit casting.

a) वाइडिंग कास्टिंग (स्वचालित रूप से)- एक छोटे डेटा टाइप को एक बड़े डेटा टाइप के आकार में परिवर्तित करना, वाइडिंग कास्टिंग या स्वचालित कास्टिंग या इम्प्लिसिट कास्टिंग कहलाता है।

byte -> short -> char -> int -> long -> float -> double

Example:-

int i = 5;

double j = i; // Implicit casting - from int to double

System.out.println(i); // Output: 5

System.out.println(j); // Output: 5.0

b) Narrowing Casting (Manually):- Converting a larger data type to a smaller data type is called narrowing casting or explicit casting.

b) नर्रोविंग कास्टिंग (मैन्युअल रूप से)- एक बड़े डेटाटाइप को एक छोटे डेटाटाइप के आकार में परिवर्तित करना, नर्रोविंग कास्टिंग या मैन्युअल कास्टिंग या एक्स्प्लिसिट कास्टिंग कहलाता है।

double -> float -> long -> int -> char -> short -> byte

Example:-

double i = 5.76;

int j = (int) i; // Explicit casting - from double to int

System.out.println(i); // Output: 5.76

System.out.println(j); // Output: 5

In the examples, the first one demonstrates implicit casting where an `int` is implicitly cast to a `double`. The second one shows explicit casting where a `double` is explicitly cast to an `int`. Understanding these casting mechanisms is essential for handling different data types in Java.

उदाहरणों में, पहला अंतर्निहित कास्टिंग को दर्शाता है जहां एक `int` को अंतर्निहित रूप से `डबल` में डाला जाता है। दूसरा स्पष्ट कास्टिंग दिखाता है जहां `डबल` को स्पष्ट रूप से `int` पर डाला जाता है। जावा में विभिन्न डेटा प्रकारों को संभालने के लिए इन कास्टिंग तंत्रों को समझना आवश्यक है।

data types in Java जावा में डेटा के प्रकार

In Java, data types are used to define the type of data that a variable can hold. Java supports two types of data types:

जावा में, डेटा प्रकारों का उपयोग उस डेटा के प्रकार को परिभाषित करने के लिए किया जाता है जिसे एक वेरिएबल धारण कर सकता है। जावा दो प्रकार के डेटा प्रकारों का समर्थन करता है:

1. Primitive Data Types:- These are the basic data types that store simple values. 

There are eight primitive data types in Java:-

1. आदिम डेटा प्रकार:- ये मूल डेटा प्रकार हैं जो सरल मान संग्रहीत करते हैं। जावा में आठ आदिम डेटा प्रकार हैं:-

byte      8-bit signed integer.

short     16-bit signed integer.

int         32-bit signed integer.

long      64-bit signed integer.

float      32-bit floating-point number.

double  64-bit floating-point number.

char      16-bit Unicode character.

boolean Represents true or false.

Examples:-

byte myByte = 10;

short myShort = 1000;

int myInt = 100000;

long myLong = 1000000000L; // Note the 'L' suffix for long literals

float myFloat = 3.14f; // Note the 'f' suffix for float literals

double myDouble = 3.14159;

char myChar = 'A';

boolean myBoolean = true;

2. Reference Data Types:- These data types refer to objects. Reference data types do not contain the actual data stored in a variable but contain a reference (memory address) to the location where the data is stored.like:-

2. संदर्भ डेटा प्रकार:- ये डेटा प्रकार वस्तुओं को संदर्भित करते हैं। संदर्भ डेटा प्रकारों में एक चर में संग्रहीत वास्तविक डेटा नहीं होता है बल्कि उस स्थान पर एक संदर्भ (मेमोरी पता) होता है जहां डेटा संग्रहीत होता है।जैसे:-

a.) String - A sequence of characters.

स्ट्रिंग - वर्णों का एक क्रम.

String myString = "Hello, Java!";

b.) Array - A collection of elements of the same type.

सारणी - एक ही प्रकार के तत्वों का संग्रह।

int[] myArray = {1, 2, 3, 4, 5};

c.) Class - User-defined data type.

कक्षा - उपयोगकर्ता-परिभाषित डेटा प्रकार।

class Person {

String name;

int age;

}

Person myPerson = new Person();

myPerson.name = "John";

myPerson.age = 30;

d.) Interface - Defines a set of methods.

इंटरफ़ेस - विधियों के एक सेट को परिभाषित करता है।

interface Shape {

void draw();
}
class Circle implements Shape {
public void draw() {
System.out.println("Drawing a circle");
}
}

These data types provide the building blocks for writing Java programs, and understanding them is essential for effective programming in Java.

ये डेटा प्रकार जावा प्रोग्राम लिखने के लिए बिल्डिंग ब्लॉक प्रदान करते हैं, और जावा में प्रभावी प्रोग्रामिंग के लिए उन्हें समझना आवश्यक है।

scope of a variable in java जावा में वेरिएबल का कार्यक्षेत्र

In Java, the scope of a variable is the region within a Java program where the variable can be accessed. The scope of a variable can be classified into three types:

जावा में, वेरिएबल का कार्यक्षेत्र उस क्षेत्र को कहा जाता है जिसमें वेरिएबल को एक्सेस किया जा सकता है। यहाँ तीन प्रकार के वेरिएबल के कार्यक्षेत्र हैं:-

1. Local Variable:-

- Local variables are declared and used only within a method or a block `{}`.

- Their scope and lifetime are limited to that method or block.

- As soon as the program control goes outside the method, these variables cease to exist.

- In Java, unlike C and C++, two variables with the same name cannot be declared in a nested block (inner and outer block). Each block's variable must have a different name.

1. लोकल वेरिएबल:-

- लोकल वेरिएबल किसी मेथड या ब्लॉक `{}` के भीतर ही घोषित और प्रयुक्त किए जाते हैं।

- इनका कार्यक्षेत्र और जीवन केवल उस मेथड या ब्लॉक तक सीमित होता है।

- जब प्रोग्राम कंट्रोल मेथड से बाहर जाता है, तो ये वेरिएबल समाप्त हो जाते हैं।

- जावा में, सी और सी++ की भांति, एक ही नाम के दो वेरिएबल एक साथ एक नेस्टेड ब्लॉक (इनर और आउटर ब्लॉक) में घोषित नहीं किए जा सकते हैं। प्रत्येक ब्लॉक के वेरिएबल का नाम भिन्न होना चाहिए।

2. Instance Variable:-

- These variables are declared within a class and are instantiated when an object of that class is created.

- Each object of the class has its own copy of instance variables.

- They exist as long as the object exists.

2. इंस्टैंस वेरिएबल:-

- ये वेरिएबल्स किसी क्लास के भीतर घोषित किए जाते हैं और जब उस क्लास के ऑब्जेक्ट को बनाया जाता है, तो ये इंस्टैंसिएट हो जाते हैं।

- क्लास के प्रत्येक ऑब्जेक्ट के पास अपना कॉपी होता है।

- ये तब तक मौजूद रहते हैं जब तक ऑब्जेक्ट मौजूद होता है।

3. Class Variable:-

- Class variables function like global variables for a class.

- They are shared among all objects of the class.

- Each class variable is stored in memory only once, regardless of the number of objects created for that class.

3. क्लास वेरिएबल:-

- ये वेरिएबल्स किसी क्लास के लिए एक साझा वेरिएबल का कार्य करते हैं।

- इन्हें क्लास के सभी ऑब्जेक्ट्स के बीच साझा किया जाता है।

- प्रत्येक क्लास वेरिएबल को मेमोरी में केवल एक ही बार स्थान ग्रहण किया जाता है, चाहे उस क्लास के लिए कितने भी ऑब्जेक्ट्स बने हों।

Example:-

public class VariableScopeExample {

    // Class variable

    static int globalVar = 10;

    public static void main(String[] args) {

        // Local variable

        int localVar = 5;

        System.out.println("Local Variable: " + localVar);

        System.out.println("Class Variable: " + globalVar);

        // Creating an object of SampleClass

        SampleClass obj = new SampleClass();

        // Accessing instance variable through object

        System.out.println("Instance Variable through Object: " + obj.instanceVar);

    }

}

class SampleClass {

    // Instance variable

    int instanceVar = 20;

}

variable in Java जावा में वेरिएबल

In Java, a variable is a named storage location that can hold a value. Variables are fundamental to programming, allowing developers to store and manipulate data in their programs. 

Here are some key points about variables in Java:

1. Declaration:-

Before you can use a variable, you must declare it. This involves specifying the variable's type and name. For example:

int age; // Declaration of an integer variable named "age"

2. Initialization:-

After declaring a variable, you can assign an initial value to it. This is known as initialization.

age = 50; // Initialization of the "age" variable with the value 50

Alternatively, you can combine declaration and initialization in a single line:

int age = 50; // Declaration and initialization in one line

3. Types:- Java is a statically-typed language, meaning that you must declare the type of a variable before using it. Common variable types include `int` (integer), `double` (floating-point number), `char` (character), `boolean` (boolean value), and more.

int count = 10;

double pi = 3.14;

char grade = 'A';

boolean isStudent = true;

4. Naming Rules:-

- Variable names must begin with a letter, dollar sign ($), or underscore (_).

- Subsequent characters can be letters, digits, dollar signs, or underscores.

- Variable names are case-sensitive.

- Java has reserved words that cannot be used as variable names (e.g., `int`, `float`, `class`).

5. Scope:- The scope of a variable refers to the region of the program where the variable can be used. In Java, variables can have different scopes, such as local scope (within a method or block), class scope (as a class field), or global scope (rarely used, but for constants).

public class Example {

// Class-level variable (field)

int globalVar = 5;

public void exampleMethod() {

// Local variable within a method

int localVar = 10;

System.out.println(localVar);

}

}

6. Final Keyword:- You can use the `final` keyword to make a variable a constant (its value cannot be changed once initialized).

final double PI = 3.14159;

Program:- 

public class SimpleInterest{

public static void main(String args[]){

// Declare variables for principal, rate, time, and simple interest

float p, r, t, si;

// Assign values to the variables

p = 1000; // Principal amount

r = 2; // Rate of interest

t = 5; // Time in years

// Calculate simple interest using the formula: SI = (P * R * T) / 100

si = (p * r * t) / 100;

// Print the calculated simple interest

System.out.println("Simple Interest is= " + si);

}

}

Constants (Literal) in Java जावा में स्थिरांक

In Java, a constant is a variable whose value cannot be changed once it has been assigned. Constants are typically used to represent fixed values that remain the same throughout the execution of a program. In Java, constants are often declared using the final modifier.

जावा में, स्थिरांक एक वेरिएबल है जिसका मान एक बार निर्दिष्ट होने के बाद बदला नहीं जा सकता है। स्थिरांक का उपयोग आमतौर पर निश्चित मानों को दर्शाने के लिए किया जाता है जो किसी प्रोग्राम के निष्पादन के दौरान समान रहते हैं। जावा में, स्थिरांक को अक्सर अंतिम संशोधक का उपयोग करके घोषित किया जाता है।

Syntax:-

final datatype constant_name=value;

Example:-

final double PI=3.14159;

In Java, a global constant typically refers to a constant variable that is accessible throughout a class or even across multiple classes within the same package. You can create a global constant by using the final modifier and often the static modifier.

जावा में, एक वैश्विक स्थिरांक आम तौर पर एक स्थिर चर को संदर्भित करता है जो एक कक्षा में या एक ही पैकेज के भीतर कई कक्षाओं में भी पहुंच योग्य होता है। आप final संशोधक और static  संशोधक का उपयोग करके एक वैश्विक स्थिरांक बना सकते हैं।

Syntax:-

static final datatype constant_name=value;

Example:-

static final double PI=3.14159;

Program:-

public class ConstantsExample {

// Declaration of constants

static final int MAX_VALUE = 100;

static final String GREETING = "Hello, World!";

static final double PI = 3.14159;

public static void main(String[] args) {

// Accessing constants within the main method

System.out.println("Max Value: " + MAX_VALUE);

System.out.println("Greeting: " + GREETING);

System.out.println("Value of PI: " + PI);

}

}

Java Programming Style जावा प्रोग्रामिंग की शैली

Programming style is a set of guidelines applied to use the instructions of a programming language correctly. Following a programming style is crucial because it helps the programmer understand the code easily, and it reduces the chances of errors. Here are some important rules for Java programming style-

प्रोग्रामिंग शैली, किसी प्रोग्रामिंग लैंग्वेज के निर्देशों को सही तरीके से उपयोग करने के लिए, लागु किये गए दिशानिर्देशों का एक समूह होता है। एक प्रोग्रामिंग शैली का पालन करना अत्यंत आवश्यक होता है क्योंकि इसकी सहायता से प्रोग्रामर, प्रोग्रामिंग कोड को आसानी से समझ सकता है एवं कम त्रुटियां उत्पन्न होती है। जावा प्रोग्रामिंग शैली के कुछ महत्वपूर्ण नियम निम्न है –

1. A Java program should be easy to read and understand by others, including users or specialist programmers.

एक जावा प्रोग्राम पढने एवं समझने में आसान होना चाहिए। अर्थात हमारे लिखे जावा प्रोग्राम को अन्य उपयोगकर्ता या विशेषज्ञ प्रोग्रामर के समझ में आने योग्य होना चाहिए।

2. Each class (excluding nested classes) should have Javadoc comments and an `@author` tag indicating the purpose of the class, all general interfaces, and the name of the programmer.

प्रत्येक क्लास (नेस्टेड कक्षाओं को छोड़कर) में जावाडॉक टिप्पणी एवं एक @author टैग होना चाहिए जो क्लास के उद्देश्य, सभी जनरल इंटरफ़ेस एवं प्रोग्रामर के नाम को दर्शाते हो।

3. Each method (excluding private methods) should have Javadoc comments explaining its purpose

प्रत्येक मेथड (प्राइवेट मेथड को छोड़कर) में जावाडॉक टिप्पणी होनी चाहिए जो बताती है कि यह क्या करती है।

4. Each variable should have a comment explaining its purpose.

प्रत्येक वेरिएबल में एक टिप्पणी होनी चाहिए जो उसके उद्देश्य की व्याख्या करे।

5. A method's body can include comments that explain the logic of the written code.

एक मेथड की बॉडी में, टिपण्णी को शामिल किया जा सकता है जो लिखे गए कोड के लॉजिक की व्याख्या कर सके।

6. Use indentation to show the structure of your Java program. For example, the main part of a class definition should be indented, a method definition's main part should be indented, and when one statement is written inside another, it should be indented one level more.

अपने जावा प्रोग्राम की संरचना को प्रदर्शित करने के लिए इंडेंटेशन का उपयोग करना चाहिए जैसे एक क्लास परिभाषा का मुख्य भाग इंडेंट होना चाहिए, एक मेथड परिभाषा का मुख्य भाग इंडेंट होना चाहिए एवं जब कोई स्टेटमेंट किसी अन्य स्टेटमेंट के अन्दर लिखा जाता है, तब वह अगले स्तर पर इंडेंट होना चाहिए।

7. A closing curly brace `}` should be on a separate line, and an opening curly brace `{` can be on the same line or a separate line to maintain alignment.

एक दाहिना मझला कोष्टक "}" एक पृथक पंक्ति में होना चाहिए एवं बायां मझला कोष्टक "{" स्वयं एक पंक्ति पर रखा जा सकता है जिससे यह आपस में संरेखित रहे।

8. Avoid placing more than one statement on a single line.

एक से अधिक स्टेटमेंट को एक पंक्ति में न रखें।

9. Break a long line into shorter lines.

एक लम्बी पंक्ति को छोटी-छोटी पंक्तियों में तोड़ा जाना चाहिए।

10. Include some space between method definitions to make the program easier to read.

मेथड परिभाषाओं के बीच कुछ रिक्त स्थान होना चाहिए जिससे प्रोग्राम को पढ़ने में आसानी हो।

11. Use meaningful names for variables, methods, and classes in Java. In Java, variable, method, and package names start with lowercase letters, while class names start with uppercase letters. When a name consists of more than one word, the first letter of each subsequent word is capitalized (camel case), such as `maxMarks`, `SimpleInterest`, etc.

प्रोग्राम में वेरिएबल, मेथड एवं क्लास हेतु सार्थक नामों का प्रयोग किया जाना चाहिए। जावा में वेरिएबल, मेथड, पैकेज के नाम अंग्रेजी के छोटे अक्षरों एवं क्लास के नाम बड़े अक्षरों से शुरू होते हैं। जब किसी नाम में एक से अधिक शब्द हों, तो अगले शब्द का पहला अक्षर बड़ा (कैमल केस) होता है जैसे maxMarks, SimpleInterest इत्यादि।

12. Use "final static" for constants and use "enum" to represent a group of related constants.

कांस्टेंट को दर्शाने के लिए "final static" का प्रयोग करें एवं एक दुसरे से सम्बंधित कांस्टेंट के समूह को दर्शाने के लिए "enum" का उपयोग करें।

13. Each method should have a clear and specific purpose, and the method's definition should not be too long.

प्रत्येक मेथड का एक स्पष्ट एवं विशिष्ट कार्य होना चाहिए एवं मेथड की परिभाषा बहुत लंबी नहीं होनी चाहिए।

14. Avoid using instance variables; instead, use parameters and return values for methods.

इंस्टेंस वेरिएबल्स से बचना चाहिए इसके स्थान पर मेथड के लिए पैरामीटर्स और रिटर्न वैल्यू का उपयोग करना चाहिए।

15. Represent each class with a clear, unique, and identifiable concept. The class should have appropriate use of public, private, and protected sections.

प्रत्येक क्लास को एक स्पष्ट, एकल, पहचान योग्य अवधारणा का प्रतिनिधित्व करना चाहिए एवं क्लास में पब्लिक, प्राइवेट एवं प्रोटेक्टेड भाग का सही-सही उपयोग होना चाहिए।

16. Class variables should generally be in the private section, and get and set methods should be in the public section.

क्लास के वेरिएबल को सामान्य रूप से प्राइवेट भाग में एवं गेट और सेट मेथड को पब्लिक भाग में रखा जाना चाहिए।

Java Environment जावा का वातावरण

Java Development Kit (JDK) is a software development environment used to create Java applications and applets. It includes Java Runtime Environment (JRE), a translator/loader (Java), a compiler (Javac), an archive (JAR), a documentation generator (Javadoc), and other tools related to Java development. The full name of JVM is Java Virtual Machine. It provides the runtime environment. It converts bytecode into machine code and ultimately runs the Java program. The full name of JRE is Java Runtime Environment. It is also called Java Runtime.

जावा डेवलपमेंट किट (जेडीके) एक सॉफ्टवेयर डेवलपमेंट वातावरण है जिसका उपयोग जावा एप्लिकेशन और एप्लेट्स को तैयार करने के लिए किया जाता है। इसके अंतर्गत जावा रनटाइम एनवायरनमेंट (जेआरई), एक ट्रांसलेटर/लोडर (जावा), एक कंपाइलर (जावैक), एक आर्काइव (जार), एक दस्तावेज जनरेटर (जावाडोक), और जावा के विकास से सम्बंधित अन्य टूल्स को रखा गया है। जेवीएम का पूरा नाम जावा वर्चुअल मशीन है। यह रनटाइम वातावरण उपलब्ध कराता है। यह बाइट कोड को मशीन कोड में परिवर्तित करता है तथा अंत में जावा प्रोग्राम को रन करता है। जेआरई का पूरा नाम जावा रुन्तिमे एनवायरनमेंट है। इसे जावा रनटाइम भी कहा जाता है। 

JRE, a crucial part of the Java Development Kit, is a group of software tools for developing Java applications. It is responsible for collecting the class libraries, groups of files, and other files that the JVM uses at runtime. If we want to run a Java program on the system, we need to install JRE, which is also developed by Sun Micro-systems.

जेआरई, जावा डेवलपमेंट किट का एक महत्वपूर्ण भाग होता है। यह जावा एप्लीकेशन को विकसित करने के लिए सॉफ्टवेयर टूल्स का एक समूह होता है। जेआरई, क्लास लाइब्रेरी के समूह तथा अन्य फाइल्स को संगृहीत करता है, जिसे रन टाइम पर जेवीएम प्रयोग करता है। यदि हम किसी जावा प्रोग्राम को सिस्टम में रन करना चाहते है तो हमे जेआरई इनस्टॉल करना होगा, इसे भी सन माइक्रोसिस्टम ने तैयार किया था।