Java and Object-Oriented Programming (OOP)

• Java is a high-level, class-based, object-oriented programming language designed to have as few implementation dependencies as possible.
• It's a general-purpose language intended to let application developers write once, run anywhere (WORA), meaning compiled Java code can run on all platforms supporting Java without recompilation.

Object-Oriented Programming (OOP)

• OOP is a programming paradigm based on "objects," containing data and code.
• Data in objects is in the form of fields (attributes or properties).
• Code in objects is in the form of procedures (methods).
• Key principles of OOP:
  • Abstraction simplifies complex reality by modeling classes appropriate to the problem.
  • Encapsulation bundles data with methods that operate on that data, restricting direct access to some object components.
  • Inheritance creates new classes (subclasses) from existing classes (superclasses), inheriting their properties/behaviors, which can be extended/modified.
  • Polymorphism is the ability of a variable, function, or object to take on multiple forms.

Java Syntax

• Java syntax is similar to C and C++.
• A Java program consists of one or more classes, each typically in a separate .java file.
• The main method is the entry point: public static void main(String[] args).
• Variables must be declared with a specific data type (e.g., int, double, String, boolean).
• Control flow statements include if-else, for, while, and switch.
• Operators include arithmetic, relational, logical, and assignment operators.
• Semicolons terminate statements.
• Curly braces {} define blocks of code.

Data Types

• Primitive Data Types:
  • byte: 8-bit integer
  • short: 16-bit integer
  • int: 32-bit integer
  • long: 64-bit integer
  • float: 32-bit floating-point number
  • double: 64-bit floating-point number
  • boolean: true or false
  • char: 16-bit Unicode character
• Non-Primitive Data Types (Reference Types):
  • Classes
  • Interfaces
  • Arrays
  • Objects

Variables

• Variables are named storage locations holding data values during a program's execution.
• Java is statically-typed; the type of a variable must be declared before use.
• Variable declaration syntax: dataType variableName;
• Variable initialization syntax: variableName = value;

Operators

• Arithmetic Operators: +, -, *, /, % (modulus)
• Relational Operators: == (equal to), != (not equal to), >, <, >=, <=
• Logical Operators: && (AND), || (OR), ! (NOT)
• Assignment Operators: =, +=, -=, *=, /=, %=
• Increment and Decrement Operators: ++, --

Control Flow

• if-else statements:
  • Execute different code blocks based on a condition.
  • Syntax:

    if (condition) {
        // code to execute if condition is true
    } else {
        // code to execute if condition is false
    }
    

• for loops:
  • Execute a code block repeatedly for a specified number of times.
  • Syntax:

    for (initialization; condition; increment/decrement) {
        // code to execute
    }
    

• while loops:
  • Execute a code block repeatedly as long as a condition is true.
  • Syntax:

    while (condition) {
        // code to execute
    }
    

• do-while loops:
  • Similar to a while loop, but the code block executes at least once.
  • Syntax:

    do {
        // code to execute
    } while (condition);
    

• switch statements:
  • Execute different code blocks based on a variable's value.
  • Syntax:

    switch (variable) {
        case value1:
            // code to execute if variable == value1
            break;
        case value2:
            // code to execute if variable == value2
            break;
        default:
            // code to execute if no case matches
    }
    

Classes and Objects

• A class is a blueprint for creating objects, defining properties (fields) and behaviors (methods).
• An object is an instance of a class.
• Creating an object: ClassName objectName = new ClassName();
• Accessing object members: objectName.fieldName, objectName.methodName()

Methods

• A method is a code block that performs a specific task.
• Method declaration: accessModifier returnType methodName(parameters) { // method body }
• Parameters are values passed to a method.
• The return type specifies the type of value a method returns or void if it returns nothing.

Exception Handling

• Exceptions are events that disrupt the normal flow of a program's execution.
• Java's mechanism to handle exceptions uses try-catch blocks.
• try block: Encloses code that might throw an exception.
• catch block: Catches and handles a specific type of exception.
• finally block: Always executed, regardless of exceptions, typically for cleanup.
• Syntax:

  try {
      // code that might throw an exception
  } catch (ExceptionType e) {
      // code to handle the exception
  } finally {
      // code that always executes
  }
  

• Commonly used exception classes:
  • IOException
  • NullPointerException
  • ArithmeticException
  • ArrayIndexOutOfBoundsException

Throwing Exceptions

• The throw keyword explicitly throws an exception.
• Example:

  if (age < 0) {
      throw new IllegalArgumentException("Age cannot be negative.");
  }
  

Concurrent Programming

• Concurrent programming involves executing multiple tasks or threads simultaneously.
• Java provides built-in support for concurrency through the Thread class and Runnable interface.
• Thread: A unit of execution within a process.
• Runnable: An interface with a single run() method containing code to execute in a thread.
• Creating a thread:
  • By extending the Thread class.
  • By implementing the Runnable interface.
• Starting a thread: threadName.start();
• Common concurrency issues:
  • Race conditions: Multiple threads accessing/modifying shared data concurrently, leading to unpredictable results.
  • Deadlocks: Two or more threads blocked indefinitely, waiting for each other to release resources.

Synchronization

• Synchronization controls access to shared resources by multiple threads, preventing race conditions.
• Java provides the synchronized keyword for synchronization.
• Synchronized methods: Only one thread can execute a synchronized method of an object at a time.
• Synchronized blocks: Allow specific code sections to be synchronized.
• Syntax:

  synchronized (object) {
      // code to be synchronized
  }
  

• The java.util.concurrent package provides high-level concurrency utilities like Executor, ExecutorService, Future, and Concurrent collections.

Java Libraries

• Java provides a rich set of standard libraries through the Java Development Kit (JDK).
• Core Libraries:
  • java.lang: Fundamental classes/interfaces, such as Object, String, Math, and Thread.
  • java.util: Utility classes, such as collections (List, Set, Map), date/time utilities, and random number generators.
  • java.io: Classes for input and output operations, such as reading from/writing to files and streams.
  • java.net: Classes for networking, such as sockets, URLs, and HTTP connections.
  • java.nio: Classes for non-blocking I/O operations.
  • java.math: Classes for arithmetic operations with arbitrary precision numbers (BigInteger, BigDecimal).
• Collections Framework:
  • Provides a set of interfaces and classes for storing and manipulating collections of objects.
  • Key interfaces: List, Set, Map, Queue.
  • Common implementations: ArrayList, LinkedList, HashSet, TreeSet, HashMap, TreeMap.
• Input/Output (I/O):
  • Provides classes for reading and writing data from various sources, such as files, streams, and the console.
  • Classes: InputStream, OutputStream, Reader, Writer, File, FileInputStream, FileOutputStream, BufferedReader, BufferedWriter.
• Networking:
  • Provides classes for developing network applications.
  • Classes: Socket, ServerSocket, URL, HttpURLConnection.
• Date and Time API:
  • The java.time package (introduced in Java 8) provides a comprehensive and modern API for working with dates and times.
  • Key classes: LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Duration, Period.