Java Syntax Basics

Java Syntax

Basic Structure of a Java Program
- Every Java application must have at least one class.
- The main method is the entry point:
```
public static void main(String[] args) {
    // Code goes here
}
```
Comments
- Single-line comment: // This is a comment
- Multi-line comment:
```
/* This is a 
   multi-line comment */
```
- Documentation comment:
```
/** This is a documentation comment */
```
Data Types
- Primitive types: int, char, boolean, double, float, long, byte, short
- Non-primitive types: String, Arrays, Classes
Variables
- Declaration: dataType variableName;
- Initialization: variableName = value;
- Example:
```
int count = 10;
String name = "Java";
```
Operators
- Arithmetic: +, -, *, /, %
- Relational: ==, !=, <, >, <=, >=
- Logical: &&, ||, !
- Assignment: =, +=, -=, *=, /=, %=

Control Statements

Conditional statements:

if statement:
```
if (condition) {
    // code
}
```

else if and else:

else if (condition) {
    // code
} else {
    // code
}

switch statement:

switch (variable) {
    case value1:
        // code
        break;
    default:
        // code
}

Loops

for loop:

for (initialization; condition; increment) {
    // code
}

while loop:
```
while (condition) {
    // code
}
```
do-while loop:
```
do {
    // code
} while (condition);
```

Arrays
- Declaration: dataType[] arrayName;
- Initialization:
```
int[] numbers = {1, 2, 3, 4, 5};
```

Methods

Method declaration:

returnType methodName(parameters) {
    // code
}

Example:

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

Exception Handling

try, catch, and finally:

try {
    // code that may throw an exception
} catch (ExceptionType e) {
    // code to handle exception
} finally {
    // code to execute regardless of exception
}

Modifiers
- Access modifiers: public, private, protected, and package-private (default)
- Non-access modifiers: static, final, abstract, and synchronized

These points summarize the fundamental aspects of Java syntax for programming.

Basic Structure of a Java Program

At least one class is mandatory for every Java application.
The program execution begins at the main method, which is defined as:
```
public static void main(String[] args) {
    // Code goes here
}
```

Comments

Single-line comments are created using //.
Multi-line comments are enclosed between /* and */.
Documentation comments use /** and */, typically for generating documentation.

Data Types

Primitive types include:
- int (integer), char (character), boolean (true/false), double (double-precision floating-point), float (single-precision floating-point), long (large integer), byte (8-bit integer), short (short integer).
Non-primitive types consist of String, Arrays, and user-defined Classes.

Variables

Variable declaration uses the syntax: dataType variableName;.
Initialization requires assigning a value: variableName = value;.
Example of declaring and initializing variables:
```
int count = 10;
String name = "Java";
```

Operators

Arithmetic operators: Perform mathematical operations (+, -, *, /, %).
Relational operators: Compare values (==, !=, >, <, >=, <=).
Logical operators: Combine boolean expressions (&&, ||, !).
Assignment operators: Assign values (=, +=, -=, *=, /=, %=) with shorthand notation.

Control Statements

Conditional statements:

if statement checks conditions:
```
if (condition) {
    // code
}
```

else if and else provide alternative conditions:

else if (condition) {
    // code
} else {
    // code
}

switch statement for multi-way branching:

switch (variable) {
    case value1:
        // code
        break;
    default:
        // code
}

Loops

for loop for fixed iterations:

for (initialization; condition; increment) {
    // code
}

while loop continues until condition is false:
```
while (condition) {
    // code
}
```
do-while loop guarantees at least one execution:
```
do {
    // code
} while (condition);
```

Arrays

Arrays are declared with the following syntax:
```
dataType[] arrayName;
```
Initialization example:
```
int[] numbers = {1, 2, 3, 4, 5};
```

Methods

Method declarations consist of a return type, method name, and parameters:
```
returnType methodName(parameters) {
    // code
}
```

Example of a method that adds two integers:

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

Exception Handling

Exception handling is managed through try, catch, and finally blocks:

try {
    // code that may throw an exception
} catch (ExceptionType e) {
    // code to handle exception
} finally {
    // code executed regardless of exception
}

Modifiers

Access modifiers control visibility:
- public, private, protected, and package-private (default).
Non-access modifiers define class behavior:
- static (class-level), final (constant), abstract (incomplete), synchronized (thread-safe).