The difference between Classes, Objects, and Instances

A class is a blueprint which you use to create objects. An object is an instance of a class - it's a concrete 'thing' that you made using a specific class. So, 'object' and 'instance' are the same thing, but the word 'instance' indicates the relationship of an object to its class.

This is easy to understand if you look at an example. For example, suppose you have a class House . Your own house is an object and is an instance of class House . Your sister's house is another object (another instance of class House ).

// Class House describes what a house is class House < // . >// You can use class House to create objects (instances of class House) House myHouse = new House(); House sistersHouse = new House(); 

The class House describes the concept of what a house is, and there are specific, concrete houses which are objects and instances of class House .

Note: This is exactly the same in Java as in all object oriented programming languages.

myHouse and myCar are objects myHouse is an instance of House (relates Object-myHouse to its Class-House) myCar is an instance of Car. Is this true , please see the above answer by user2390183 is it correct or not ?

Is it possible to have an object that is not the instance of a class? Just an object you declare by itself.

Java (and any other programming language) is modeled in terms of types and values. At the theoretical level, a value is a representation for some quantum of information, and a type is a set of values. When we say value X is an instance of type Y, we are simply saying that X is a member of the set of values that is the type Y.

So that's what the term "instance" really means: it describes a relationship not a thing.

The type system of the Java programming language supports two kinds of types, primitive types and reference types. The reference types are further divided into the classes and array types. A Java object is an instance of a reference type.

An object is a class instance or an array. (JLS 4.3.1)

That's the type theoretic view.

