Module 1 :: Learning

Java Introduction

Mon, 01 Jan 0001 00:00:00 +0000

How to write Java? Let’s look at a basic Java application: package com.kalschatzi; public class Main { public static void main(String args[]) { System.out.println("Hello, world"); } } This will be the simplest Java application you can write. Here’s how your folder structure should look like: Let’s deconstruct it line by line. package com.kalschatzi; This is where package is, which is what Java calls code folders. If you look at the file structure image, you’ll see that it matches.

Encapsulation

Mon, 01 Jan 0001 00:00:00 +0000

What is encapsulation Encapsulation is a fundamental concept in Object-Oriented Programming (OOP) that refers to bundling data (variables) and methods (functions) that operate on the data into a single unit (class) while restricting direct access to some details. Key Points: Hides Internal Implementation: Prevents direct modification of object data from outside the class. Provides Data Security: Only controlled access through methods (getters/setters). Enhances Maintainability: Changes in implementation don’t affect external code. What does it actually look like? This means that you need to understand a few Java keywords:

Inheritance

Mon, 01 Jan 0001 00:00:00 +0000

Inheritance Inheritance is an OOP concept that allows one class (child/subclass) to inherit properties and behaviors from another class (parent/superclass). It promotes code reuse and hierarchy-based organization. class Animal { void eat() { System.out.println("This animal eats food."); } } // Child Class class Dog extends Animal { void bark() { System.out.println("Dog barks."); } } public class Main { public static void main(String[] args) { Dog myDog = new Dog(); myDog.eat(); // Inherited method myDog.bark(); // Own method } } Interfaces An interface is like a contract that defines methods without implementations. A class must implement an interface to provide method definitions.

Polymorphism

Mon, 01 Jan 0001 00:00:00 +0000

Polymorphism means “many forms” and allows a single interface (method, class, or function) to behave differently based on the context. Method overriding This happens when a subclass provides a different implementation of a method defined in its parent class. class Animal { void makeSound() { System.out.println("Animal makes a sound"); } } class Dog extends Animal { @Override void makeSound() { System.out.println("Dog barks"); } } This way we can define a Dog class that extends Animal and can Override the base method.

Unit Testing

Mon, 01 Jan 0001 00:00:00 +0000

Testing is an essential part of software development. There are different kinds of tests, but for now we’ll focus on unit testing. Unit testing is a software testing method where individual components (units) of a program are tested in isolation to ensure they work as expected. It helps detect bugs early, improves code quality, and simplifies debugging. In Java we mainly use JUnit. In this example, we take our Animal class and test its methods.

Comparing objects

Mon, 01 Jan 0001 00:00:00 +0000

In Java, you can compare objects using different approaches. One thing you should never do is use ==. Let’s review an example: We have the class public class Animal { private String name; public Animal(String name) { this.name = name; } public String getName() { return name; } } And then we do public void testAnimalEquals() { Animal schatzi = new Animal("Schatzi"); Animal schatzi2 = new Animal("Schatzi"); assertTrue(schatzi == schatzi2); } Both animals have the same exact name and nothing else. Using schatzi == schatzi2, what’s the result?

Complexity of Algorithms

Mon, 01 Jan 0001 00:00:00 +0000

There are 2 measurements to evaluate the complexity of an algorithm: Time Complexity (Efficiency) Big-O Notation: This describes the upper bound of an algorithm’s growth rate as the input size increases. It helps estimate how the algorithm’s running time grows with input size (n). Common time complexities include: O(1): Constant time O(log n): Logarithmic time O(n): Linear time O(n log n): Log-linear time O(n^2): Quadratic time When discussing time complexity, the focus is on the average/expected cases, but there are different ones:

Data Structures

Mon, 01 Jan 0001 00:00:00 +0000

Array A fixed-size, indexed collection of elements of the same type. Best for storing a fixed number of elements with fast access by index. int[] arr = new int[5]; // Array of 5 integers, default value is 0 ArrayList A dynamically resizing array that allows random access and provides flexible resizing. Ideal for collections with frequent access and occasional insertions or deletions. ArrayList arrayList = new ArrayList<>(); // Empty ArrayList of integers LinkedList A linear collection where each element (node) contains a reference to the next element. In a double-linked list, each element also holds a reference to the previous element. Best when frequent insertions and deletions at the beginning or end are required.

HashMap Deep Dive

Mon, 01 Jan 0001 00:00:00 +0000

A HashMap is an implementation of the Map interface in Java that stores key-value pairs. It provides efficient O(1) average-time complexity for operations like insert, delete, and search. However, its performance can degrade under certain circumstances, leading to the worst-case time complexity of O(n). How HashMap works Hash Function A HashMap uses a hash function to compute an index (called a bucket) where the key-value pair will be stored. The hash function takes the key, processes it, and returns an integer index. The goal of a good hash function is to evenly distribute the keys across the available buckets to minimize collisions.