Classes and Objects in Java Example Programs
Classes and Objects in Java Example Programs
Java is an Object-Oriented programming language, i.e., everything in Java is associated with objects and objects are associated with classes. The classes and objects in Java examples programs teach us about classes and objects and their usages.
What are Classes and Objects?
A set of instructions or blueprint required to create an object is called a class. Classes are the most fundamental elements of Object-Oriented programming. Classes in Java relates to real-life stuff and make Object-Oriented programming easy yet interesting.
The instantiation of a class is called an object. In other words, that element of Object-Orientated programming, which obeys the set of instructions or blueprint defined by a class called is an object.
Class is more like a concept that we can understand but cannot touch or see it. An object implements that concept and becomes a real-time entity. Thus, we can see or touch an object. For example, A woody plant that has roots, elongated stems, leaves, a lot of twigs is called a tree. Here, leaves, roots, elongated stems, etc., are concepts or blueprints. Hence, a tree is a class. A mango tree or a guava tree is one of the objects of the class tree. This is because a mango or guava tree implements all the concepts given in the definition of a tree. Whenever we see a tree, it is basically a type of tree, i.e., an object of the class tree.
Programmatically, a Java class contains variables, methods and their definitions, and data-structures. In order to use the variables, methods or data structures of the class, we create objects. Since a class is just a blueprint, it does not occupy any memory, whereas objects occupy memory. Note that a class can have one or more than one object.
How to create a Java class?
The keyword class is used to create a class in Java. After the keyword class, the name of the class is written. For example, the code to create a class whose name is ABC and contains a variable var of integer type that stores the number 5 is:
FileName: ABC.java
public class ABC
{
int var = 5;
}
The keyword public is the access specifier.
How to create an object of a Java class?
To create the object, mention the class name, then the object name, followed by the keyword new.
FileName: ABC.java
public class ABC
{
int var = 5;
public static void main(String argvs[])
{
ABC ob = new ABC(); // creating an object of class ABC
System.out.println( ob.var );
}
}
Output:
5
Explanation: ob is the name or reference of the object, and ob is referring to the object creating by the keyword new. In other words, the new keyword is responsible for the instantiation of the class ABC. The new keyword allocates memory for the object and returns the reference of it. This reference is stored in ob.
Creating an anonymous object
In the previous example, we have seen that ob is the name/ reference of the object. However, we can also create an anonymous object in Java. An object in Java that has no name or reference is called an anonymous object.
FileName: ABC.java
public class ABC
{
int var = 5;
public static void main(String argvs[])
{
// printing the value contained in var using an anonymous object
System.out.println( (new ABC()).var );
}
}
Output:
5
Explanation: Inside the print statement, we have created the anonymous object ( new ABC()). Using the anonymous object, we are accessing the value of the variable var. The drawback of anonymous objects is; it can be used only once. Consider the following Java program. This program will print the value of the variable var twice.
FileName: ABC.java
public class ABC
{
int var = 5;
public static void main(String argvs[])
{
// Printing the value contained in var using an anonymous object
System.out.println( (new ABC()).var );
// Printing the value of var again using another anonymous object
System.out.println( (new ABC()).var );
}
}
Output:
5 5
Explanation: In the code, we have created two anonymous objects for displaying the value of the variable var two times. This is because a reference or name is required to use a Java object more than once. In the case of an object having a reference, we do not need to create two objects. Using the reference, we can display the value of variable var twice. The following code snippet does the same.
public static void main(String argvs[])
{
ABC ob = new ABC(); // creating an object having reference ob.
System.out.println( ob.var );
System.out.println( ob.var );
}
Creating Multiple Objects
Let us observe how we can create multiple objects of a class in Java.
FileName: XYZ.java
public class XYZ
{
void foo()
{
System.out.println("Inside the method foo. ");
}
public static void main(String argvs[])
{
// Creating two objects of the class XYZ
XYZ obj1 = new XYZ();
XYZ obj2 = new XYZ();
// calling the method foo()
obj1.foo();
obj2.foo();
}
}
Output:
Inside the method foo. Inside the method foo.
Explanation: In the code, we have created two objects, obj1 and obj2, of the class XYZ. Then, obj1 and obj2 are calling the method foo() separately. Since we have created two objects, there will be two copies of the class XYZ. One is assigned to obj1, and another is assigned to obj2. Therefore, changes done by obj1 does not affect changes done by obj2 (exception: class attributes and methods). Let us understand with the help of an example.
FileName: XYZ1.java
public class XYZ1
{
int x;
public static void main(String argvs[])
{
// Creating two objects of the class XYZ
XYZ1 obj1 = new XYZ1();
XYZ1 obj2 = new XYZ1();
// assigning different values of x for obj1 and obj2
obj1.x = 1;
obj2.x = 2;
// Printing the value of x for obj1 and obj2
System.out.println( obj1.x );
System.out.println( obj2.x );
}
}
Output:
1 2
Explanation: We are creating two objects of the class XYZ1. Therefore, two copies of the variable x are created: one for obj1 and another for obj2. For obj1, the variable x contains the value 1. For obj2, x contains the value 2 and the same is displayed on the console.
Creating Multiple Classes
Not only multiple objects, but we can also create multiple classes in Java. Consider the following example.
FileName: Main.java
class XYZ
{
int x;
}
public class Main
{
// main method
public static void main(String argvs[])
{
// Creating an object of the class XYZ
XYZ obj1 = new XYZ();
obj1.x = 1; // accessing the variable x and assigning value 1
System.out.println( obj1.x );
}
}
Output:
1
Explanation: The class XYZ has the variable x. Another class, Main, has the main method. Inside the main method, we have created an object of the class XYZ to access the variable x. Note that a Java program can have multiple classes, objects, methods, and variables. Along with x, we can even create another variable, y, or we can create different methods in the class XYZ. In Java projects, we always have different classes containing different variables and methods.