A simple Class 9 friendly lesson. First see the list, then read the theory and two short examples for every keyword.
Advertisement
Do not try to memorize everything in one day. First learn the common keywords: class,
public, static, void, main, if,
else, for, while, new, return,
this, and extends.
Some keywords are advanced. They are still listed because this is a complete keyword lesson.
Contextual keywords act like keywords only in special places. In other places, they may behave like normal names.
abstract reservedTheory: Used when a class or method is incomplete. An abstract class cannot be directly converted into an object; a child class completes it.
abstract class FeeRule {
abstract int lateFine(int days);
}abstract class ReportPrinter {
abstract void printReport();
}assert reservedTheory: Used for checking something during testing. If the condition is false, Java can stop the program with an error.
int marks = 85;
assert marks >= 0 : "Marks cannot be negative";int attendance = 92;
assert attendance <= 100 : "Attendance cannot exceed 100";boolean reservedTheory: Stores only two values: true or false. Useful for yes/no situations.
boolean feesPaid = true;
System.out.println(feesPaid);boolean hasLibraryCard = false;
System.out.println(hasLibraryCard);break reservedTheory: Stops a loop or exits from a switch case.
for (int roll = 1; roll <= 50; roll++) {
if (roll == 23) break;
}switch (grade) {
case 'A': System.out.println("Excellent"); break;
}byte reservedTheory: Stores a small whole number from -128 to 127. It saves memory in large data collections.
byte classNumber = 9;
System.out.println(classNumber);byte sectionCount = 4;
System.out.println(sectionCount);case reservedTheory: Used inside switch to match one possible value.
switch (day) {
case 1: System.out.println("Monday");
}switch (section) {
case 'A': System.out.println("Room 101");
}catch reservedTheory: Handles an error after try. It prevents the program from crashing suddenly.
try {
int avg = total / students;
} catch (ArithmeticException e) {
System.out.println("No students found");
}try {
int n = Integer.parseInt("90");
} catch (NumberFormatException e) {
System.out.println("Invalid number");
}char reservedTheory: Stores one character. Use single quotes.
char grade = 'A';
System.out.println(grade);char section = 'B';
System.out.println(section);class reservedTheory: Creates a blueprint for objects.
class Student {
String name;
}class LibraryBook {
String title;
}const reserved but not usedTheory: Reserved by Java, but not used in normal Java programs. Use final instead.
// Wrong in Java:
// const int MAX_MARKS = 100;// Correct Java:
final int MAX_MARKS = 100;continue reservedTheory: Skips the current round of a loop and moves to the next round.
for (int roll = 1; roll <= 5; roll++) {
if (roll == 3) continue;
System.out.println(roll);
}for (int mark : marks) {
if (mark < 0) continue;
System.out.println(mark);
}default reservedTheory: Used in switch when no case matches. It is also used in interfaces for methods with a body.
switch (choice) {
default: System.out.println("Invalid choice");
}interface Printable {
default void print() { System.out.println("Printing"); }
}do reservedTheory: Starts a do-while loop. The loop runs at least once.
int attempt = 1;
do {
System.out.println("Try " + attempt);
attempt++;
} while (attempt <= 3);int page = 1;
do {
System.out.println("Read page " + page);
page++;
} while (page <= 5);double reservedTheory: Stores decimal numbers with good precision.
double percentage = 87.5;
System.out.println(percentage);double fee = 1250.75;
System.out.println(fee);else reservedTheory: Runs when the if condition is false.
if (marks >= 33) System.out.println("Pass");
else System.out.println("Fail");if (feesPaid) System.out.println("Admit card allowed");
else System.out.println("Pay fees first");enum reservedTheory: Creates a fixed set of named values.
enum Grade { A, B, C, D }
Grade g = Grade.A;enum BusRoute { ROUTE_1, ROUTE_2 }
BusRoute r = BusRoute.ROUTE_1;extends reservedTheory: Used when one class inherits from another class.
class OnlineStudent extends Student {
String loginId;
}class ReferenceBook extends LibraryBook {
String subject;
}final reservedTheory: Makes a value, method, or class unchangeable in a certain way.
final int MAX_MARKS = 100;final class SchoolIdCard {
int id;
}finally reservedTheory: Runs after try-catch, usually for cleanup work.
try {
System.out.println("Read marks");
} finally {
System.out.println("Close file");
}try {
int x = 10 / 2;
} catch (Exception e) {
System.out.println("Error");
} finally {
System.out.println("Done");
}float reservedTheory: Stores decimal numbers. Add f at the end.
float height = 5.8f;
System.out.println(height);float temperature = 36.5f;
System.out.println(temperature);for reservedTheory: Repeats code a fixed number of times.
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}for (int mark : marks) {
System.out.println(mark);
}goto reserved but not usedTheory: Reserved by Java, but not used. Java avoids goto because it can make programs confusing.
// Wrong in Java:
// goto start;// Use loop instead:
for (int i = 1; i <= 3; i++) {
System.out.println(i);
}if reservedTheory: Makes a decision when a condition is true.
if (marks >= 33) {
System.out.println("Pass");
}if (attendance >= 75) {
System.out.println("Allowed for exam");
}implements reservedTheory: Used when a class promises to follow an interface.
interface Printable { void print(); }
class ReportCard implements Printable {
public void print() { System.out.println("Report"); }
}interface Payable { void pay(); }
class FeeAccount implements Payable {
public void pay() { System.out.println("Fee paid"); }
}import reservedTheory: Brings a class from a package into your program.
import java.util.Scanner;import java.time.LocalDate;instanceof reservedTheory: Checks whether an object belongs to a class or type.
Object obj = "Riya";
System.out.println(obj instanceof String);Student s = new Student();
System.out.println(s instanceof Student);int reservedTheory: Stores whole numbers.
int marks = 95;
System.out.println(marks);int rollNumber = 27;
System.out.println(rollNumber);interface reservedTheory: Creates a set of methods that classes can implement.
interface Printable {
void print();
}interface LoginAllowed {
boolean canLogin();
}long reservedTheory: Stores very large whole numbers. Add L at the end if needed.
long schoolPhone = 919335874326L;long population = 1400000000L;native reservedTheory: Used for methods written outside Java, usually in C or C++. Class 9 students only need to recognize it.
native void scanFingerprint();native int systemBatteryLevel();new reservedTheory: Creates a new object.
Student s1 = new Student();LibraryBook book = new LibraryBook();package reservedTheory: Places a class inside a named group or folder.
package school.records;
class Student { }package school.library;
class Book { }private reservedTheory: Allows access only inside the same class.
class Student {
private int marks;
}class FeeAccount {
private double balance;
}protected reservedTheory: Allows access in the same package and child classes.
class Person {
protected String name;
}class Account {
protected int accountNumber;
}public reservedTheory: Allows access from outside also.
public class Main { }public void display() {
System.out.println("Hello");
}return reservedTheory: Sends a value back from a method or stops a method.
int total(int a, int b) {
return a + b;
}void check(int marks) {
if (marks < 0) return;
System.out.println(marks);
}short reservedTheory: Stores a small whole number, larger than byte but smaller than int.
short totalStudents = 1200;short libraryBooks = 3200;static reservedTheory: Belongs to the class rather than one object.
static String schoolName = "Sunrise School";static void showSchool() {
System.out.println("Sunrise School");
}strictfp reservedTheory: Makes floating-point calculations follow strict rules. It is rarely needed now.
strictfp class Calculator {
double area(double r) { return 3.14 * r * r; }
}strictfp double average(double a, double b) {
return (a + b) / 2;
}super reservedTheory: Refers to the parent class.
class OnlineStudent extends Student {
OnlineStudent() { super(); }
}class ChildReport extends Report {
void show() { super.show(); }
}switch reservedTheory: Selects one block from many choices.
switch (month) {
case 1: System.out.println("January"); break;
}switch (grade) {
case 'A': System.out.println("Excellent"); break;
}synchronized reservedTheory: Controls access when many threads use the same method or data.
synchronized void updateFee() {
balance = balance - 500;
}synchronized void issueBook() {
issuedBooks++;
}this reservedTheory: Refers to the current object.
class Student {
String name;
Student(String name) { this.name = name; }
}class Book {
int price;
void setPrice(int price) { this.price = price; }
}throw reservedTheory: Manually creates an error.
if (marks < 0) {
throw new IllegalArgumentException("Marks cannot be negative");
}if (age < 5) {
throw new IllegalArgumentException("Too young for Class 9");
}throws reservedTheory: Tells that a method may produce an error.
void readMarks() throws Exception {
System.out.println("Reading marks");
}void openFile() throws java.io.IOException {
System.out.println("Open file");
}transient reservedTheory: Prevents a field from being saved during serialization.
class Login {
transient String password;
}class StudentSession {
transient int otp;
}try reservedTheory: Starts a block where an error might happen.
try {
int avg = total / count;
} catch (Exception e) {
System.out.println("Error");
}try {
int n = Integer.parseInt("85");
} catch (Exception e) {
System.out.println("Invalid");
}void reservedTheory: Means a method returns no value.
void display() {
System.out.println("Report card");
}public static void main(String[] args) {
System.out.println("Start");
}volatile reservedTheory: Used with threads so that changes to a variable are visible quickly to all threads.
volatile boolean classStarted = false;volatile int liveViewerCount = 0;while reservedTheory: Repeats code while a condition is true.
int page = 1;
while (page <= 5) {
System.out.println(page);
page++;
}int balance = 1000;
while (balance > 0) {
balance -= 100;
}_ reserved identifierTheory: The single underscore is reserved in modern Java and cannot be used as a variable name.
// Wrong in modern Java:
// int _ = 10;// Correct:
int unusedMarks = 10;exports contextualTheory: Used in module-info.java to allow another module to use a package.
module school.app {
exports school.records;
}module library.app {
exports library.books;
}module contextualTheory: Defines a Java module. This is advanced and usually not needed in Class 9.
module school.app {
requires java.base;
}module library.app {
exports library.books;
}non-sealed contextualTheory: Used with sealed classes. It says a child class is open for further inheritance.
non-sealed class OnlineExam extends Exam { }non-sealed class DigitalBook extends Book { }open contextualTheory: Used with modules to allow deep reflection for all packages.
open module school.app {
requires java.base;
}open module report.app {
requires java.sql;
}opens contextualTheory: Used in module-info.java to open a package for reflection.
module school.app {
opens school.records;
}module library.app {
opens library.data to report.app;
}permits contextualTheory: Used with sealed classes to list allowed child classes.
sealed class Exam permits OnlineExam, OfflineExam { }sealed class Payment permits CashPayment, UpiPayment { }provides contextualTheory: Used in modules to provide a service implementation.
module school.app {
provides ReportService with PdfReportService;
}module library.app {
provides SearchService with BookSearchService;
}record contextualTheory: Creates a simple data class with less code.
record Student(String name, int marks) { }record Book(String title, int price) { }requires contextualTheory: Used in modules to say one module needs another module.
module school.app {
requires java.sql;
}module report.app {
requires school.app;
}sealed contextualTheory: Restricts which classes can extend a class.
sealed class Exam permits OnlineExam, OfflineExam { }sealed class FeePayment permits CashPayment, UpiPayment { }to contextualTheory: Used in module-info.java with exports or opens to target a specific module.
module school.app {
exports school.records to report.app;
}module library.app {
opens library.data to admin.app;
}transitive contextualTheory: Used with requires. If A requires transitive B, users of A also read B.
module school.app {
requires transitive java.sql;
}module report.app {
requires transitive school.app;
}uses contextualTheory: Used in modules to say that a module uses a service.
module school.app {
uses ReportService;
}module library.app {
uses SearchService;
}var contextualTheory: Lets Java guess the local variable type from the value.
var marks = 95;
System.out.println(marks);var name = "Riya";
System.out.println(name);when contextualTheory: Used in modern switch pattern matching as a condition guard. This is advanced.
// Advanced example:
case Integer n when n >= 90 -> "Excellent";// Advanced example:
case String s when s.length() > 10 -> "Long name";with contextualTheory: Used in advanced module/service contexts and newer Java features. Beginners only need to recognize it.
module school.app {
provides ReportService with PdfReportService;
}module library.app {
provides SearchService with BookSearchService;
}yield contextualTheory: Returns a value from a switch expression block.
String result = switch (marks / 10) {
case 10, 9 -> "A";
default -> "Needs practice";
};String feeStatus = switch (paid) {
case true -> "Paid";
case false -> { yield "Pending"; }
};true, false, and nullThese are not counted as Java keywords. They are special literal values.
boolean present = true;
boolean absent = false;String middleName = null;
System.out.println(middleName);