Classes, Objects, and Methods in Java
In Java, classes, objects, and methods form the core of object-oriented programming (OOP).
A class serves as a blueprint or template that defines the attributes (properties) and behaviors
(methods) common to all objects of that type. Essentially, it groups together objects that share
similar characteristics and functionalities.
An object is a specific instance created from a class. It represents an actual entity in the
program with its own state and behavior defined by the class. Through objects, real-world
entities are modeled and manipulated in the code.
Classes
A class is a blueprint or template for creating objects. It defines the properties
(fields/attributes) and behaviors (methods) that the objects of the class will have.
Syntax:
Copy the codeclass ClassName {
// Fields (variables)
int field1;
String field2;
// Methods
void methodName() {
// Method body
}
}
Objects
An object is an instance of a class. It is created using the new keyword and
represents a specific entity with its own state and behavior.
Syntax:
Copy the codeClassName objectName = new ClassName();
Example:
Copy the codeclass Car {
String brand;
int speed;
void displayInfo() {
System.out.println("Brand: " + brand + ", Speed: " + speed);
}
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car(); // Object creation
myCar.brand = "Toyota";
myCar.speed = 120;
myCar.displayInfo(); // Output: Brand: Toyota, Speed: 120
}
}
Methods
A method is a block of code that performs a specific task. It can be called on an
object to execute the behavior defined in the class.
Syntax:
Copy the codereturnType methodName(parameters) {
// Method body
return value; // Optional, based on returnType
}
Example:
Copy the codeclass Calculator {
int add(int a, int b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculator calc = new Calculator();
int result = calc.add(5, 10); // Method call
System.out.println("Sum: " + result); // Output: Sum: 15
}
}
Key Points:
Encapsulation: Classes encapsulate data and methods.
Reusability: Classes and methods promote code reuse.
Modularity: Objects and methods make code modular and easier to maintain.
Java Classes
What is a Class in Java?
A class in Java represents a collection of objects that share similar properties and behaviors.
It acts as a blueprint or prototype defined by the user, from which individual objects are
created. For example, Student is a class, while a specific student like Ravi is an object (an
instance of the Student class).
Properties of Java Classes
A class is an abstract concept; it is not a real-world object but a template or prototype
for creating objects.
It does not consume memory by itself.
A class groups variables (also called data members) of different data types and a set
of methods.
In Java, a class can contain:
o Data members (fields/variables)
o Methods (functions to define behavior)
o Constructors (special methods to initialize objects)
o Nested classes (classes defined within another class)
o Interfaces (can be declared inside a class)
How to Declare a Class in Java
The general syntax to declare a class is:
java
CopyEdit
access_modifier class ClassName {
// data members (fields)
// methods
// constructors
// nested classes
// interfaces
}
Components of a Java Class Declaration
A class declaration typically consists of the following parts:
1. Modifiers: Define access level, such as public or default (package-private).
2. class keyword: Used to declare a class.
3. Class name: Should start with a capital letter by convention.
4. Superclass (optional): If the class inherits from another class, the superclass name
follows the keyword extends. Java supports single inheritance (only one
superclass).
5. Interfaces (optional): If the class implements interfaces, their names follow the
keyword implements, separated by commas. A class can implement multiple
interfaces.
6. Class body: Enclosed within { }, containing data members, methods, constructors,
nested classes, and interfaces.
Additional Details
Constructors: Special methods used to initialize new objects of the class.
Fields (data members): Variables that hold the state or attributes of the class and its
objects.
Methods: Define the behavior or functionality of the class and its objects.
Java supports various types of classes used in real-world programming:
o Nested classes (classes defined inside other classes)
o Anonymous classes (classes without a name, usually used for quick
implementation)
o Lambda expressions (concise way to represent anonymous functions)