In practice, most Java developers treat the words "instance" and "object" as synonyms. (And that includes me then I'm trying to explain something quickly.) And most developers use the word "value" rather than "instance" to refer to an instance of a primitive type.

I really appreciate your answer sir, and I almost got it, just one more question. We say-"Whenever the compiler hits the 0 argument constructor it creates a instance of a class.". In this context what is really created an instance or an object? An object I guess and we use the word "instance" as synonym.But it would kind, if you better confirm it.

@Ryan: Basically yes: it is creating an Object which is an instance of the Class in question. (But note that the quoted sentence is saying "instance of a Class" rather than just "instance" . so the author is not actually using "instance" as a synonym here.)

@RuneFS - the "modelling" I am talking about is not about representation. It is theoretical. Yea, in some languages there are objects that denote types, or even that allow you to enumerate all of the instances of a type. But those properties augment the generic "modelling" rather than invalidating it.

@RuneFS - No . I am talking about "type theory". It is a branch of mathematics. It is independent of the technology that is used to run programs. The closest type theory gets to computation is lambda calculus. (If you are interested, try and get hold of a copy of "Types and Programming Languages" by Benjamin C. Pierce.)

You are making the same mistake as user2390183 . You are treating variables as "names". They are not. Variables are "reference holders" that contain references to objects. Objects don't have intrinsic names. The references are the closest thing that there is to a "name" for an object, except that they don't have a constant representation. (The GC can move an object which changes the bit pattern used to represent the reference.)

A class is basically a definition, and contains the object's code. An object is an instance of a class

for example if you say

String word = new String(); 

the class is the String class, which describes the object (instance) word.

When a class is declared, no memory is allocated so class is just a template.

When the object of the class is declared, memory is allocated.

Thanks david for the link. From the topics I got this Every real world things which have state and behaviour can be called as "object". And to classify these objects we use class(A class is the blueprint from which individual objects are created). And it says that, the objects of the class are instances. Now please someone tell me what is the differences between object and instance?Does this mean that object don't really exist in context of programming and instance represents object in it?

@Mustafa: I'm sorry to contradict you, but according to the JLS, an array is also an object in Java. And you'll find that the JLS does not define the term 'instance' at all. See my answer.

@Ryan: See my answer for the distinction between "instance" and "object". @Mustafa's answer and comment are (IMO) misleading.

@mustafabar - "When a class is declared, no memory is allocated so class is just a template." - And this isn't true either. Memory is allocated to (at least) represent the static variables of the class. (And for other things too that are related to the type identity of the class.)

I like Jesper's explanation in layman terms

By improvising examples from Jesper's answer,

class House < // blue print for House Objects >class Car < // blue print for Instances of Class Car >House myHouse = new House(); Car myCar = new Car(); 

myHouse and myCar are objects

myHouse is an instance of House (relates Object-myHouse to its Class-House) myCar is an instance of Car

"myHouse is an instance of Class House" which is same as saying "myHouse is an Object of type House"

Class is Data Type,You use this type to create object.

• Instance is Logical but object is Physical means occupies some memory.
• We can create an instance for abstract class as well as for interface, but we cannot create an
  object for those.
• Object is instance of class and instance means representative of class i.e object.
• Instance refers to Reference of an object.
• Object is actually pointing to memory address of that instance.
• You can’t pass instance over the layers but you can pass the object over the layers
• You can’t store an instance but you can store an object
• A single object can have more than one instance.
• Instance will have the both class definition and the object definition where as in object it will have only the object definition.

Syntax of Object:

 Classname var=new Classname(); 

But for instance creation it returns only a pointer refering to an object, syntax is :

 Classname varname; 

Class : Structure

Object : Physical Manifestation

Instance : each object created from class

Reference : Address of Object

Objects in the real world are physical. Objects in a computer program are not physical. (You can't touch them. They don't obey the laws of physics. Etcetera. And even the bit patterns in memory are representations of objects . not actual Java objects.)

Honestly, I feel more comfortable with Alfred blog definitions:

Object: real world objects shares 2 main characteristics, state and behavior. Human have state (name, age) and behavior (running, sleeping). Car have state (current speed, current gear) and behavior (applying brake, changing gear). Software objects are conceptually similar to real-world objects: they too consist of state and related behavior. An object stores its state in fields and exposes its behavior through methods.

Class: is a “template” / “blueprint” that is used to create objects. Basically, a class will consists of field, static field, method, static method and constructor. Field is used to hold the state of the class (eg: name of Student object). Method is used to represent the behavior of the class (eg: how a Student object going to stand-up). Constructor is used to create a new Instance of the Class.

Instance: An instance is a unique copy of a Class that representing an Object. When a new instance of a class is created, the JVM will allocate a room of memory for that class instance.

Given the next example:

public class Person < private int id; private String name; private int age; public Person (int id, String name, int age) < this.id = id; this.name = name; this.age = age; >public int hashCode() < final int prime = 31; int result = 1; result = prime * result + id; return result; >public boolean equals(Object obj) < if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (id != other.id) return false; return true; >public static void main(String[] args) < //case 1 Person p1 = new Person(1, "Carlos", 20); Person p2 = new Person(1, "Carlos", 20); //case 2 Person p3 = new Person(2, "John", 15); Person p4 = new Person(3, "Mary", 17); >> 

For case 1, there are two instances of the class Person, but both instances represent the same object.

For case 2, there are two instances of the class Person, but each instance represent a different object.

So class, object and instance are different things. Object and instance are not synonyms as is suggested in the answer selected as right answer.

In java, the objects are spawned on heap memory. These require reference to be pointed and used in our application. The reference has the memory location of the object with which we can use the objects in our application. A reference in short is nothing but a name of the variable which stores the address of the object instantiated on a memory location.

An instance is a general term for object . FYI, Object is a class.

Class A < >A ref = new A(); 

For the above code snippet, ref is the reference for an object of class A generated on heap.

If you have a program that models cars you have a class to represent cars, so in Code you could say:

Car someCar = new Car(); 

someCar is now an instance of the class Car. If the program is used at a repairshop and the someCar represents your car in their system, then your car is the object.

So Car is a class that can represent any real world car someCar is an instance of the Car class and someCare represents one real life object (your car)

however instance and object is very often used interchangably when it comes to discussing coding

Any kind of data your computer stores and processes is in its most basic representation a row of bits. The way those bits are interpreted is done through data types. Data types can be primitive or complex. Primitive data types are - for instance - int or double. They have a specific length and a specific way of being interpreted. In the case of an integer, usually the first bit is used for the sign, the others are used for the value.

Complex data types can be combinations of primitive and other complex data types and are called "Class" in Java.

You can define the complex data type PeopleName consisting of two Strings called first and last name. Each String in Java is another complex data type. Strings in return are (probably) implemented using the primitive data type char for which Java knows how many bits they take to store and how to interpret them.

When you create an instance of a data type, you get an object and your computers reserves some memory for it and remembers its location and the name of that instance. An instance of PeopleName in memory will take up the space of the two String variables plus a bit more for bookkeeping. An integer takes up 32 bits in Java.

Complex data types can have methods assigned to them. Methods can perform actions on their arguments or on the instance of the data type you call this method from. If you have two instances of PeopleName called p1 and p2 and you call a method p1.getFirstName(), it usually returns the first name of the first person but not the second person's.