Basic Syntax and Structure

Java programs consist of classes, methods, and statements that are executed in a specific order. Here's the basic structure of a simple Java program:

    
        // This is a comment

        public class Example {
            public static void main(String[] args) {
                // Code goes here
            }
        }

Class Definition:: The public class Example defines a class named Example. A Java program can have multiple classes, but one class must have the main method.
Method Declaration:: The public static void main(String[] args) is the entry point for the program. It is where the execution begins.
Comments:: Java supports both single-line and multi-line comments. Single-line comments start with //, and multi-line comments are enclosed with /* and */.

Classes and Methods

Classes:
A class is a blueprint for objects. It defines the properties (variables) and behaviors (methods) that an object can have.
Methods:
A method is a block of code that performs a specific task. It contains a set of instructions to be executed.
Method Definition:
public void printMessage() defines a method named printMessage that doesn't return anything (void).
Creating an Object:
In the main method, we create an object of MyClass using new MyClass().
Calling the Method:
The printMessage method is invoked on the object obj.

    
    public class MyClass {

        // This is a method that prints a message
        public void printMessage() {
            System.out.println("Hello from the method!");
        }

        public static void main(String[] args) {
            MyClass obj = new MyClass();  // Creating an object of MyClass
            obj.printMessage();           // Calling the method
        }
    }

Comments

Java supports three types of comments:

Single-line comments:
Used to comment out a single line.
```
// This is a single-line comment
```

Multi-line comments:

Used to comment out multiple lines.


             /* 
             * This is a multi-line comment
             * that spans multiple lines.
             */

Javadoc comments:

Used to generate documentation for classes and methods.


             /**
             * This is a Javadoc comment
             * that can be used for documentation.
             */

Variables and Data Types

In Java, variables are used to store data. Each variable has a data type that determines what kind of data it can store.

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
char: 16-bit Unicode character
boolean: Represents true or false

    
    public class VariablesExample {
        public static void main(String[] args) {
            int age = 25;                  // Integer variable
            double price = 19.99;          // Double variable (floating-point number)
            char grade = 'A';              // Char variable (single character)
            boolean isJavaFun = true;      // Boolean variable (true/false)

            System.out.println("Age: " + age);
            System.out.println("Price: " + price);
            System.out.println("Grade: " + grade);
            System.out.println("Is Java fun? " + isJavaFun);
        }
    }

Basic I/O (Input and Output)

Java provides built-in classes for input and output (I/O). The most common classes are System.out for output and Scanner for input.

Output: Printing to the Console

You can print to the console using System.out.println() for printing with a newline and System.out.print() for printing without a newline.

    
    public class OutputExample {
        public static void main(String[] args) {
            System.out.println("Hello, World!");  // Prints with a newline
            System.out.print("Hello, ");          // Prints without a newline
            System.out.print("Java!");            // Prints on the same line
        }
    }

Input: Reading from the Console

To read input from the user, we use the Scanner class.

    
    import java.util.Scanner;

    public class InputExample {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);  // Create a Scanner object

            System.out.print("Enter your name: ");
            String name = scanner.nextLine();          // Read a string input
            System.out.println("Hello, " + name + "!");

            System.out.print("Enter your age: ");
            int age = scanner.nextInt();              // Read an integer input
            System.out.println("You are " + age + " years old.");

            scanner.close();  // Close the scanner
        }
    }

nextLine() Reads a line of text.
nextInt() Reads an integer.
scanner.close() Always close the scanner to avoid resource leaks.

Arithmetic Operations

Java supports standard arithmetic operations, such as addition, subtraction, multiplication, and division. The basic operators are:

+ (addition)
- (subtraction)
* (multiplication)
/ (division)
% (modulus)

Example of Arithmetic Operations:

    
    public class ArithmeticExample {
        public static void main(String[] args) {
            int a = 10;
            int b = 3;

            System.out.println("Addition: " + (a + b));        // 10 + 3 = 13
            System.out.println("Subtraction: " + (a - b));     // 10 - 3 = 7
            System.out.println("Multiplication: " + (a * b));  // 10 * 3 = 30
            System.out.println("Division: " + (a / b));        // 10 / 3 = 3 (integer division)
            System.out.println("Modulus: " + (a % b));         // 10 % 3 = 1 (remainder)
        }
    }

Note: When dividing two integers, Java performs integer division (the fractional part is discarded). For floating-point division, you can use double or float types.

String Handling

Strings in Java are objects, and you can perform various operations on them, such as concatenation, comparison, and manipulation.

Basic String Operations:

    
    public class StringExample {
        public static void main(String[] args) {
            String greeting = "Hello";
            String name = "Java";

            // Concatenation
            String message = greeting + " " + name;
            System.out.println(message);  // Output: Hello Java

            // String length
            System.out.println("Length: " + message.length());  // Output: 10

            // Convert to uppercase
            System.out.println(message.toUpperCase());  // Output: HELLO JAVA

            // Convert to lowercase
            System.out.println(message.toLowerCase());  // Output: hello java

            // String comparison
            boolean isEqual = greeting.equals(name);
            System.out.println("Are the strings equal? " + isEqual);  // Output: false

            // Substring
            String substring = message.substring(6, 10);
            System.out.println(substring);  // Output: Java
        }
    }

Basic Syntax and Structure