Java 101: Building a Solid Foundation for Backend Mastery#

Breakdown of the Code#

• public class HelloWorld: Declares a public class named HelloWorld. In Java, the filename must match the class name (for public classes).
• main method: Execution begins in the main method. This method signature must follow public static void main(String[] args).
• System.out.println: Prints output to the console, followed by a newline.

To compile and run:

1. javac HelloWorld.java
2. java HelloWorld

Java places strict emphasis on naming conventions, file organization, and strong typing. Let’s build on this foundation step by step.

3.1 Overview of Primitive Data Types#

Primitive data types in Java are not objects; they store values directly in memory. Java has eight primitive data types:

3.2 Reference Data Types#

All non-primitive types, including arrays and classes, are reference types. They store a reference (or pointer) to the memory location of the actual data.

Example:

1
String name = "Alice";
2
String anotherName = new String("Bob"); // less common in modern practice

Unlike primitive types, reference types can represent more complex structures. Java’s powerful object model is built around leveraging classes and objects.

5.1 if-else Statements#

1
if (a > b) {
2
    System.out.println("a is greater than b");
3
} else if (a == b) {
4
    System.out.println("a equals b");
5
} else {
6
    System.out.println("b is greater than a");
7
}

5.2 switch Statements#

1
int dayOfWeek = 3;
2
switch (dayOfWeek) {
3
    case 1:
4
        System.out.println("Monday");
5
        break;
6
    case 2:
7
        System.out.println("Tuesday");
8
        break;
9
    case 3:
10
        System.out.println("Wednesday");
11
        break;
12
    default:
13
        System.out.println("Other day");
14
}

In modern Java versions, you can also use the enhanced switch expression syntax to directly produce a value.

5.3 Loops#

• for Loop: Repeats a block of code a known number of times.

  1
  for (int i = 0; i < 5; i++) {
  2
      System.out.println("i is: " + i);
  3
  }
  

• while Loop: Continues as long as a condition remains true.

  1
  int i = 0;
  2
  while (i < 5) {
  3
      System.out.println("i is: " + i);
  4
      i++;
  5
  }
  

• do-while Loop: Similar to while, but runs at least once.

  1
  int j = 0;
  2
  do {
  3
      System.out.println("j is: " + j);
  4
      j++;
  5
  } while (j < 5);
  

6.1 Classes and Objects#

A class is a blueprint, while an object is an instance of that class. Consider a simple Car class:

1
public class Car {
2
    private String make;
3
    private String model;
4
    private int year;
5

6
    public Car(String make, String model, int year) {
7
        this.make  = make;
8
        this.model = model;
9
        this.year  = year;
10
    }
11

12
    public void displayInfo() {
13
        System.out.println("Make: " + make + ", Model: " + model + ", Year: " + year);
14
    }
15
}

You can create an object (instance) of Car like so:

1
Car myCar = new Car("Toyota", "Camry", 2020);
2
myCar.displayInfo();

6.2 Encapsulation#

Encapsulation means bundling data and methods within a class. Private fields combined with public getters/setters ensure data integrity.

Example:

1
public class BankAccount {
2
    private double balance;
3

4
    public BankAccount(double balance) {
5
        this.balance = balance;
6
    }
7

8
    public double getBalance() {
9
        return balance;
10
    }
11

12
    public void deposit(double amount) {
13
        if (amount > 0) {
14
            balance += amount;
15
        }
16
    }
17

18
    public void withdraw(double amount) {
19
        if (amount > 0 && amount <= balance) {
20
            balance -= amount;
21
        }
22
    }
23
}

6.3 Inheritance#

Inheritance allows a child class to derive properties and methods from a parent (super) class:

1
public class Animal {
2
    public void eat() {
3
        System.out.println("The animal is eating.");
4
    }
5
}
6

7
public class Dog extends Animal {
8
    public void bark() {
9
        System.out.println("The dog is barking.");
10
    }
11
}
12

13
Dog dog = new Dog();
14
dog.eat();   // Inherited method
15
dog.bark();  // Child's method

