Classes

In Java, classes are fundamental building blocks of object-oriented programming. A class is a blueprint or template that defines the structure and behavior of objects. It serves as a blueprint for creating instances or objects of that class.

Here are some key points about classes in Java:

Class Declaration: A class is declared using the class keyword, followed by the class name. The class name should start with an uppercase letter and follow naming conventions (e.g., CamelCase).
```
public class MyClass {
    // class members and methods
}
```
Class Members: A class can contain various members, including fields (variables), methods, constructors, and nested classes. These members define the attributes and behavior of objects created from the class.
Fields: Fields are variables declared within a class, representing the state or data associated with objects of that class. Fields can be of any valid Java data type.
```
public class MyClass {
    private int myField; // field declaration
}
```
Methods: Methods are functions defined within a class that perform specific operations or actions. They define the behavior of objects of that class. Methods can have parameters (input values) and a return type (output value).
```
public class MyClass {
    public void myMethod() {
        // method implementation
    }
}
```
Constructors: Constructors are special methods used to initialize objects of a class. They have the same name as the class and are called when an object is created. Constructors can have parameters to initialize the object with specific values.
```
public class MyClass {
    public MyClass() {
        // constructor implementation
    }
}
```
Object Creation: Objects are instances of a class created using the new keyword. The new keyword allocates memory for the object and calls the constructor to initialize it.
```
MyClass obj = new MyClass(); // Object creation
```
Class Inheritance: In Java, classes can inherit properties and methods from other classes. This is achieved using the extends keyword to create a subclass (child class) that inherits from a superclass (parent class).
```
public class MySubclass extends MyClass {
    // subclass members and methods
}
```
Access Modifiers: Classes, fields, and methods can have access modifiers (public, private, protected, or default) to control their visibility and accessibility from other parts of the program.
Encapsulation: Java classes support encapsulation, which means bundling related data and methods together, and providing access to them through well-defined interfaces (public methods). Encapsulation helps in data hiding and maintaining code integrity.

Classes in Java play a crucial role in organizing and structuring code, promoting reusability, and implementing object-oriented concepts like encapsulation, inheritance, and polymorphism. They provide a blueprint for creating objects with specific attributes and behaviors, enabling modular and scalable development.

Class = Blueprint

Objects and Classes