> For the complete documentation index, see [llms.txt](https://www.pranaypourkar.co.in/the-programmers-guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/oop-basics/what-is-an-object.md).

# What is an Object?

## About

In Java, an **object** is an instance of a class that contains **state (fields/variables)** and **behavior (methods)**. Objects are created based on the blueprint defined by a class.

## **Characteristics of an Object**

1. **State (Attributes)** 
   * Represented by **instance variables** (fields).
   * Stores the data or properties of the object.
2. **Behavior (Methods)** 
   * Defined by **functions inside the class**.
   * Determines what actions an object can perform.
3. **Identity (Reference)** 
   * Each object has a unique memory address in the heap.

## **Example of an Object**

```java
// Class Definition
class Car {
    String brand;  // Attribute
    int speed;

    // Constructor
    Car(String brand, int speed) {
        this.brand = brand;
        this.speed = speed;
    }

    // Method (Behavior)
    void accelerate() {
        speed += 10;
        System.out.println(brand + " is now going at " + speed + " km/h.");
    }
}

// Main Class
public class Main {
    public static void main(String[] args) {
        // Creating Objects
        Car car1 = new Car("Toyota", 50);
        Car car2 = new Car("Honda", 40);

        // Accessing Object Methods
        car1.accelerate();  // Toyota is now going at 60 km/h.
        car2.accelerate();  // Honda is now going at 50 km/h.
    }
}
```

## **How Objects Work in Memory**

1. Objects are created in the **heap memory**.
2. The **reference variable** (like `car1` and `car2`) points to the object in memory.
3. Multiple reference variables can point to the same object.

```java
Car car3 = car1;  // Now both car1 and car3 point to the same object
```

## When is the object created with new keyword

In Java, the object is created with the `new` keyword during **runtime**.

The `new` keyword plays a crucial role in the object creation process:

1. **Memory Allocation:** It triggers the allocation of memory for the new object on the heap. The heap is a special area of memory dedicated to storing objects in Java.
2. **Constructor Call:** It invokes the constructor of the class specified after `new`. The constructor is responsible for initializing the object's state by assigning values to its fields.

Therefore, the `new` keyword initiates object creation and memory allocation at runtime, not during compilation. This allows for dynamic object creation based on your program's needs.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/oop-basics/what-is-an-object.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.