6.4 Polymorphism#

Polymorphism enables a single interface to represent different underlying forms. For instance, each subclass of Animal can have its own eat() implementation:

1
public class Cat extends Animal {
2
    @Override
3
    public void eat() {
4
        System.out.println("The cat is eating fish.");
5
    }
6
}

Thus, calling eat() on a generic Animal reference at runtime can invoke different methods depending on the actual instance.

7.1 Interfaces#

An interface defines a contract without specifying implementation details. Here is an example:

1
public interface PaymentService {
2
    void processPayment(double amount);
3
}

Any class implementing PaymentService must provide the processPayment method:

1
public class CreditCardPayment implements PaymentService {
2
    @Override
3
    public void processPayment(double amount) {
4
        System.out.println("Processing credit card payment of $" + amount);
5
    }
6
}

7.2 Abstract Classes#

An abstract class sits between a fully concrete class and an interface:

1
public abstract class Shape {
2
    protected String color;
3

4
    public Shape(String color) {
5
        this.color = color;
6
    }
7

8
    public abstract double getArea();
9
}

Concrete subclasses must implement the abstract methods, but the abstract class can include partial method implementations or fields.

8.1 List Interface#

Exemplified by ArrayList and LinkedList, both of which maintain an ordered collection of elements.

1
List<String> names = new ArrayList<>();
2
names.add("Alice");
3
names.add("Bob");
4
names.add("Charlie");
5

6
for (String name : names) {
7
    System.out.println(name);
8
}

8.2 Set Interface#

Used for storing unique elements. Common implementations include HashSet and TreeSet.

1
Set<Integer> numbers = new HashSet<>();
2
numbers.add(10);
3
numbers.add(20);
4
numbers.add(10);  // duplicate, ignored
5

6
System.out.println(numbers.size()); // Output: 2

8.3 Map Interface#

Stores key-value pairs, with HashMap as the most widely used implementation.

1
Map<String, Integer> scores = new HashMap<>();
2
scores.put("Alice", 95);
3
scores.put("Bob", 88);
4
scores.put("Charlie", 90);
5

6
System.out.println(scores.get("Alice")); // 95

9.1 try-catch Blocks#

1
try {
2
    int result = 10 / 0;
3
} catch (ArithmeticException e) {
4
    System.out.println("Divide by zero error: " + e.getMessage());
5
}

Execution jumps to the catch block if the exception is thrown.

9.2 Throwing and Declaring Exceptions#

You can throw your own exceptions:

1
if (amount <= 0) {
2
    throw new IllegalArgumentException("Amount must be positive");
3
}

You may also declare that a method can throw an exception (checked exception):

1
public void readFile() throws IOException {
2
    // ...
3
}

9.3 finally Block#

The finally block executes whether an exception is thrown or not:

1
try {
2
    // risky operation
3
} catch (IOException e) {
4
    // handle exception
5
} finally {
6
    // cleanup code
7
}

10.1 File Input#

1
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
2
    String line;
3
    while ((line = reader.readLine()) != null) {
4
        System.out.println(line);
5
    }
6
} catch (IOException e) {
7
    e.printStackTrace();
8
}

10.2 File Output#

1
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
2
    writer.write("Hello, World!");
3
} catch (IOException e) {
4
    e.printStackTrace();
5
}

Using the try-with-resources statement ensures automatic resource closure.

11.1 Creating Threads#

1. Extend Thread:

   1
   public class MyThread extends Thread {
   2
       @Override
   3
       public void run() {
   4
           System.out.println("Hello from MyThread!");
   5
       }
   6
   }
   7
   
   8
   MyThread thread = new MyThread();
   9
   thread.start();
   

2. Implement Runnable:

   1
   public class MyRunnable implements Runnable {
   2
       @Override
   3
       public void run() {
   4
           System.out.println("Hello from MyRunnable!");
   5
       }
   6
   }
   7
   
   8
   Thread thread = new Thread(new MyRunnable());
   9
   thread.start();
   

