Class and Objects in Java

Lecture 62:-  Class and Objects in Java

In Java, a class is a blueprint or a template that defines the properties and behaviors of objects. An object, on the other hand, is an instance of a class, representing a specific entity with its own unique characteristics. Let's dive deeper into classes and objects in Java:

1. Class Declaration: To create a class in Java, you use the class keyword followed by the class name. The class can contain fields (attributes) and methods (behaviors). Here's the general syntax of a class declaration:

   javaCopy code
   public class ClassName {
       // Fields (attributes)
       dataType fieldName1;
       dataType fieldName2;
       // ...
   
       // Constructor(s)
       public ClassName(parameters) {
           // Constructor code
       }
   
       // Methods (behaviors)
       returnType methodName1(parameters) {
           // Method code
       }
   
       returnType methodName2(parameters) {
           // Method code
       }
       // ...
   }
   

2. Creating Objects: Once you have defined a class, you can create objects (instances) of that class using the new keyword. The new keyword allocates memory for the object and calls the constructor to initialize its state. Here's how you create an object:

   javaCopy code
   ClassName objectName = new ClassName(arguments);
   

3. Accessing Members: You can access the members (fields and methods) of an object using the dot (.) operator. For example, to access a field or call a method, you use the following syntax:

   javaCopy code
   objectName.fieldName;
   objectName.methodName(arguments);
   

4. Constructor: A constructor is a special method that is used to initialize the state of an object when it is created. It has the same name as the class and does not have a return type. If you don't explicitly define a constructor, Java provides a default constructor with no arguments.

5. Instance Variables (Fields): Instance variables are fields declared within the class but outside of any method. They represent the state of the object and have unique values for each object instance.

6. Methods (Behaviors): Methods are functions declared within the class. They represent the behaviors or actions that objects of the class can perform.

Here's a simple example to illustrate classes and objects in Java:

javaCopy code
public class Car {
    // Instance variables
    String make;
    String model;
    int year;

    // Constructor
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    // Method
    public void start() {
        System.out.println("Starting the " + make + " " + model);
    }

    public static void main(String[] args) {
        // Creating objects
        Car car1 = new Car("Toyota", "Camry", 2022);
        Car car2 = new Car("Honda", "Accord", 2021);

        // Accessing members
        System.out.println(car1.make); // Output: Toyota
        car2.start(); // Output: Starting the Honda Accord
    }
}

In this example, we have a Car class with three instance variables (make, model, and year), a constructor that takes arguments to initialize these variables, and a start method representing the behavior of starting the car.

In the main method, we create two Car objects (car1 and car2) and access their members using the dot operator. We also call the start method on car2, resulting in the output "Starting the Honda Accord".

Disclaimer:-

Under Section 107 of the copyright act 1976, allowance is made for fair use for purposes such as criticism, comment, news reporting, scholarship, and research. Fair use is a use permitted by copyright statute that might otherwise be infringing. Non-profit, educational, or personal use tips the balance in favor of fair use.