Know the Difference Between Reference, Object, Instance, and Class?
Get clear with these terminologies used in programming.
In this article, I’m going to explain about most frequently used terminologies in the java programming language. Classes, objects, instances, and references are a few terms that you may have heard on a day-to-day basis while writing codes. After reading this article you will get to know about these terms and their different usage.
What is a Class?
Class is a blueprint/template/representation or user-defined data type for the objects. We write only one class for hundreds of objects. A class is defined using the class keyword followed by the name of the class and then the class body is defined.
Example:
The Student is defined as a class using the class keyword and then inside curly brackets, instance variables, and instance methods are defined.
What is an Object?
An object is a real-world or software entry that has attributes(instance fields) and behavior(instance methods). The object is created with a new operator in the heap. e.g. new ClassName(); . Objects are instantiated when the class is loaded into memory. Objects are also called Instances.
Example:
Here the object of type Student is created using a new operator in heap and the address is returned in variable s1, then default construct student() is called.
What is a Reference?
Reference holds the address of an object or instance. Whenever we want to call instance methods, we use this reference which holds the address of the object. References are like C++ pointers.
s1 is a reference of type Student and points to the object of type Student and will be used to access instance variables and methods.
Below I’ve written Student class with the instance variable and methods. And created objects and references for this class in Main (driver class).
OUTPUT :
When Does the Java Compiler Add the Default Constructor?
If a class doesn’t have any constructor provided by the programmer, then the java compiler will add a default constructor without parameters that will call a superclass constructor internally with a super() call. This is called a default constructor.
You can see that I haven’t added a default constructor in the Student class hence compiler will create one default constructor and will add it to the class.
Example:
Note: Inside the default constructor, it will add a super() call also, to call the superclass constructor.[In the case of the Student class, the superclass is the Object class] and every class internally inherits the object class.
Purpose of adding default constructor:
The constructor’s duty is to initialize instance variables. If there are no instance variables then you could choose to remove the constructor from your class.
But when you are inheriting some class it is your responsibility to call the superclass constructor to make sure that the superclass initializes all its instance variables properly.
That’s why if there are no constructors, the java compiler will add a default constructor and calls a superclass constructor.
Note: super() call inside the default constructor is generally hidden.
That’s all for this article. Hope you have enjoyed this article.
What exactly is an instance in Java?
What is the difference between an object, instance, and reference? They say that they have to create an instance to their application? What does that mean?
12 Answers 12
An object and an instance are the same thing.
Personally I prefer to use the word «instance» when referring to a specific object of a specific type, for example «an instance of type Foo». But when talking about objects in general I would say «objects» rather than «instances».
A reference either refers to a specific object or else it can be a null reference.
They say that they have to create an instance to their application. What does it mean?
They probably mean you have to write something like this:
If you are unsure what type you should instantiate you should contact the developers of the application and ask for a more complete example.
«instance to an application» means nothing.
«object» and «instance» are the same thing. There is a «class» that defines structure, and instances of that class (obtained with new ClassName() ). For example there is the class Car , and there are instance with different properties like mileage, max speed, horse-power, brand, etc.
Reference is, in the Java context, a variable* — it is something pointing to an object/instance. For example, String s = null; — s is a reference, that currently references no instance, but can reference an instance of the String class.
*Jon Skeet made a note about the difference between a variable and a reference. See his comment. It is an important distinction about how Java works when you invoke a method — pass-by-value.
The value of s is a reference. It’s very important to distinguish between variables and values, and objects and references.
When you use the keyword new for example JFrame j = new JFrame(); you are creating an instance of the class JFrame .
The new operator instantiates a class by allocating memory for a new object and returning a reference to that memory.
Note: The phrase «instantiating a class» means the same thing as «creating an object.» When you create an object, you are creating an «instance» of a class, therefore «instantiating» a class.
The types of the Java programming language are divided into two categories: primitive types and reference types.
The reference types are class types, interface types, and array types.
There is also a special null type.
An object is a dynamically created instance of a class type or a dynamically created array .
The values of a reference type are references to objects.
I think that Object = Instance. Reference is a «link» to an Object.
variable c stores a reference to an object of type Car.
Here an object is created from the Computer class. A reference named c allows the programmer to access the object.
The main differnece is when you say ClassName obj = null; you are just creating an object for that class. It’s not an instance of that class.
This statement will just allot memory for the static meber variables, not for the normal member variables.
But when you say ClassName obj = new ClassName(); you are creating an instance of the class. This staement will allot memory all member variables.
basically object and instance are the two words used interchangeably. A class is template for an object and an object is an instance of a class.
«creating an instance of a class» how about, «you are taking a class and making a new variable of that class that WILL change depending on an input that changes»
Class in the library called Nacho
variable Libre to hold the «instance» that will change
Nacho Libre = new Nacho(Variable, Scanner Input, or whatever goes here, This is the place that accepts the changes then puts the value in «Libre» on the left side of the equals sign (you know «Nacho Libre = new Nacho(Scanner.in)» «Nacho Libre» is on the left of the = (that’s not tech talk, that’s my way of explaining it)
I think that is better than saying «instance of type» or «instance of class». Really the point is it just needs to be detailed out more. «instance of type or class» is not good enough for the beginner. wow, its like a tongue twister and your brain cannot focus on tongue twisters very well. that «instance» word is very annoying and the mere sound of it drives me nuts. it begs for more detail. it begs to be broken down better. I had to google what «instance» meant just to get my bearings straight. try saying «instance of class» to your grandma. yikes!
Java — Object and Classes
In this chapter, we will look into the concepts — Classes and Objects.
Object − Objects have states and behaviors. Example: A dog has states — color, name, breed as well as behaviors – wagging the tail, barking, eating. An object is an instance of a class.
Class − A class can be defined as a template/blueprint that describes the behavior/state that the object of its type support.
Objects in Java
Let us now look deep into what are objects. If we consider the real-world, we can find many objects around us, cars, dogs, humans, etc. All these objects have a state and a behavior.
If we consider a dog, then its state is — name, breed, color, and the behavior is — barking, wagging the tail, running.
If you compare the software object with a real-world object, they have very similar characteristics.
Software objects also have a state and a behavior. A software object’s state is stored in fields and behavior is shown via methods.
So in software development, methods operate on the internal state of an object and the object-to-object communication is done via methods.
Classes in Java
A class is a blueprint from which individual objects are created.
Following is a sample of a class.
Example
A class can contain any of the following variable types.
Local variables − Variables defined inside methods, constructors or blocks are called local variables. The variable will be declared and initialized within the method and the variable will be destroyed when the method has completed.
Instance variables − Instance variables are variables within a class but outside any method. These variables are initialized when the class is instantiated. Instance variables can be accessed from inside any method, constructor or blocks of that particular class.
Class variables − Class variables are variables declared within a class, outside any method, with the static keyword.
A class can have any number of methods to access the value of various kinds of methods. In the above example, barking(), hungry() and sleeping() are methods.
Following are some of the important topics that need to be discussed when looking into classes of the Java Language.
Constructors
When discussing about classes, one of the most important sub topic would be constructors. Every class has a constructor. If we do not explicitly write a constructor for a class, the Java compiler builds a default constructor for that class.
Each time a new object is created, at least one constructor will be invoked. The main rule of constructors is that they should have the same name as the class. A class can have more than one constructor.
Following is an example of a constructor −
Example
Java also supports Singleton Classes where you would be able to create only one instance of a class.
Note − We have two different types of constructors. We are going to discuss constructors in detail in the subsequent chapters.
Creating an Object
As mentioned previously, a class provides the blueprints for objects. So basically, an object is created from a class. In Java, the new keyword is used to create new objects.
There are three steps when creating an object from a class −
Declaration − A variable declaration with a variable name with an object type.
Instantiation − The ‘new’ keyword is used to create the object.
Initialization − The ‘new’ keyword is followed by a call to a constructor. This call initializes the new object.
Following is an example of creating an object −
Example
If we compile and run the above program, then it will produce the following result −
Output
Accessing Instance Variables and Methods
Instance variables and methods are accessed via created objects. To access an instance variable, following is the fully qualified path −
Example
This example explains how to access instance variables and methods of a class.
If we compile and run the above program, then it will produce the following result −
Output
Source File Declaration Rules
As the last part of this section, let’s now look into the source file declaration rules. These rules are essential when declaring classes, import statements and package statements in a source file.
There can be only one public class per source file.
A source file can have multiple non-public classes.
The public class name should be the name of the source file as well which should be appended by .java at the end. For example: the class name is public class Employee<> then the source file should be as Employee.java.
If the class is defined inside a package, then the package statement should be the first statement in the source file.
If import statements are present, then they must be written between the package statement and the class declaration. If there are no package statements, then the import statement should be the first line in the source file.
Import and package statements will imply to all the classes present in the source file. It is not possible to declare different import and/or package statements to different classes in the source file.
Classes have several access levels and there are different types of classes; abstract classes, final classes, etc. We will be explaining about all these in the access modifiers chapter.
Apart from the above mentioned types of classes, Java also has some special classes called Inner classes and Anonymous classes.
Java Package
In simple words, it is a way of categorizing the classes and interfaces. When developing applications in Java, hundreds of classes and interfaces will be written, therefore categorizing these classes is a must as well as makes life much easier.
Import Statements
In Java if a fully qualified name, which includes the package and the class name is given, then the compiler can easily locate the source code or classes. Import statement is a way of giving the proper location for the compiler to find that particular class.
For example, the following line would ask the compiler to load all the classes available in directory java_installation/java/io −
A Simple Case Study
For our case study, we will be creating two classes. They are Employee and EmployeeTest.
First open notepad and add the following code. Remember this is the Employee class and the class is a public class. Now, save this source file with the name Employee.java.
The Employee class has four instance variables — name, age, designation and salary. The class has one explicitly defined constructor, which takes a parameter.
Example
As mentioned previously in this tutorial, processing starts from the main method. Therefore, in order for us to run this Employee class there should be a main method and objects should be created. We will be creating a separate class for these tasks.
Following is the EmployeeTest class, which creates two instances of the class Employee and invokes the methods for each object to assign values for each variable.
Save the following code in EmployeeTest.java file.
Now, compile both the classes and then run EmployeeTest to see the result as follows −
Output
What is Next?
In the next session, we will discuss the basic data types in Java and how they can be used when developing Java applications.
What Are Java Instance Variables & Why Do They Matter?
What is an instance variable in Java? For starters, they are more valuable than they may initially sound. They are invariably vital for your Java software. But what are they really, and how do they work?
This post will explain the concepts behind an instance variable, how they work and how you can use them. You will see some code examples of syntax and learn of some ways you can use them in your development to build better, more efficient software.