11.2 Synchronization#

Multiple threads may need to share data safely. Java provides the synchronized keyword to control access to shared resources.

1
public class Counter {
2
    private int count = 0;
3

4
    public synchronized void increment() {
5
        count++;
6
    }
7

8
    public synchronized int getValue() {
9
        return count;
10
    }
11
}

11.3 The Executor Framework#

Instead of manually managing threads, you can leverage the ExecutorService:

1
ExecutorService executor = Executors.newFixedThreadPool(4);
2
executor.submit(() -> System.out.println("Task 1"));
3
executor.submit(() -> System.out.println("Task 2"));
4
executor.shutdown();

13.1 Common Annotations#

• @Override: Ensures you are overriding a method from the parent class.
• @Deprecated: Marks a method or class as deprecated.
• @SuppressWarnings: Suppresses compiler warnings.

13.2 Reflection Example#

Reflection can instantiate classes or invoke methods dynamically:

1
Class<?> clazz = Class.forName("com.example.MyClass");
2
Object instance = clazz.newInstance();
3

4
Method method = clazz.getMethod("someMethod", String.class);
5
method.invoke(instance, "Hello");

14.1 Coding Style#

• Follow established naming conventions for classes, methods, and variables (e.g., class names start with an uppercase letter, method names with a lowercase letter).
• Keep methods focused on a single task to improve readability and maintainability.

14.2 Handling Nulls and Optional#

• Avoid excessive null checks by using Optional in Java 8 and above.
• Return empty collections instead of null to reduce potential NullPointerExceptions.

14.3 Immutable Objects#

• Limit mutability wherever possible. Immutable classes are inherently thread-safe and easier to reason about.
• Use final fields to enforce immutability.

14.4 Logging#

• Use established logging frameworks like SLF4J with Logback or Log4j for consistent, configurable, and performant logging.

15.1 Spring Framework#

Spring is a comprehensive ecosystem providing features such as:

• Dependency Injection (DI): Simplifies object creation and links components with minimal coupling.
• Spring MVC: Builds web applications using a model-view-controller architecture.
• Spring Boot: Streamlines configuration, packaging, and deployment. Provides embedded servers and ready-to-run setups.

Example: A simple Spring Boot REST controller:

1
@RestController
2
public class GreetingController {
3

4
    @GetMapping("/hello")
5
    public String sayHello() {
6
        return "Hello from Spring Boot!";
7
    }
8
}

15.2 Java Persistence API (JPA) and Hibernate#

JPA is an ORM (Object-Relational Mapping) specification, with Hibernate as a popular implementation. It maps Java objects to relational database tables.

1
@Entity
2
public class User {
3
    @Id
4
    @GeneratedValue
5
    private Long id;
6

7
    private String username;
8
    private String email;
9

10
    // getters and setters
11
}

A Repository interface (Spring Data JPA) might look like:

1
public interface UserRepository extends JpaRepository<User, Long> {
2
    List<User> findByUsername(String username);
3
}

15.3 Advanced Concurrency#

To handle high loads:

• Use CompletableFuture and Java’s async APIs to run jobs asynchronously.
• Explore concurrency libraries like Fork/Join Framework for parallelism.
• Employ advanced concurrency constructs like CountDownLatch, CyclicBarrier, and Semaphore.

15.4 Microservices#

Java-based microservices often rely on:

• Spring Cloud: Integrations for service discovery, configuration, and circuit breakers.
• MicroProfile: Set of APIs optimized for microservices, supporting JAX-RS, CDI, and JSON-B, among others.

15.5 Design Patterns#

Familiarity with patterns such as Singleton, Factory, Builder, and Observer helps you structure complex systems in a scalable way.

Example – The Singleton Pattern:

1
public class Singleton {
2
    private static Singleton instance;
3

4
    private Singleton() {
5
        // private constructor
6
    }
7

8
    public static synchronized Singleton getInstance() {
9
        if (instance == null) {
10
            instance = new Singleton();
11
        }
12
        return instance;
13
    }
14
}