Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Java program structure — package declarations, import statements, class definitions, methods, main method anatomy, and the rules for organizing Java source files.
Every Java program follows a specific structure. Understanding this structure is essential — it's not just syntax rules, it's the foundation of how Java organizes code, manages namespaces, and compiles source files.
The Complete Structure of a Java Source File
A Java source file (.java) can contain the following elements in this exact order:
Example
// 1. Package declaration (optional, but one at most)
package com.company.project;
// 2. Import statements (optional, zero or more)
import java.util.List;
import java.util.ArrayList;
import java.io.*; // wildcard import
// 3. Class/Interface/Enum/Record declarations (one or more)
public class MyProgram {
// 4. Fields (instance and static variables)
private String name;
private static int count = 0;
// 5. Constructors
public MyProgram(String name) {
this.name = name;
count++;
}
// 6. Methods (instance and static)
public void greet() {
System.out.println("Hello, " + name);
}
// 7. Main method (entry point — optional per class)
public static void main(String[] args) {
MyProgram program = new MyProgram("Java");
program.greet();
}
// 8. Inner classes, interfaces, enums (optional)
class InnerHelper {
void help() { System.out.println("Helping..."); }
}
}
Output
Hello, Java
Breaking Down Each Section
1. Package Declaration
The package statement declares which package (namespace/folder) this class belongs to:
java example
// Package declaration — MUST be the first non-comment line
package com.wohotech.javacourse.fundamentals;
// This means:
// - Source file is in: src/com/wohotech/javacourse/fundamentals/
// - Class full name is: com.wohotech.javacourse.fundamentals.ClassNameRules for packages:
- Must be the first statement in the file (only comments can precede it)
- Only one package declaration per file
- Uses lowercase by convention
- Follows reverse domain name convention:
com.company.project.module - Corresponds to the folder structure on disk
java example
// Package hierarchy example:
// com.wohotech.shop.models → src/com/wohotech/shop/models/
// com.wohotech.shop.services → src/com/wohotech/shop/services/
// com.wohotech.shop.utils → src/com/wohotech/shop/utils/
package com.wohotech.shop.models;
public class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public String toString() {
return name + " ($" + price + ")";
}
}2. Import Statements
Imports allow you to use classes from other packages without their full qualified names:
java example
package com.example.demo;
// Single class import (preferred — explicit)
import java.util.ArrayList;
import java.util.HashMap;
import java.time.LocalDate;
// Wildcard import (imports all classes in the package)
import java.util.*; // imports everything from java.util
// Static import (imports static members)
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.System.out; // allows: out.println(...)
public class ImportDemo {
public static void main(String[] args) {
// Without import: java.util.ArrayList<String> list = new java.util.ArrayList<>();
// With import:
ArrayList<String> list = new ArrayList<>();
list.add("Java");
// Using static import
double radius = 5.0;
double area = PI * radius * radius; // No need for Math.PI
double diagonal = sqrt(200); // No need for Math.sqrt()
out.println("Area: " + area); // No need for System.out
out.println("Diagonal: " + diagonal);
}
}Output
Area: 78.53981633974483 Diagonal: 14.142135623730951
Import rules:
java.lang.*is automatically imported (String, System, Math, etc.)- Imports come AFTER the package declaration
- Order doesn't matter (but IDEs organize them alphabetically)
- Wildcard
*imports only classes, not sub-packages
java example
import java.util.*; // imports List, Map, Set, etc.
// Does NOT import java.util.stream.* — sub-packages are separate!
import java.util.stream.*; // need this separately3. Class Declaration
The class is the fundamental building block of Java programs:
java example
// Access modifier + class keyword + class name
public class Student {
// Class body goes here
}Class declaration rules:
java example
// A source file can have MULTIPLE classes...
// File: MyFile.java
public class MyFile { // public class MUST match filename
// Main class
}
class Helper { // non-public class — OK in same file
// Helper class
}
class AnotherHelper { // another non-public class — OK
// Another helper
}
// RULE: Only ONE public class per file, and its name MUST match the filename
// RULE: The file MUST be named after the public class: MyFile.java4. Fields (Variables)
Fields define the state of the class:
Example
public class Employee {
// Instance fields — each object gets its own copy
private String name;
private int age;
private double salary;
// Static fields — shared across ALL objects of this class
private static int totalEmployees = 0;
private static final String COMPANY = "WohoTech"; // constant
// Field initialization block (runs before constructor)
{
System.out.println("Instance initializer block executed");
}
// Static initialization block (runs once when class is loaded)
static {
System.out.println("Static initializer block executed");
// Used for complex static field initialization
}
public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
totalEmployees++;
}
public static void main(String[] args) {
System.out.println("Creating employees...");
Employee e1 = new Employee("Alice", 30, 75000);
Employee e2 = new Employee("Bob", 25, 65000);
System.out.println("Total employees: " + totalEmployees);
}
}
Output
Static initializer block executed Creating employees... Instance initializer block executed Instance initializer block executed Total employees: 2
5. Constructors
Constructors initialize objects when created with new:
java example
public class Rectangle {
private double width;
private double height;
// Default constructor (no arguments)
public Rectangle() {
this.width = 1.0;
this.height = 1.0;
}
// Parameterized constructor
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
// Constructor chaining with this()
public Rectangle(double side) {
this(side, side); // calls the two-parameter constructor
}
public double area() {
return width * height;
}
public static void main(String[] args) {
Rectangle r1 = new Rectangle(); // uses default
Rectangle r2 = new Rectangle(5, 3); // uses parameterized
Rectangle r3 = new Rectangle(4); // uses single-param (square)
System.out.println("r1 area: " + r1.area()); // 1.0
System.out.println("r2 area: " + r2.area()); // 15.0
System.out.println("r3 area: " + r3.area()); // 16.0
}
}Output
r1 area: 1.0 r2 area: 15.0 r3 area: 16.0
6. Methods
Methods define the behavior of the class:
java example
public class Calculator {
// Instance method
public int add(int a, int b) {
return a + b;
}
// Static method (belongs to class, not object)
public static int multiply(int a, int b) {
return a * b;
}
// Method with variable arguments (varargs)
public int sum(int... numbers) {
int total = 0;
for (int n : numbers) {
total += n;
}
return total;
}
// Method overloading (same name, different parameters)
public double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
Calculator calc = new Calculator();
System.out.println("add(3, 4) = " + calc.add(3, 4));
System.out.println("add(3.5, 4.2) = " + calc.add(3.5, 4.2));
System.out.println("multiply(5, 6) = " + Calculator.multiply(5, 6));
System.out.println("sum(1,2,3,4,5) = " + calc.sum(1, 2, 3, 4, 5));
}
}Output
add(3, 4) = 7 add(3.5, 4.2) = 7.7 multiply(5, 6) = 30 sum(1,2,3,4,5) = 15
7. The Main Method — Entry Point
The main method is where Java starts executing your program:
Example
public class MainMethodAnatomy {
// Let's break down each keyword:
public // accessible from anywhere (JVM needs to call it)
static // belongs to class, not an instance (no object needed to call it)
void // returns nothing
main // method name (JVM looks for exactly this name)
(String[] args) // command-line arguments as string array
{
// Program execution starts here
System.out.println("Arguments received: " + args.length);
for (int i = 0; i < args.length; i++) {
System.out.println(" args[" + i + "] = " + args[i]);
}
}
}
Output
// Run with: java MainMethodAnatomy Hello World 123 Arguments received: 3 args[0] = Hello args[1] = World args[2] = 123
Valid main method signatures:
java example
// All of these are valid main methods:
public static void main(String[] args) { } // standard
public static void main(String args[]) { } // C-style array
public static void main(String... args) { } // varargs (Java 5+)
// These are NOT valid main methods (JVM won't find them):
// static void main(String[] args) { } // not public
// public void main(String[] args) { } // not static
// public static int main(String[] args) { } // not void
// public static void main() { } // no String[] parameterComplete Program Example
Here's a realistic, well-structured Java program:
Example
package com.wohotech.student;
import java.util.ArrayList;
import java.util.List;
/**
* Student management program demonstrating proper Java structure.
*
* @author WohoTech
* @version 1.0
*/
public class StudentManager {
// Constants
private static final int MAX_STUDENTS = 100;
// Static field
private static int studentCount = 0;
// Instance fields
private List<Student> students;
private String departmentName;
// Constructor
public StudentManager(String departmentName) {
this.departmentName = departmentName;
this.students = new ArrayList<>();
}
// Methods
public boolean addStudent(String name, int age, double gpa) {
if (studentCount >= MAX_STUDENTS) {
System.out.println("Maximum capacity reached!");
return false;
}
students.add(new Student(name, age, gpa));
studentCount++;
return true;
}
public void displayAll() {
System.out.println("\n=== " + departmentName + " Department ===");
System.out.println("Total students: " + students.size());
System.out.println("-".repeat(40));
for (Student s : students) {
System.out.printf(" %-15s Age:%-3d GPA:%.2f%n",
s.name, s.age, s.gpa);
}
}
public double getAverageGPA() {
if (students.isEmpty()) return 0.0;
double sum = 0;
for (Student s : students) {
sum += s.gpa;
}
return sum / students.size();
}
// Entry point
public static void main(String[] args) {
StudentManager cs = new StudentManager("Computer Science");
cs.addStudent("Alice Johnson", 20, 3.8);
cs.addStudent("Bob Smith", 21, 3.5);
cs.addStudent("Charlie Brown", 19, 3.9);
cs.addStudent("Diana Prince", 22, 3.7);
cs.displayAll();
System.out.printf("\nAverage GPA: %.2f%n", cs.getAverageGPA());
}
// Inner class
private static class Student {
String name;
int age;
double gpa;
Student(String name, int age, double gpa) {
this.name = name;
this.age = age;
this.gpa = gpa;
}
}
}
Output
=== Computer Science Department === Total students: 4 ---------------------------------------- Alice Johnson Age:20 GPA:3.80 Bob Smith Age:21 GPA:3.50 Charlie Brown Age:19 GPA:3.90 Diana Prince Age:22 GPA:3.70 Average GPA: 3.73
Source File Rules Summary
| Rule | Description |
|---|---|
| File name | Must match the public class name + .java |
| Public classes | Only ONE public class per file |
| Package | At most one, must be first statement |
| Imports | After package, before class declarations |
| Default package | If no package is declared (not recommended) |
| Case sensitivity | Java is case-sensitive: Student.java ≠ student.java |
Compilation and File Organization
java example
// File: src/com/example/app/App.java
package com.example.app;
public class App {
public static void main(String[] args) {
System.out.println("Structured Java program!");
}
}
// Compile: javac -d out src/com/example/app/App.java
// This creates: out/com/example/app/App.class
// Run: java -cp out com.example.app.AppOutput
Structured Java program!
Standard Project Layout
my-project/
├── src/ # Source files
│ └── com/
│ └── wohotech/
│ └── app/
│ ├── Main.java
│ ├── models/
│ │ ├── User.java
│ │ └── Product.java
│ ├── services/
│ │ └── UserService.java
│ └── utils/
│ └── StringUtils.java
├── test/ # Test files
│ └── com/
│ └── wohotech/
│ └── app/
│ └── models/
│ └── UserTest.java
├── lib/ # External libraries (JARs)
├── out/ # Compiled .class files
└── README.md
Common Mistakes
- Filename doesn't match public class name —
MyClass.javamust containpublic class MyClass. This is enforced by the compiler. - Multiple public classes in one file — only one public class is allowed per
.javafile. - Package doesn't match folder structure — if you declare
package com.example;, the file must be incom/example/directory. - Forgetting that main must be
public static void— all three modifiers are required for the JVM to find the entry point. - Putting statements before the package declaration — only comments can appear before
package. - Using default package in real projects — while valid, the default (unnamed) package can't be imported by other packages. Always use named packages.
- Confusing
String[] argswithString args[]— both are valid butString[] argsis preferred Java style.
Best Practices
- One class per file — even though multiple non-public classes are allowed, one class per file is cleaner
- Match package names to folder structure — IDE does this automatically
- Use meaningful package names —
com.company.project.module - Keep main method short — delegate to other methods
- Order members consistently — fields → constructors → methods (or follow your team's convention)
- Use access modifiers intentionally — default to
private, expose only what's needed
Interview Questions
Q1: What is the structure of a Java source file?
Answer: A Java source file contains (in order): (1) Package declaration (optional, at most one), (2) Import statements (optional, zero or more), (3) Class/Interface/Enum declarations (one or more, only one can be public). The public class name must match the filename.
Q2: Why must the filename match the public class name?
Answer: This is a design choice for the compiler and JVM to easily locate class files. When you reference com.example.MyClass, the JVM knows to look for com/example/MyClass.class. This one-to-one mapping between public class names and filenames makes the class-loading mechanism straightforward.
Q3: Can you have a Java file without any public class?
Answer: Yes. A file can contain only package-private (default access) classes. In that case, the file can have any name. However, this is uncommon and not recommended — it makes code harder to navigate.
Q4: Explain each keyword in public static void main(String[] args).
Answer: public — accessible by the JVM from outside the class. static — can be called without creating an object (JVM doesn't instantiate your class). void — returns nothing to the caller (JVM doesn't expect a return value). main — the specific method name the JVM looks for. String[] args — command-line arguments passed when running the program.
Q5: What happens if you write two public classes in one file?
Answer: The compiler throws an error. Java enforces a rule: each source file can have at most one public top-level class, and the file must be named after that class. This ensures a predictable mapping between class names and file locations for the ClassLoader.
Summary
Java program structure is precise and intentional: packages organize classes into namespaces, imports provide shortcuts to other packages, and the class body contains fields, constructors, and methods. The main method serves as the entry point, and strict file-naming rules ensure the JVM can always locate your code. Mastering this structure gives you the foundation for writing clean, organized Java applications.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Java Program Structure.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, fundamentals, introduction, program
Related Java Master Course Topics
Continue learning this concept
FundamentalsYour First Java ProgramWrite, compile, and run your first Java program — a detailed walkthrough of Hello World, explaining every line, common errors beginners face, and how to progress beyond the basics.FundamentalsArray IntroductionComplete introduction to arrays in Java covering definition, memory layout, types of arrays, declaration, initialization, accessing elements, and real-world use cases with detailed examples.FundamentalsJava Compilation ProcessStep-by-step explanation of how Java source code becomes executable — from writing .java files through javac compilation, bytecode generation, class loading, verification, and JVM execution.FundamentalsFeatures of JavaA deep dive into all key features of Java programming language — platform independence, object-oriented nature, robustness, security, multithreading, and more with practical examples.FundamentalsHistory of JavaThe complete history of Java programming language — from the Green Project at Sun Microsystems in 1991 to modern Java 21+ LTS releases, covering every major version and milestone.FundamentalsJava EditionsComplete guide to Java editions — Java SE, Java EE (Jakarta EE), Java ME, and JavaFX. Understand which edition to use for desktop, web, enterprise, mobile, and embedded development.