Classes, Methods, Objects,
and Object Instantiation
Classes
Java is an object-oriented programming (OOP) language, where the basic building blocks
are classes and objects.
Classes in Java
A class is a blueprint or template for creating objects. It defines the structure and behavior
(fields and methods) that the objects of the class will have.
Key Features of a Class
Fields (Variables): Represent the properties or state of the class.
Methods: Define the behavior or actions that objects of the class can perform.
Constructors: Special methods used to initialize objects.
Classes
Declaration:
Use the class keyword.
The class name should follow Java naming conventions (e.g., PascalCase).
Syntax of a Class
class ClassName
{
// Fields (State)
dataType fieldName;
// Methods (Behavior)
returnType methodName(parameters)
{
// Method body
}
}
Classes
Example
class Car
{
// Fields
String brand;
int speed;
// Methods
void displayDetails()
{
System.out.println("Brand: " + brand);
System.out.println("Speed: " + speed + " km/h");
}
}
In this example, Car is a class with fields brand and speed, and a method displayDetails().
Classes
Encapsulation:
Classes group fields and methods into a single unit, following the principle of
encapsulation.
Modifiers:
Access Modifiers: public, private, protected, or default (package-private).
Non-Access Modifiers: final, abstract, static.
Inheritance:
A class can inherit from another class using the extends keyword.
Types of Fields:
Instance Fields: Belong to an instance of the class (object). Each object has its own copy
of instance fields.
Static Fields: Shared among all instances of the class and belong to the class itself.
Declared using the static keyword.
Classes
Initialization:
Instance Fields: Initialized in constructors or directly at declaration.
Static Fields: Initialized in a static block or at declaration.
class Test
{
int instanceField = 10; // Instance field initialized at declaration
static int staticField = 20; // Static field initialized at declaration
}
•Memory Allocation:
Instance Fields: Allocated in the heap memory for each object.
Static Fields: Allocated once in the class area, shared by all objects.
Encapsulation:
Fields should be private and accessed using methods (getters and setters) to
ensure data integrity and encapsulation.
Methods
Methods in Java
A method is a block of code designed to perform a specific task. It can take input parameters,
perform actions, and optionally return a value.
Types of Methods
Instance Methods: Operate on an object’s state and require an object to be called.
Static Methods: Belong to the class and can be called without creating an object.
Types of Parameters
Formal Parameters: Declared in the method definition and receive values when the
method is called.
Actual Parameters: The values or arguments passed to a method during a call.
Methods
Syntax of a Method
returnType methodName(dataType parameter1, dataType parameter2, ...)
{
// Method body
}
Methods
Example:
class Example
{
void greet(String name) // Formal parameter
{
System.out.println("Hello, " + name + "!");
}
}
public class Main
{
public static void main(String[] args)
{
Example example = new Example();
example.greet("Alice"); // Actual parameter
}
}
Output : Hello, Alice!
Methods
Types of Value Passing in Java
Java supports two primary ways of passing values to methods:
Pass by Value
Java uses pass-by-value for method arguments.
A copy of the value is passed to the method.
Modifications to the parameter inside the method do not affect the original value.
Methods
Example: Primitive Data Types
class Example {
void modifyValue(int num) {
num = num + 10; // Changes only the local copy
System.out.println("Inside method: " + num);
}
}
public class Main {
public static void main(String[] args) {
int value = 5;
Example example = new Example();
example.modifyValue(value);
System.out.println("Outside method: " + value); // Original value remains unchanged
}
}
Output:
Inside method: 15
Outside method: 5
Methods
Pass by Reference (Simulated via Object References)
While Java doesn’t support true pass-by-reference, it passes object references by value.
This means modifications to the object inside the method affect the original object since
both refer to the same memory location.
Methods
class Example {
void modifyObject(Person person) {
person.name = "Updated Name"; // Modifies the actual object
}
}
class Person {
String name;
}
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.name = "Original Name";
Example example = new Example();
example.modifyObject(person);
System.out.println("Name after modification: " + person.name);
}
}
Output: Name after modification: Updated Name
Methods
Calling Methods in Java
Instance Methods
Called using an object of the class.
Can access both instance and static members.
Example
class Calculator {
int add(int a, int b) {
return a + b;
}
}
public class Main {
public static void main(String[] args) {
Calculator calc = new Calculator(); // Create object
int sum = calc.add(10, 20); // Call instance method
System.out.println("Sum: " + sum);
}
}
Output: Sum: 30
Methods
Static Methods
•Called using the class name, without needing an object.
•Cannot access instance variables or methods directly.
Example
class MathUtils {
static int multiply(int a, int b) {
return a * b;
}
}
public class Main {
public static void main(String[] args) {
int result = MathUtils.multiply(5, 4); // Call static method
System.out.println("Result: " + result);
}
}
Output: Result: 20
Methods
Method Chaining
Methods can be chained by returning the current object (this).
Example
class Builder {
StringBuilder sb = new StringBuilder();
Builder append(String str) {
sb.append(str);
return this;
}
String build() {
return sb.toString();
}
}
public class Main {
public static void main(String[] args) {
Builder builder = new Builder();
String result = builder.append("Hello ").append("World!").build();
System.out.println(result);
}
}
Output: Hello World!
Methods
Method Overloading
A class can have multiple methods with the same name but different parameter lists.
The method called is determined by the number and type of arguments passed.
class Display {
void show(int number) {
System.out.println("Number: " + number);
}
void show(String message) {
System.out.println("Message: " + message);
}
}
public class Main {
public static void main(String[] args) {
Display display = new Display();
display.show(42); // Calls method with int parameter
display.show("Hello Java"); // Calls method with String parameter
}
}
Number: 42
Message: Hello Java
Methods
Key Takeaways
1.Parameters:
Formal parameters are defined in the method declaration.
Actual parameters are passed during method invocation.
2.Passing Values:
Java uses pass-by-value for primitives.
Object references allow simulated pass-by-reference.
3.Calling Methods:
Instance methods require an object.
Static methods can be called directly using the class name.
Overloaded methods allow flexibility based on parameter types.
4.Best Practices:
Use clear and descriptive parameter names.
Prefer immutability for objects passed to methods to avoid unintended side effects.
Avoid excessive method overloading to reduce ambiguity.
Classes
Example:
class Student
{
// Instance fields
private String name;
private int rollNumber;
// Static field
static String schoolName = "ABC High School";
// Constructor to initialize instance fields
Student(String name, int rollNumber)
{
this.name = name;
this.rollNumber = rollNumber;
}
Classes
// Getter methods to access private fields
public String getName()
{
return name;
}
public int getRollNumber()
{
return rollNumber;
}
// Method to display student details
void displayDetails()
{
System.out.println("Name: " + name);
System.out.println("Roll Number: " + rollNumber);
System.out.println("School: " + schoolName);
}
}
Classes
public class Main
{
public static void main(String[] args)
{
// Creating objects
Student student1 = new Student("Alice", 101);
Student student2 = new Student("Bob", 102);
// Displaying details
student1.displayDetails();
student2.displayDetails();
}
}
Classes
Output:
Name: Alice
Roll Number: 101
School: ABC High School
Name: Bob
Roll Number: 102
School: ABC High School
Objects
Objects in Java
An object is a runtime instance of a class. It represents a specific entity that has:
State: Defined by the fields (variables).
Behavior: Defined by the methods.
Identity: A unique memory address.
Creating an Object
Objects are created using the new keyword, which calls the class constructor.
Objects
class Dog {
// Fields
String name;
String breed;
// Method
void bark() {
System.out.println(name + " is barking!");
}
}
public class Main {
public static void main(String[] args) {
// Creating an object of Dog class
Dog dog1 = new Dog();
dog1.name = "Buddy";
dog1.breed = "Golden Retriever";
System.out.println("Dog Name: " + dog1.name);// Accessing fields and methods
System.out.println("Dog Breed: " + dog1.breed);
dog1.bark(); // Output: Buddy is barking!
}
}
Objects
Object Instantiation
Object instantiation is the process of creating an object from a class. It involves:
Memory Allocation: Memory is allocated to the object.
Constructor Call: Initializes the object’s fields.
Steps for Object Instantiation
Declaration: Declare a reference variable.
Example: ClassName objectName;
Instantiation: Use the new keyword to create the object.
Example: objectName = new ClassName();
Initialization: The constructor initializes the object’s fields.
Objects
class Person {
String name; Output:
int age;
Person(String name, int age) { // Constructor Name: Alice
this.name = name; Age: 30
this.age = age; Name: Bob
} Age: 25
void displayInfo() { // Method
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
public class Main {
public static void main(String[] args) {
Person person1 = new Person("Alice", 30); // Creating objects
Person person2 = new Person("Bob", 25); // Creating objects
person1.displayInfo(); // Calling methods on objects
person2.displayInfo(); // Calling methods on objects
}
}
Objects
Comprehensive Example: Combining All Concepts
Let’s combine classes, methods, objects, and instantiation in a single example:
class Student {
String name;
int rollNumber; // Fields
int marks; // Fields
// Constructor
Student(String name, int rollNumber, int marks) {
this.name = name;
this.rollNumber = rollNumber;
this.marks = marks;
}
// Instance Method
void displayDetails() {
System.out.println("Name: " + name);
System.out.println("Roll Number: " + rollNumber);
System.out.println("Marks: " + marks);
}
Objects
// Static Method
static void welcomeMessage()
{
System.out.println("Welcome to the Student Portal!");
}
}
public class Main {
public static void main(String[] args) {
Student.welcomeMessage(); // Calling the static method
Student student1 = new Student("John", 101, 85); // Creating objects
Student student2 = new Student("Emma", 102, 90); // Creating objects
student1.displayDetails(); // Calling instance methods
student2.displayDetails(); // Calling instance methods
}
Objects
Output:
Welcome to the Student Portal!
Name: John
Roll Number: 101
Marks: 85
Name: Emma
Roll Number: 102
Marks: 90
Classes
Key Takeaways
Classes
Act as a blueprint to define fields and methods.
Methods
Define actions.
Can be static (class-level) or instance (object-level).
Objects
Represent instances of classes.
Encapsulate state and behavior.
Object Instantiation
Involves memory allocation and constructor execution.
Methods
Practice Questions:
Java_FUN_L0_1 Print square root
Java_FUN_L0_2.Find the power
Java_FUN_L0_3.Check Perfect, Abundant, Deficient
Java_FUN_L0_4.Generate Prime numbers
Java_FUN_L0_5.Check Adam number
Java_FUN_L0_6.Count the Number of Digits
Java_FUN_L0_7.Difference between the largest and smallest Digit
Java_FUN_L0_8.Number of Factors
Java_FUN_L0_9.Decimal to Binary
Java_FUN_L0_10.Find the largest character from the given characters
Methods
Practice Questions:
Java_FUN_L1_1. Arithmetic Operators
Java_FUN_L1_2.Alphabets counter
Java_FUN_L1_3.Armstrong Number Check
Java_FUN_L1_4.Difference between reverse number and number
Java_FUN_L1_5.Seggregate vowels and consonants
Java_FUN_L1_6.Multiply the value inside the variable
Java_FUN_L1_7.Two Addresses of a variable are given to swap the values in it
Java_FUN_L1_8.Array max of three repeat
Java_FUN_L1_9.Read data using the class
Java_FUN_L1_10.Read the Bio using the class
Methods
Practice Questions:
Java FUN L2 1 String Expand
Java FUN L2 2.Array rotator
Java FUN L2.3 AT by group reverser
Java FUN L2 4.arr union
Java FUN L2 5.arr intersection
Java FUN L2 6 array expand
Java FUN L2 7.count frequency
Java FUN L2 8 Maximum product
Java FUN L2 9.Vowel sort
Java.FUN.L2 10.Rotate difference
THANK YOU
