Java – Object and Classes

Java Classes and Objects

Java is an Object-Oriented programming language. In Java, the classes and objects are the basic and important features of object-oriented programming system, Java supports the following fundamental OOPs concepts –

• Classes
• Objects
• Inheritance
• Polymorphism
• Encapsulation
• Abstraction
• Instance
• Method
• Message Passing

In this tutorial, we will learn about Java Classes and Objects, the creation of the classes and objects, accessing class methods, etc.

Java Classes

A class is a blueprint from which individual objects are created (or, we can say a class is a data type of an object type). In Java, everything is related to classes and objects. Each class has its methods and attributes that can be accessed and manipulated through the objects.

For example, if you want to create a class for students. In that case, “Student” will be a class, and student records (like student1, student2, etc) will be objects.

We can also consider that class is a factory (user-defined blueprint) to produce objects.

Properties of Java Classes

• A class does not take any byte of memory.
• A class is just like a real-world entity, but it is not a real-world entity. It’s a blueprint where we specify the functionalities.
• A class contains mainly two things: Methods and Data Members.
• A class can also be a nested class.
• Classes follow all of the rules of OOPs such as inheritance, encapsulation, abstraction, etc.

Types of Java Class Variables

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.

Creating (Declaring) a Java Class

To create (declare) a class, you need to use access modifiers followed by class keyword and class_name.

Syntax to create a Java class

Use the below syntax to create (declare) class in Java:

access_modifier class class_name{
  data members;
  constructors;
  methods;...;}

Example of a Java Class

In this example, we are creating a class “Dog”. Where, the class attributes are breed, age, and color. The class methods are setBreed(), setAge(), setColor(), and printDetails().

// Creating a Java classclassDog{// Declaring and initializing the attributesString breed;int age;String color;// methods to set breed, age, and color of the dogpublicvoidsetBreed(String breed){this.breed = breed;}publicvoidsetAge(int age){this.age = age;}publicvoidsetColor(String color){this.color = color;}// method to print all three valuespublicvoidprintDetails(){System.out.println("Dog detials:");System.out.println(this.breed);System.out.println(this.age);System.out.println(this.color);}}

Java Objects

An object is a variable of the type class, it is a basic component of an object-oriented programming system. A class has the methods and data members (attributes), these methods and data members are accessed through an object. Thus, an object is an instance of a class.

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, and color, and the behavior is – barking, wagging the tail, and 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.

Creating (Declaring) a Java 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.

Syntax to Create a Java Object

Consider the below syntax to create an object of the class in Java:

Class_name object_name =newClass_name([parameters]);

Note: parameters are optional and can be used while you’re using constructors in the class.

Example to Create a Java Object

In this example, we are creating an object named obj of Dog class and accessing its methods.

// Creating a Java classclassDog{// Declaring and initializing the attributesString breed;int age;String color;// methods to set breed, age, and color of the dogpublicvoidsetBreed(String breed){this.breed = breed;}publicvoidsetAge(int age){this.age = age;}publicvoidsetColor(String color){this.color = color;}// method to print all three valuespublicvoidprintDetails(){System.out.println("Dog detials:");System.out.println(this.breed);System.out.println(this.age);System.out.println(this.color);}}publicclassMain{publicstaticvoidmain(String[] args){// Creating an object of the class DogDog obj =newDog();// setting the attributes
    obj.setBreed("Golden Retriever");
    obj.setAge(2);
    obj.setColor("Golden");// Printing values
    obj.printDetails();}}

Output

Dog detials:
Golden Retriever
2
Golden

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 −

/* First create an object */ObjectReference=newConstructor();/* Now call a variable as follows */ObjectReference.variableName;/* Now you can call a class method as follows */ObjectReference.MethodName();

Example

In this example, We’ve created a class named Puppy. In Puppy class constructor, puppy name is printed so that when the object is created, its name is printed. An instance variable puppyAge is added and using getter/setter method, we can manipulate the age. In main method, an object is created using new operator. Age is updated using setAge() method and using getAge(), the age is printed.

publicclassPuppy{int puppyAge;publicPuppy(String name){// This constructor has one parameter, <i>name</i>.System.out.println("Name chosen is :"+ name );}publicvoidsetAge(int age ){
      puppyAge = age;}publicintgetAge(){System.out.println("Puppy's age is :"+ puppyAge );return puppyAge;}publicstaticvoidmain(String[]args){/* Object creation */Puppy myPuppy =newPuppy("tommy");/* Call class method to set puppy's age */
      myPuppy.setAge(2);/* Call another class method to get puppy's age */
      myPuppy.getAge();/* You can access instance variable as follows as well */System.out.println("Variable Value :"+ myPuppy.puppyAge );}}

Output

If we compile and run the above program, then it will produce the following result −

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Rules for using the Classes and Objects Concepts

Let’s now look into the source file declaration rules (to use the Java classes & objects approach). 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.

More Examples on Java Classes and Objects

Example 1

The Employee class has four instance variables – name, age, designation and salary. The class has one explicitly defined constructor, which takes a parameter.

importjava.io.*;publicclassEmployee{String name;int age;String designation;double salary;// This is the constructor of the class EmployeepublicEmployee(String name){this.name = name;}// Assign the age of the Employee  to the variable age.publicvoidempAge(int empAge){
      age = empAge;}/* Assign the designation to the variable designation.*/publicvoidempDesignation(String empDesig){
      designation = empDesig;}/* Assign the salary to the variable	salary.*/publicvoidempSalary(double empSalary){
      salary = empSalary;}/* Print the Employee details */publicvoidprintEmployee(){System.out.println("Name:"+ name );System.out.println("Age:"+ age );System.out.println("Designation:"+ designation );System.out.println("Salary:"+ salary);}}

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.

Example 2

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.

importjava.io.*;publicclassEmployeeTest{publicstaticvoidmain(String args[]){/* Create two objects using constructor */Employee empOne =newEmployee("James Smith");Employee empTwo =newEmployee("Mary Anne");// Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();}}

Output

Now, compile both the classes and then run EmployeeTest to see the result as follows −

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0