Java Syntax Basics

Variables:
- Declaration: type variableName;
- Primitive data types: int, double, boolean, etc.
- Reference data types: String, Array, etc.
Operators:
- Arithmetic operators: +, -, *, /, etc.
- Comparison operators: ==, !=, >, <, etc.
- Logical operators: &&, ||, !
Control Flow:
- Conditional statements: if, if-else, switch
- Loops: for, while, do-while
Methods:
- Method declaration: returnType methodName(parameters) { ... }
- Method calling: methodName(arguments)

Classes and Objects:
- Class: a blueprint for creating objects
- Object: an instance of a class
Inheritance:
- A child class inherits properties and behavior from a parent class
- extends keyword is used to inherit from a parent class
Polymorphism:
- Method overriding: a child class provides a different implementation of a method
- Method overloading: multiple methods with the same name but different parameters
Encapsulation:
- Hiding internal implementation details from the outside world
- Using private variables and public methods to access them

Thread:
- A separate path of execution within a program
- Created using Thread class or Runnable interface
Thread Life Cycle:
- Newborn: created but not started
- Runnable: eligible to run
- Running: executing
- Dead: finished or terminated
Synchronization:
- Using synchronized keyword to ensure thread safety
- Using wait() and notify() methods to coordinate threads

Try-Catch Block:
- try block: code that may throw an exception
- catch block: code to handle an exception
Exception Types:
- Checked exceptions: must be handled or declared
- Unchecked exceptions: runtime exceptions, no need to handle or declare
Throwing Exceptions:
- Using throw keyword to throw an exception
- Using throws keyword to declare an exception

Default Constructor:
- A no-argument constructor provided by the compiler
- Used to initialize objects when no constructor is defined
Parameterized Constructor:
- A constructor with parameters
- Used to initialize objects with specific values
Copy Constructor:
- A constructor that creates a copy of an object
- Used to create a duplicate object

Variables Declaration:
- Must specify the data type followed by the variable name
- Syntax: type variableName;
Primitive Data Types:
- Examples: int, double, boolean
- Store a single value
Reference Data Types:
- Examples: String, Array
- Store a reference to an object
Arithmetic Operators:
- Used for mathematical operations
- Examples: +, -, *, /
Comparison Operators:
- Used for comparing values
- Examples: ==, !=, >, <

OOP is a programming paradigm that revolves around the concept of objects and classes.
Key features of OOP include encapsulation, abstraction, inheritance, and polymorphism.
Encapsulation bundles data and methods that operate on that data within a single unit (class).
Abstraction exposes only necessary information to the outside world while hiding internal details.
Inheritance creates a new class based on an existing class.
Polymorphism allows an object to take on multiple forms.

An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions.
Types of exceptions include checked exceptions (e.g., IOException) and unchecked exceptions (e.g., NullPointerException).
Exception handling mechanisms include try-catch block, throw keyword, and throws keyword.

A constructor is a special method that is used to initialize objects when they are created.
Characteristics of constructors include having the same name as the class, having no return type, and being called when an object is created.
Types of constructors include default constructor (a constructor with no parameters) and parameterized constructor (a constructor with parameters).

Access modifiers are used to control access to classes, methods, and variables.
Types of access modifiers include public, private, protected, and default (or package-private).
Public access allows access from anywhere.
Private access allows access only within the same class.
Protected access allows access within the same class and its subclasses.
Default access allows access within the same package.

Inheritance is a mechanism that allows one class to inherit the properties and behavior of another class.
Key concepts include superclass (or parent class), subclass (or child class), and inheritance types.
Superclass is the class from which another class inherits.
Subclass is the class that inherits from another class.
Inheritance types include single inheritance, multilevel inheritance, hierarchical inheritance, and multiple inheritance.

Polymorphism is the ability of an object to take on multiple forms.
Types of polymorphism include method overriding, method overloading, and operator overloading.
Method overriding is a subclass providing a different implementation of a method already defined in its superclass.
Method overloading is multiple methods with the same name but different parameters.
Operator overloading is not supported in Java.

Abstraction is the concept of showing only necessary information to the outside world while hiding internal details.
Abstraction in Java includes abstract classes, abstract methods, and interfaces.
Abstract classes are classes that cannot be instantiated and are used as a base class for other classes.
Abstract methods are methods that are declared without an implementation.
Interfaces are abstract classes that define a contract for other classes to implement.