Java: Classes and Objects

• Java revolves around objects and their interactions as an object-oriented programming language.
• OOP is a paradigm based on objects containing data (fields/attributes/properties) and code (methods/procedures).
• Encapsulation, Abstraction, Inheritance, and Polymorphism are key principles of OOP.

Classes

• Classes serve as blueprints or templates for object creation.
• Data (attributes/fields) and behavior (methods) are defined within a class for its objects.
• Classes encapsulate data and methods into a single unit.
• class ClassName { // fields // methods } is the syntax for a class.
• Fields are variables inside the class, representing an object's state, and can have different data types.
• Methods are functions inside a class, defining an object's behavior, and can accept parameters and return values.
• Dog class example:

class Dog {
 String breed;
 int age;

 void bark() {
  System.out.println("Woof!");
 }
}

Objects

• Objects are concrete instances of a class that exist in memory.
• Objects are created using the new keyword.
• Each object possesses its own unique state based on the values of its fields.
• Objects interact by calling methods.
• ClassName objectName = new ClassName(); is the syntax for creating an object.
• Dog object example:

Dog myDog = new Dog();
myDog.breed = "Golden Retriever";
myDog.age = 3;
myDog.bark();

Object Creation

• The new keyword followed by the class name and parentheses (constructor call) creates objects.
• A constructor is a special method used to initialize the object's state.
• If no constructor is explicitly defined, Java provides a default constructor.
• Dog myDog = new Dog(); creates a Dog object.

Accessing Object Members

• The dot operator (.) accesses object members (fields and methods).
• objectName.fieldName accesses a field's value.
• objectName.methodName() calls a method.
• myDog.breed = "Golden Retriever"; sets the breed field of the myDog object.
• myDog.bark(); calls the bark method of the myDog object.

Constructors

• A constructor, a special method called upon object creation, initializes the object's state.
• Constructors share the same name as the class, can accept parameters, and initialize with specific values.
• Java provides a default no-argument constructor if you don't define one.
• Dog class constructor example:

class Dog {
 String breed;
 int age;

 // Constructor
 public Dog(String breed, int age) {
  this.breed = breed;
  this.age = age;
 }
 void bark() {
  System.out.println("Woof!");
 }
}

• The this keyword refers to the current object.

Encapsulation

• Encapsulation bundles data (fields) and methods that operate on that data within a class.
• It hides the internal implementation details of an object from the external environment.
• Access modifiers (private, public, protected) control the visibility of class members.
• private members are only accessible within the class itself.
• public members are accessible from anywhere.
• protected members are accessible within the class, its subclasses, and other classes in the same package.
• BankAccount class example:

class BankAccount {
 private double balance;

 public BankAccount(double initialBalance) {
  this.balance = initialBalance;
 }

 public double getBalance() {
  return balance;
 }

 public void deposit(double amount) {
  balance += amount;
 }

 public void withdraw(double amount) {
  if (amount <= balance) {
   balance -= amount;
  } else {
   System.out.println("Insufficient funds.");
  }
 }
}

Abstraction

• Abstraction simplifies complex reality by modeling classes appropriate to the problem.
• It focuses only on essential characteristics, ignoring non-essential details.
• Achieved through abstract classes and interfaces.
• Abstract classes cannot be instantiated directly.
• Interfaces define a contract that classes can implement.
• Shape class example:

abstract class Shape {
 abstract double getArea();
}

class Circle extends Shape {
 double radius;

 public Circle(double radius) {
  this.radius = radius;
 }

 @Override
 double getArea() {
  return Math.PI * radius * radius;
 }
}

Inheritance

• Inheritance is where a subclass/child class inherits properties/behaviors from a superclass/parent class.
• It promotes code reuse and reduces redundancy.
• Subclasses can override superclass methods to provide specific implementations.
• The extends keyword is used to inherit from a class.
• Animal/Dog class example:

class Animal {
 String name;

 void eat() {
  System.out.println("Animal is eating.");
 }
}

class Dog extends Animal {
 void bark() {
  System.out.println("Woof!");
 }
}

Polymorphism

• Polymorphism means "many forms."
• It allows objects of different classes to be treated as objects of a common type.
• Achieved through method overriding (runtime polymorphism) and method overloading (compile-time polymorphism).
• Method overriding occurs when a subclass provides a specific implementation for a method already defined in its superclass.
• Method overloading occurs when a class has multiple methods with the same name but different parameters.
• Method Overriding example:

class Animal {
 void makeSound() {
  System.out.println("Generic animal sound.");
 }
}

class Dog extends Animal {
 @Override
 void makeSound() {
  System.out.println("Woof!");
 }
}

class Cat extends Animal {
 @Override
 void makeSound() {
  System.out.println("Meow!");
 }
}

Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); // Output: Woof!
animal2.makeSound(); // Output: Meow!

• Method Overloading example:

class Calculator {
 int add(int a, int b) {
  return a + b;
 }

 double add(double a, double b) {
  return a + b;
 }
}

Arrays

• Arrays store a fixed-size, sequential collection of elements of the same type.
• Accessed using an index (starting from 0).
• Declared using square brackets [].
• dataType[] arrayName = new dataType[arraySize]; is the syntax.
• int[] numbers = new int[5]; creates an integer array of size 5.
• Elements can be initialized during declaration, for example: int[] numbers = {1, 2, 3, 4, 5};
• Array length is accessed using the length property.
• int arrayLength = numbers.length; is an example of accessing array length.

Array Operations

• arrayName[index] to access elements.
• int firstNumber = numbers[0]; is an example of accessing the first element.
• arrayName[index] = newValue; to modify elements.
• numbers[0] = 10; is an example of modifying the first element.
• Iterating through an array using loops (for loop, foreach loop).
• Example:

int[] numbers = {1, 2, 3, 4, 5};

for (int i = 0; i < numbers.length; i++) {
 System.out.println(numbers[i]);
}

for (int number : numbers) {
 System.out.println(number);
}

Multidimensional Arrays

• Multidimensional arrays are arrays of arrays.
• They can have multiple dimensions (e.g., 2D array, 3D array).
• Declared using multiple square brackets.
• int[][] matrix = new int[3][3]; creates a 3x3 integer matrix.
• arrayName[rowIndex][columnIndex] accesses elements.
• int element = matrix[0][0]; is an example of accessing an element.
• Example:

int[][] matrix = {
 {1, 2, 3},
 {4, 5, 6},
 {7, 8, 9}
};

for (int i = 0; i < matrix.length; i++) {
 for (int j = 0; j < matrix[i].length; j++) {
  System.out.print(matrix[i][j] + " ");
 }
 System.out.println();
}