1. The Classic "Hello, World!" Program
Let's start with the traditional first program that every programmer writes:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Hello, World!
áᎠprogram á screen áážáŹ "Hello, World!" áááŻáá˛áˇ text ááᯠááźááąá¸áážáŹ ááźá áşááŤáááşá áááŻá¸áážááşá¸ááąáááˇáş Java programming áá˛áˇ áĄááźáąááś structure áĄáŹá¸ááŻáśá¸ ááŤáááşááŤáááşá
How it works:
- JVM á program ááᯠstart ááŻááşáá˛áˇ áĄááŤ
mainmethod ááᯠáážáŹááŤáááş mainmethod áĄáá˛á statements áá˝áąááᯠtop-to-bottom execute ááŻááşááŤáááşSystem.out.println()á text ááᯠconsole áážáŹ print ááŻááşááąá¸ááŤáááş- Program á ááźáŽá¸ááŻáśá¸ááŤáááş (no more statements to execute)
2. Java Program Structure (áĄááąá¸á áááş áá˝á˛ááźááşá¸á áááşááźáŹááźááşá¸)
// 1. Class Declaration
public class HelloWorld {
// 2. Main Method (Entry Point)
public static void main(String[] args) {
// 3. Method Body (Executable Code)
System.out.println("Hello, World!");
} // End of main method
} // End of class
Part 1: Class Declaration
public class HelloWorld {
// class body
}
public - Access modifier ááŤá áᎠclass ááᯠáááşáááąáááᯠaccess
ááŻááşáááŻáˇ ááááş áááŻáá˛áˇ áááąáŹááŤá
public= Everyone can accessprivate= Only within this classprotected= Subclasses can access- No modifier = Package-private (same package only)
class - Java keyword ááŤá Class áá
áşáᯠdeclare ááŻááşáááş ááŻáśá¸ááŤáááşá
Java áážáŹ code áĄáŹá¸ááŻáśá¸ class áá˛áážáŹ ááąá¸áááŤáááşá
HelloWorld - Class áá˛áˇ ááŹáááşááŤá Naming Rules:
- CapitalCase (PascalCase) ááŻáśá¸á፠- á áŹááŻáśá¸ááźáŽá¸áá˛áˇ á á፠(HelloWorld, MyClass, StudentInfo)
- File name áá˛áˇ exactly áá°áááŤáááş - HelloWorld class ááᯠHelloWorld.java ááźá áşááááş
- Letters, digits, underscore, dollar sign áᏠááŻáśá¸áááŻáˇ áááŤáááş
- Digit áá˛áˇ áá áááŻááşá፠- 3Class â, Class3 â
- Java keywords áááŻáśá¸áá፠- class, public, int á ááŹáá˝áą â
- Case-sensitive ááźá áşááŤáááş - HelloWorld â helloworld
{ } - Curly braces á class body ááᯠdefine ááŻááşááŤáááşá Class áá˛áˇ
code áĄáŹá¸ááŻáśá¸ curly braces áĄáá˝ááşá¸áážáŹ ááąá¸áááŤáááşá
Part 2: Main Method
public static void main(String[] args) {
// method body
}
Main method á Java program áá˛áˇ entry point (á
áááşáᏠááąááŹ)
ááźá
áşááŤáááşá JVM á program run áá˛áˇ áĄá፠main method ááᯠáĄáááşááŻáśá¸ áážáŹááźáŽá¸ execute
ááŻááşááŤáááşá
Signature breakdown (áĄá áááşáĄáááŻááşá¸áá áşááŻááťááşá¸á áŽ):
public - JVM á áááşáááąáááᯠaccess ááŻááşáááŻááşáááŻáˇ public
ááźá
áşáááŤáááşá JVM á class áĄááźááşáááą ááąáŤáşáážáŹ ááźá
áşáááŻáˇááŤá
static - Object áááŻááşáᲠááąáŤáşáááŻáˇ ááááŻáˇ static ááźá
áşáááŤáááşá
- JVM á
HelloWorldobject áááŻááşáá˛HelloWorld.main()ááᯠáááŻááşáááŻááş ááąáŤáşááťááşáááŻáˇá፠staticmethods áá˝áąá class-level ááźá áşááźáŽá¸ object ááááŻááŤ- Non-static ááᯠobject create ááŻááşááážáŹ ááźá
áşááŤáááş -
HelloWorld obj = new HelloWorld();
void - Return type ááŤá void áááŻáᏠááŹááž return
áááŻááşáá°á¸ áááŻáá˛áˇ áááąáŹááŤá
void= Returns nothingint= Returns integer numberString= Returns text- Main method á
voidááźá áşáááŤáááş (JVM requirement)
main - Method ááŹáááşááŤá ááŤá fixed name ááźá
áşááźáŽá¸
ááźáąáŹááşá¸áááŻáˇ ááááŤá JVM á "main" áááŻáá˛áˇ ááŹáááşááᯠáááşáážááşááŹá¸áááŻáˇááŤá
String[] args - Parameter ááŤá Command-line arguments áá˝áąáááŻ
áááşááśáááŻáˇ ááźá
áşááŤáááşá
String[]= Array of strings (text áá˝áą á áŻá ááşá¸ááŹá¸ááŹ)args= Parameter name (áááŻááşááźááŻááşáᏠááąá¸áááŻáˇáááąáááˇáş "args" á standard)- Command line áááą:
java HelloWorld arg1 arg2 arg3 - args[0] = "arg1", args[1] = "arg2", args[2] = "arg3"
đ Main method signature á exact ááźá áşáááŤáááş:
- â
public static void main(String[] args) - â
public static void main(String args[])- Also valid - â
public static void main(String... args)- Varargs also valid - â
static public void main(String[] args)- Order áážáŹá¸áááş (works but not standard) - â
public void main(String[] args)- static ááážáááąáŹáˇ error - â
public static int main(String[] args)- void áááŻááşáááş error
Part 3: Print Statement
System.out.println("Hello, World!");
System - java.lang package áá˛á built-in class
áá
áşáᯠááźá
áşááŤáááşá System ááᯠimport áááŻááşáááŤá java.lang á automatic import ááźá
áşáááŻáˇááŤá
out - System class áá˛áˇ static field áá
áşááŻ
ááźá
áşááŤáááşá ááŤá PrintStream object áá
áşáᯠááźá
áşááźáŽá¸ standard output stream
(console) ááᯠrepresent ááŻááşááŤáááşá
println() - "Print Line" áá˛áˇ áĄáááŻááąáŹááşááŤá Text ááᯠprint
ááŻááşááźáŽá¸ cursor ááᯠnext line ááᯠáá˝ážáąáˇááąá¸ááŤáááşá
println()= Print + New lineprint()= Print only (no new line)printf()= Formatted print (like C language)
"Hello, World!" - String literal ááŤá Print ááŻááşááťááşáá˛áˇ text áááŻ
double quotes (" ") áá˛áážáŹ áááˇáşááŤáááşá
- Double quotes áááŻááŤáááş - Single quotes (') á character áĄáá˝ááşááŹ
- Case-sensitive ááźá áşááŤáááş - "Hello" â "hello"
- Special characters ááŻáśá¸áááŻáˇ áááŤáááş - \n (newline), \t (tab), \" (quote)
; - Semicolon á Java áážáŹ statement áá˛áˇ áĄááŻáśá¸ marker ááŤá
áááźá
áşáááą áááˇáşáááŤáááşá Semicolon áááŤáááş compilation error ááąáŤáşááŤáááşá
3. How to Write, Compile, and Run (áĄáááˇáşáááˇáş ááŻááşáááşá¸)
Step 1: Write the Code
Create a file named HelloWorld.java using any text editor (Notepad, VS Code,
IntelliJ IDEA):
đ File Naming Rules
- File name MUST match class name exactly - Case-sensitive!
- File extension MUST be
.java - If class name is
HelloWorld, file must beHelloWorld.java - â
helloworld.java- Wrong case - â
Hello.java- Wrong name - â
HelloWorld.txt- Wrong extension - â
HelloWorld.java- Correct!
Step 2: Compile the Program
Open Command Prompt/Terminal in the folder containing your file:
javac HelloWorld.java
javac = Java Compiler command
What happens during compilation:
- Compiler á
HelloWorld.javasource file ááᯠáááşááŤáááş - Syntax errors áá˝áą á á áşááąá¸ááŤáááş (typos, missing semicolons, etc.)
- áĄáŹá¸ááŻáśá¸ áážááşáááşáááş
HelloWorld.classbytecode file ááᯠcreate ááŻááşááŤáááş - Success ááźá áşáááş output message ááážáá፠(silent success)
- Error áážááááş error messages ááźááŤáááş
After compilation: HelloWorld.class file ááąáŤáşááŹááŤáááşá ááŤá
bytecode file ááźá
áşááźáŽá¸ JVM á execute ááŻááşáážáŹ ááźá
áşááŤáááşá
Step 3: Run the Program
java HelloWorld
Hello, World!
java = Java Runtime command (JVM launcher)
â ď¸ áĄááąá¸ááźáŽá¸áá˛áˇ Points:
- Class name áᏠááŻáśá¸ááŤ, file extension (.class) áááŤáá°á¸
- â
java HelloWorld- Correct - â
java HelloWorld.class- Wrong! Don't include .class - â
java HelloWorld.java- Wrong! Don't include .java
What happens during execution:
- JVM á
HelloWorld.classfile ááᯠload ááŻááşááŤáááş mainmethod ááᯠáážáŹááźáŽá¸ execution start ááŻááşááŤáááş- Method body áá˛á statements áá˝áąááᯠtop-to-bottom execute ááŻááşááŤáááş
System.out.println()á console áážáŹ text print ááŻááşááŤáááş- No more statements áážáááąáŹáˇ program terminate ááźá áşááŤáááş
4. More Print Examples (ááąáŹááşáááş áĽáááŹááťáŹá¸)
Example 1: Multiple Print Statements
public class Welcome {
public static void main(String[] args) {
System.out.println("Welcome to Java Programming!");
System.out.println("Java is powerful and versatile.");
System.out.println("Let's learn Java together!");
}
}
Welcome to Java Programming!
Java is powerful and versatile.
Let's learn Java together!
Multiple println() statements áá˝áą ááŻáśá¸áááş line áá
áşááźáąáŹááşá¸ááťááşá¸á
Ꭰprint
ááŻááşááŤáááşá Statement áá
áşááŻááťááşá¸á
Ꭰexecute ááźáŽá¸áááş cursor á next line ááᯠáá˝ážáąáˇááŤáááşá
Statements áá˝áąá top-to-bottom order áĄáááŻááşá¸ execute ááźá áşááŤáááşá
Example 2: print() vs println()
public class PrintDemo {
public static void main(String[] args) {
// Using print() - stays on same line
System.out.print("Java ");
System.out.print("is ");
System.out.print("fun!");
// Move to next line
System.out.println();
// Using println() - moves to next line
System.out.println("Learning");
System.out.println("Programming");
}
}
Java is fun!
Learning
Programming
print() - Text print ááŻááşááźáŽá¸ cursor á same line áážáŹáá˛
áážáááąááŤáááş
- áá áşááźáąáŹááşá¸áááşá¸áážáŹ á áŹááťáŹá¸ááťáŹá¸ ááąá¸ááťááşáááş ááŻáśá¸ááŤ
- Example: Building sentences piece by piece
println() - Text print ááŻááşááźáŽá¸ cursor á next line áááŻ
áá˝ážáąáˇááŤáááş
- Line áá áş áá áşááźáąáŹááşá¸ááťááşá¸á Ꭰprint ááťááşáááş ááŻáśá¸ááŤ
- Most commonly used for output
println() with no argument - Empty line áá
áşááźáąáŹááşá¸ áááˇáşááąá¸ááŤáááş
(line break only)
Example 3: Printing Numbers and Expressions
public class Numbers {
public static void main(String[] args) {
// Printing numbers
System.out.println(100);
System.out.println(3.14);
// Printing expressions (calculations)
System.out.println(10 + 20);
System.out.println(50 - 15);
System.out.println(5 * 6);
System.out.println(100 / 4);
// Mixing text and numbers
System.out.println("Result: " + (10 + 5));
System.out.println("Pi value: " + 3.14159);
}
}
100
3.14
30
35
30
25
Result: 15
Pi value: 3.14159
Numbers without quotes: Quotes áááŤáááş number áĄááźá áş treat ááŻááşááźáŽá¸ calculations ááŻááşáááŻáˇ áááŤáááş
System.out.println(10 + 20);â Output:30(calculation)System.out.println("10 + 20");â Output:10 + 20(text)
Concatenation with + operator: Text áá˛áˇ numbers áá˝áąááᯠ+
operator áá˛áˇ ááąáŤááşá¸áááŻáˇ áááŤáááş
"Result: " + 15âResult: 15- Text ááŤáááş áĄáŹá¸ááŻáśá¸ string áĄááźá áş convert ááźá áşááŤáááş
Parentheses for calculations: Calculation ááᯠáĄáááş ááŻááşááťááşáááş parentheses () ááŻáśá¸ááŤ
"Result: " + (10 + 5)â Calculate first, then concat âResult: 15"Result: " + 10 + 5â Concat left-to-right âResult: 105(string concat!)
Example 4: Special Characters (Escape Sequences)
public class SpecialChars {
public static void main(String[] args) {
// New line
System.out.println("Line 1\nLine 2\nLine 3");
// Tab
System.out.println("Name:\tJohn");
System.out.println("Age:\t25");
// Quotes
System.out.println("She said, \"Hello!\"");
// Backslash
System.out.println("File path: C:\\Users\\Documents\\file.txt");
// Single quote (in char context)
System.out.println("It\'s a beautiful day!");
}
}
Line 1
Line 2
Line 3
Name: John
Age: 25
She said, "Hello!"
File path: C:\Users\Documents\file.txt
It's a beautiful day!
Escape sequences á backslash \ áá˛áˇ á
áá˛áˇ special character combinations ááŤ:
\n- New line (line break)\t- Tab (horizontal spacing)\"- Double quote (inside string)\'- Single quote\\- Backslash (literal backslash)\r- Carriage return\b- Backspace
ááŹááźáąáŹááˇáş áááŻáĄááşáá˛? Special meaning áážááá˛áˇ characters áá˝áąááᯠstring áá˛áážáŹ
ááŻáśá¸ááťááşáááş escape sequences ááŻáśá¸áááŤáááşá áĽááᏠ- quotes ááᯠstring áá˛áážáŹ ááźááťááşáááş
\" ááŻáśá¸áááŤáááşá
5. Common Mistakes and How to Fix Them (áĄáážáŹá¸ááťáŹá¸áážááˇáş áĄááźáąááťáŹá¸)
Mistake 1: File Name Doesn't Match Class Name
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello!");
}
}
error: class HelloWorld is public, should be declared in a file named HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello!");
}
}
File name áá˛áˇ public class name á exactly áá°áááŤáááş - case-sensitive!
Mistake 2: Missing Semicolon
public class Test {
public static void main(String[] args) {
System.out.println("Hello") // Missing semicolon!
}
}
error: ';' expected
public class Test {
public static void main(String[] args) {
System.out.println("Hello"); // Semicolon added
}
}
Mistake 3: Missing or Mismatched Braces
public class Test {
public static void main(String[] args) {
System.out.println("Hello");
// Missing closing brace for main method!
}
error: reached end of file while parsing
}
public class Test {
public static void main(String[] args) {
System.out.println("Hello");
} // Closing brace for main
} // Closing brace for class
Mistake 4: Wrong main Method Signature
public class Test {
public void main(String[] args) { // Missing 'static'
System.out.println("Hello");
}
}
Error: Main method is not static in class Test
public class Test {
public static void main(String[] args) { // 'static' included
System.out.println("Hello");
}
}
Mistake 5: Case Sensitivity Errors
public class Test {
public static void main(String[] args) {
system.out.println("Hello"); // 'system' should be 'System'
}
}
error: cannot find symbol
symbol: variable system
â ď¸ Java Case Sensitivity Rules
SystemâsystemStringâstringmainâMainprintlnâPrintln- Class names, method names, keywords - áĄáŹá¸ááŻáśá¸ case-sensitive ááźá áşááŤáááş
Mistake 6: Forgetting Double Quotes
System.out.println(Hello); // Missing quotes!
error: cannot find symbol
symbol: variable Hello
System.out.println("Hello"); // Quotes added
6. Key Takeaways (áážááşááŹá¸ááááˇáş áĄááťááşááťáŹá¸)
- Every Java program must have a class - All code lives inside classes
- File name must match public class name exactly - Case-sensitive!
- Main method is the entry point - Signature must be exact
- Statements end with semicolons - Don't forget the ;
- Curly braces must match - Every { needs a corresponding }
- Java is case-sensitive - System â system
- Compile with javac -
javac FileName.java - Run with java -
java ClassName(no .class extension) - println() adds newline - print() doesn't
- Use escape sequences for special characters - \n, \t, \", etc.
đĄ Practice Exercise
Task: Write a program named MyInfo.java that displays your
information:
Name: [Your Name]
Age: [Your Age]
Hobby: [Your Hobby]
Learning: Java Programming
Requirements:
- Class name must be
MyInfo - Use multiple
println()statements - File name must be
MyInfo.java - Don't forget semicolons!
đĄ Quick Quiz
Q1: Which command compiles a Java program?
Q2: What is the output of: System.out.print("A"); System.out.print("B");
Q3: What does \n do in a string?