Review and Revision of Object Oriented Programming Fundamentals

This lecture consolidates two hours of review covering Java execution foundations, class and object design, construction and initialization, variable kinds, static members, the this and final keywords, arrays, strings, and file streams, preparing essential concepts for examination.

25.1 Bytecode — The Foundation and Magic of Java

25.1.1 Definition and Nature of Bytecode

A bytecode — the highly optimized set of instructions that the Java runtime system executes — is the direct output of the Java compiler. It is not an executable file in the ordinary sense. When a program is written in a typical language, the source is compiled straight to a native executable tied to one machine. In Java the path is split into two stages. The source file, saved with a .java extension, is compiled by javac into a .class file. That .class file holds bytecode. Bytecode is then taken up by an interpreter, the Java Virtual Machine or JVM, which turns it into actions the underlying hardware and operating system can carry out.

Real-world: This two-stage design is the reason bytecode is often called Java's magic. It is the foundation that lets Java programs move between platforms without recompilation.

Bytecode is described as a highly optimized set of instructions to be executed by the JVM. The class file — for example First.class produced from First.java — is the physical container for bytecode. The JVM reads that container and performs interpretation. The distinction matters: compilation checks syntax and creates bytecode, interpretation creates the final program outcome.

25.1.2 Compilation to Bytecode and Interpretation by the JVM

The workflow from editing to running has a fixed order that is worth memorizing.

1. Interact with a text editor and write the program.
2. Save the source as a .java file, for example First.java. Saving with the class name is the recommended practice.
3. Compile with the Java compiler: javac First.java. During compilation the compiler checks whether the writing respects the language, checks types, checks syntax and checks for typos.
4. If no error is found, compilation succeeds and creates First.class. That file is bytecode.
5. Interpret the bytecode with java First. Note that the interpreter is invoked with the class name only, without an extension. The interpreter converts bytecode to hardware and operating system compatibility and the program prints its result, for example hello world.

Exam note: The two files created — .java as source and .class as bytecode — appear in checks of how a Java program is written, compiled, and interpreted. The names javac for the compiler and java for the interpreter are the expected answers.

Think of bytecode as a compact, portable intermediate language. It is not tied to Windows, Linux, or Mac. It is tied only to the JVM specification.

25.1.3 Why Bytecode Matters — Key Intuition

A helpful way to picture bytecode is as a parcel that any post office can deliver as long as the local branch knows the parcel format. Here the parcel is the .class file, and the local branch is the JVM installed on the target machine. Only the JVM needs to be implemented for each platform. Once that is in place, the same bytecode runs everywhere.

Real-world: Portability is the direct payoff. A program created on one machine can be taken as bytecode and executed on another machine with a different operating system, provided a JVM is present on the second machine.

A common way to restate the idea is: translating a Java program into bytecode makes it much easier to run on any platform because only the JVM needs a platform-specific implementation, not every application.

Bytecode sits between source and native code. Visualize a flow diagram: left box is First.java on your editor, arrow labeled javac points to middle box First.class (bytecode) with a small badge portable, then fan-out arrows from that middle box to three right boxes labeled Windows JVM, Linux JVM, macOS JVM, each arrow labeled java. The takeaway from the picture is one compile, many runs, with only the right-hand JVMs being platform specific.

Excellent portability is why bytecode is often called Java's magic: it decouples what you ship from where it runs, at the cost of requiring a JVM on every target.

25.2 Portability and Platform Independence

25.2.1 Source to Bytecode to Execution

Portability — the ability to carry a program from one system to another without change — follows directly from the bytecode design. The sequence is:

• Write Java code and keep it as a source file, for example Program.java.
• Compile with javac to generate bytecode as a .class file.
• Carry the .class file to any platform.
• Execute on Windows, Linux, Mac, or any other platform that hosts a JVM.

That ability to generate code on one machine and execute it on another machine is what makes a Java program portable. The figure used to illustrate this shows a single source branching after compilation into one .class artifact that fans out to multiple operating system targets.

Exam note: Questions about portability often ask what is required to run bytecode on a new platform. The answer is a correctly installed JVM for that platform.

25.2.2 Role of the Java Virtual Machine

The Java Virtual Machine is the interpreter and runtime system that bridges bytecode and the real machine. Whatever platform is involved — Windows, Mac, or Linux — the JVM must be installed there. Once installed, any .class file, which is bytecode, executes successfully because the JVM handles the conversion to hardware-specific instructions and operating system calls.

Real-world: This is why Java is called a platform-independent language. The independence does not mean bytecode runs without help; it means the help is standardized as the JVM, not as a recompilation of the application for each operating system.

A useful mental check is: bytecode itself is platform independent, the JVM is platform dependent, and the combination gives platform independent execution for the application.

Imagine a diagram: one source box at the top, one Program.class box in the middle, then three parallel host icons below (Windows, Linux, Mac) each containing a small JVM layer on top of Hardware + OS. Arrows from Program.class point straight down into each JVM. The shape says one artifact fans out to many hosts, and the only per-host work is installing the JVM once.

Cross-check: generate Program.java on machine A and run it on machine B with no javac on B — only java — and hello world still prints if the JVM is present.

25.3 Core Features of Object Oriented Programming

Four features form the core of object oriented programming. They appear together whenever organizing programs around classes.

25.3.1 Classes and Encapsulation

A class — a collection of member data and member functions grouped into a single unit — expresses the idea of encapsulation. Encapsulation groups the data members and the functions that operate on that data into one unit. That unit is the class. Operations defined in the class work over the data members of that class.

A class is described as a set of attributes and the operations performed on those attributes. Data members represent attributes; functions represent operations. Grouping them together is the single-unit idea.

Real-world: In Java a program cannot be written without creating a class. The class is the base for carrying out computation and for organizing code.

25.3.2 Objects as Instances

An object — an instance of a class — is a concrete realization of the blueprint. A class named Student may define attributes such as identifier, name, stream, and marks. A specific student such as Mike or George is an object of that class. Both Mike and George have their own identifier, their own name, their own stream, and their own marks. The set of attributes is shared in definition; the values are local to each object.

The same pattern holds for other domains. An Account class or a Circle class can have many objects. Each object carries its own state while sharing the operations defined by the class.

25.3.3 Polymorphism — One Name, Many Forms

Polymorphism translates to one name and many forms. The typical realization is overloading. Overloading keeps the function name the same while changing the argument list.

For example, a function named getData may appear in a parent class. A second definition with the same name getData is added in the same class but with a different set of arguments — two arguments, then three arguments, and so on. The name remains getData. Which definition is followed depends on the number of arguments provided at the call site. One name therefore supports multiple forms, and that is polymorphism under the overloading category.

25.3.4 Inheritance with Extends

Inheritance is about accessing the properties of one class in another. One class is the parent class, another is the child class. The child extends the parent and gains access to data members and functions of the parent that are declared public or protected. Private data members and private functions are not accessible through inheritance.

In Java the keyword is extends. A sketch of the form is:

class ABC {
    // body of parent class
}
class XYZ extends ABC {
    // can access public and protected members of ABC
}

This is the fourth main feature. It lets a child reuse and extend behavior without rewriting the parent.

Picture a Venn-style stack: bottom layer is class as the unit of grouping, next layer adds objects as live copies, third layer adds polymorphism as multiple interfaces on the same name, top layer adds inheritance as vertical reuse. The takeaway is that the first two build state and behavior, the last two add flexibility and reuse without rewriting.

25.4 Classes as Blueprints — Structure and Examples

25.4.1 Attributes and Operations Together

A class is a blueprint from which individual objects can be created. It holds a set of attributes and a set of operations that work on those attributes. Multiple objects of a single class can be created, each with its own local values for the attributes but using the same operations. Saying a class is a blueprint captures three ideas: it defines what data exists, it defines what can be done with that data, and it allows many distinct instances that conform to that definition.

In programming methodology terms, data members are the attributes and functions or methods are the operations. A class bundles them so that any object of the class has the same shape of state and the same set of behaviors, differing only in the concrete values stored.

25.4.2 Illustrative Classes — Account, Student, Circle

Three concrete blueprints illustrate the idea.

Account class. Data members are account name and account balance. Functions are withdraw, deposit, and determineBalance. Each of those functions can access the two data members. Any number of objects can be created — for example two or three accounts — each with its own name and balance.

Student class. The concept has been introduced with attributes identifier, name, stream, and marks. The same shape applies here.

Circle class. Attributes are center and radius. Operations are area and circumference. The geometry depends on those attributes.

These examples show the same pattern across domains: name the class, list its data members, list its operations. That triple is the class definition.

25.4.3 Instance Creation and Property Access

Consider two classes side by side.

The first class is named Student with attributes name, identifier, stream, and marks. Objects John and Jill are instances of Student. Each has its own identifier, name, stream, and marks.

The second class is named Circle with attributes center and radius and operations area and circumference. Objects Circle A and Circle B are instances of Circle. Each has its own center and radius and can access area and circumference as defined in the class.

Stated directly: objects are created from a class and then use the properties of that class. Property here means both data members and the ability to invoke operations. This is the instance relationship that underlies every object oriented program.

Picture two Student cards side by side labeled John and Jill. Both cards have four printed lines name, identifier, stream, marks — same shape. Handwritten values differ. Below them two Circle discs labeled Circle A and Circle B with different radii and the same two buttons area, circumference. The takeaway is one blueprint, many distinct instances.

25.5 Writing, Saving, Compiling and Running a Simple Program

25.5.1 Required Structure — Class and Main Method

A Java program always starts with a class. Provide the name of the class, for example First, preceded by the keyword class. The class body is enclosed in braces. Inside the class, include the main method. The signature is:

public static void main(String args[])

where args is a string array used for receiving command line arguments during interpretation.

A key rule is: whether there is a single class or a multi-class scenario where classes are connected through objects, at least one main method must exist in at least one of the classes. For a single-class program, main must be present in that class. Execution starts from main. Printing a simple string uses System.out.println("hello world").

Exam note: Expect to write the exact main signature and to explain that execution begins at main. Missing String args[] or writing white instead of void will not compile.

25.5.2 Saving, Compiling with javac and Interpreting with java

Saving, compiling, and interpreting are three distinct steps that are easy to confuse.

• Save the source with the class name: First.java. The .java extension is required.
• Compile: javac First.java. This invokes the Java compiler. It checks language conformance and syntax. On success it creates First.class. That file is bytecode.
• Interpret: java First. This invokes the interpreter on the class name alone. The bytecode is interpreted and the output hello world appears on the screen.

The two-stage outcome — compiler produces .class, interpreter runs the class — is the bytecode workflow in miniature. The process illustrates why saving with the correct class name, using the correct compiler name javac, and using the correct interpreter form java First all matter.

25.5.3 From Class Diagram to Code — Account Example

A common teaching figure shows a class on the left and its code on the right, using the Account class as the subject.

On the left, the name of the class is Account. Data members are account number, name, and amount. Functions are insert, withdraw, deposit, checkBalance, and display.

On the right, the translation to Java is:

class Account {
    int accountNumber;
    String name;
    float amount;

    void insert(int acc, String n, float amt) {
        accountNumber = acc;
        name = n;
        amount = amt;
    }
    // withdraw, deposit, checkBalance, display defined similarly
}

Only one method, insert, is shown fully. It receives three parameters and assigns them inside the class. The same pattern creates the remaining methods.

If this class is not intended to be used from another class through inheritance, the recommended practice is to include public static void main inside this class, create objects of the class there, and call methods one by one — for example calling insert to add an amount, or withdraw and deposit as needed. That keeps creation, initialization, and use in one executable unit.

public static void main(String args[])

class First {
    public static void main(String args[]) {
        System.out.println("hello world");
    }
}

Think of the folder as two layered stacks: top stack is source text First.java, bottom stack is bytecode First.class. An arrow labeled javac points down from top to bottom. A second arrow labeled java First points from the bottom stack to the screen image hello world. Visual landmarks: the source stack is readable text; the bytecode stack is smaller binary text not readable; the screen is the final destination.

Exam note repeated for retention: two files .java and .class, two tools javac and java, one entry point main.

25.6 Constructors — Default and Parameterized

25.6.1 What a Constructor Is and Its Rules

A constructor is a special entity related to methods. It follows two strict rules:

• Its name must be the same as its class name.
• It must have no explicit return type. It is not written with void or any other return type.

For a class named ABC, a constructor is written as public ABC() with no return type marker. That form identifies it as a constructor, not an ordinary method. Its purpose is initialization of objects.

25.6.2 Default Constructor and Automatic Initialization

A default constructor is also called a no-argument constructor. It takes no parameters. For class ABC, it is public ABC() with an empty parameter list.

A default constructor provides default values to objects. In Java, an int is initialized to 0, a String is initialized to null, and a float is initialized to 0.0 when no explicit value is given.

A minimal illustration uses a class named Account with data members account number of type int, name of type String, and amount of type float, and a method display that prints those three values. No initialization is performed in the class and no values are passed in main. The program creates an object:

Account even = new Account();
even.display();

The call new Account() uses the default constructor. Even though no constructor was explicitly written in the source as public Account(), the program executes successfully. The reason is that a default constructor is provided automatically if none is written. The display prints the defaults:

0   null   0.0

where 0 corresponds to int, null to String, and 0.0 to float. The important takeaway is that failing to write a default constructor explicitly is not an error when no other constructor exists; the language supplies one.

25.6.3 Parameterized Constructor and the No-Auto-Creation Rule

A parameterized constructor receives values and uses them to initialize the data members of the class. In the same Account class, a parameterized constructor is:

Account(int acc, String n, float amt) {
    accountNumber = acc;
    name = n;
    amount = amt;
}

In main, creation supplies concrete values:

Account even = new Account(101, "Amit", 5000.0f);
even.display();

The call passes three values. Inside the constructor those values initialize the data members. The subsequent display prints the supplied values rather than the defaults.

A sharp edge case needs attention. Consider adding a commented line after the successful creation:

// Account a1 = new Account();

If the class contains only the parameterized constructor shown above and no explicit no-argument constructor, then new Account() with no arguments will not compile. When a parameterized constructor is implemented, a copy of the default constructor is not created automatically. In the earlier example with no constructor at all, the automatic default existed. Once a parameterized constructor is present, that automatic creation stops. To allow both forms, an explicit no-argument constructor must be added:

Account() { }

Only then can Account a1 = new Account(); coexist with Account even = new Account(101, "Amit", 5000.0f);. This rule — parametric presence suppresses the auto default — is a frequent source of compilation complaints and is worth checking first when a no-argument creation fails after adding a parameterized constructor.

class Account {
    int accountNumber;
    String name;
    float amount;
    void display(){ System.out.println(accountNumber+" "+name+" "+amount); }
}

Account even = new Account();
even.display();

Account(int acc, String n, float amt){
    accountNumber = acc; name = n; amount = amt;
}

Account even = new Account(101, "Amit", 5000.0f);
even.display();

// Account a1 = new Account();

Account(){ }

Visualize a timeline for object creation: left marker new Account(101,"Amit",5000.0f) triggers a box constructor runs with arrows acc->accountNumber, n->name, amt->amount, then a green check object ready and call to display. For default construction the same timeline shows new Account() -> auto constructor -> fields filled with 0, null, 0.0 -> ready.

Parameterized constructor suppresses automatic default constructor — the warning to memorize and the first thing to check when new Account() stops compiling.

25.7 Variables — Instance and Static

25.7.1 What Is a Variable

A variable — a name given to a memory location — is the basic unit of storage in a program. The name refers to a place in memory where a value is held. The value can be varied over time.

For example, int A = 10; means A is a variable holding 10 at the memory address assigned to A, say address 1000. When the program later executes A = 20;, the value at address 1000 is overwritten with 20. Later A = 30; overwrites it again with 30. Only one value is retrievable at a time, and each assignment replaces the previous content. All operations done on the variable affect that memory location. A variable must be declared before it is used.

25.7.2 Instance Variables

An instance variable belongs to an object. Each object gets its own copy. A data member such as int A and int B inside class ABC becomes an instance variable when objects are created.

Create two objects:

ABC a1 = new ABC();
ABC a2 = new ABC();

Then a1.A and a1.B are distinct from a2.A and a2.B. Giving a1.A = 10 and a1.B = 20 while giving a2.A = 30 and a2.B = 40 shows complete independence. Changing the value in one object never affects the other. This per-object copy is the defining property of instance variables.

25.7.3 Static or Class Variables — One Copy Shared

A static variable — also called a class variable — is any field declared with the static modifier. It tells the compiler that exactly one copy of this variable exists regardless of how many times the class has been instantiated. There will be only one copy per class, shared among all instances.

A concrete layout helps. Inside class ABC:

class ABC {
    int a;
    int b;
    static int c;
}

Create two objects as before, a1 and a2. Instance fields behave as in the previous subsection: a1.a may be 10, a1.b may be 20, a2.a may be 30, a2.b may be 40. The static field c is different. Suppose c holds 50. That 50 is the single shared value. Whether accessed conceptually through a1 or a2, the value seen is 50. If at some instant the value is modified to 60, then any later access, even through a1, sees 60. It is shared.

Because only one copy exists, the intended access form uses the class name directly, not an object name:

ABC.c

for class ABC and field c. Using the class name signals that the variable is a class variable, not an instance variable. In an instance, only one copy of a static variable exists regardless of how many objects are created, and that is the essential contrast with instance variables.

An applied example uses a static field of type String:

class ABC {
    static String classware = "Java programming";
}
class XYZ {
    public static void main(String args[]) {
        System.out.println(ABC.classware);
    }
}

The class is ABC, the static variable is classware initialized to the string Java programming. Inside another class XYZ, inside main, the value is accessed as ABC.classware. That prints Java programming on the screen. Accessing through the class name is the correct way to use a class variable, and it emphasizes that the storage belongs to the class as a whole.

Real-world: Shared configuration such as a program title, a default version string, or a counter of how many objects have been created is often kept as a static variable so that all instances see the same value.

Exam note: Questions may ask how many copies of a static variable exist after creating three objects. The answer remains one copy shared by all three.

class ABC {
    int a; int b; static int c;
}

ABC a1 = new ABC(); ABC a2 = new ABC();
a1.a = 10; a1.b = 20; a2.a = 30; a2.b = 40;
ABC.c = 50; // or a1.c = 50 — same single slot

class ABC { static String classware = "Java programming"; }
class XYZ { public static void main(String args[]){ System.out.println(ABC.classware); } }

Imagine two house icons a1 and a2. Inside each house are two labeled drawers a and b with different numbers. Above both houses is a shared whiteboard labeled c with one number 50 visible from either house. Turn the whiteboard to 60 and anyone looking from either house sees 60. The drawers stay independent.

Static variable single shared copy ABC.c versus per-object a b — the intuition to keep when counting copies.

25.8 Static Block for Initializing Static Variables

25.8.1 Syntax and Automatic Execution on Class Loading

A static block is used for initializing static variables. Normal data members can be initialized at declaration or inside a constructor, and their values vary per object. A static variable is a class variable, so its initialization is tied to the class itself, not to any particular object. The static block addresses that need.

The syntax is a block preceded by the keyword static:

class ABC {
    static int I;
    static {
        I = 20;
        System.out.println("inside static block");
    }
}

Whatever is written inside the static block is executed automatically. No explicit call is required. The block executes when the class is loaded into memory. As soon as class ABC is loaded, the block gets its chance to run, and whatever it contains runs before ordinary code that uses the class. In this example the static variable I is initialized to 20 inside the block, and the message inside static block is printed.

Because I is static, its initialized value is accessed through the class name:

System.out.println(ABC.I);

That prints 20. The sequence is: class loads, static block runs, static variables obtain their block-assigned values, and later code can read those values through ClassName.variable. Adding a System.out.println inside the block is a simple way to observe that the block ran at class-load time, not at object-creation time.

A helpful intuition is that the static block is the class-level constructor. Ordinary constructors initialize per-object state; the static block initializes per-class state exactly once.

class ABC {
    static int I;
    static { I = 20; System.out.println("inside static block"); }
}

Visualize time on a horizontal axis: mark class load with a tall bar labeled static { I=20 }, then marks new a1, new a2, and reads ABC.I as small ticks after. The block's bar occurs once at the very left; object creations sit to its right. Takeaway: class-level constructor versus object-level constructor.

25.9 The this Keyword — Reference to the Current Object

25.9.1 Core Idea and Six Distinct Usages

The keyword this is a reference variable that refers to the current object. Current object means the object that is presently executing a method or whose context is active. When a method is called through a particular object, this inside that method denotes that calling object.

Six different usages have been discussed:

1. To refer to the current class instance variable.
2. To invoke the current class method.
3. To invoke the current class constructor.
4. To be passed as an argument in a method call.
5. To be passed as an argument in a constructor call.
6. To return the current class instance from a method.

Whenever the need is to deal with the current object — whether a field, a method, or a constructor — this is the handle for the calling object or the object associated with the current execution of the class.

A tiny illustration of why it matters starts with a class ABC that has a field int x = 10; and a method showData that prints x. In main, objects are created:

ABC a1 = new ABC();
ABC a2 = new ABC();
ABC a3 = new ABC();

Each has its own x, potentially initialized differently through a parameterized constructor. Calling a1.showData(), a2.showData(), or a3.showData() reaches the same method body, but this inside the body can identify which of a1, a2, or a3 made the call. That identification is the first usage and the root of the other five.

25.9.2 Usage 1 — Disambiguating Instance Variables

The most frequent use is to resolve name collision between a parameter and a field.

Consider a class Account with data members:

int accountNumber;
String name;
float amount;

It has a parameterized constructor that receives three values and a display method that prints them. Suppose the constructor is written as:

Account(int acc, String n, float amt) {
    accountNumber = acc;
    name = n;
    amount = amt;
}

That works when parameter names differ from field names. If the names are kept the same for clarity, for example the first parameter is also called accountNumber, a direct assignment accountNumber = accountNumber; does not achieve the intended initialization. The right-hand name is taken as the field itself, not the parameter, so the assignment has no effect.

The fix uses this:

Account(int accountNumber, String name, float amount) {
    this.accountNumber = accountNumber;
    this.name = name;
    this.amount = amount;
}

Here the left side this.accountNumber is explicitly the field of the calling object, while the right side accountNumber is the parameter received by the constructor. The keyword connects the left side to the calling object — the object created with Account even = new Account(101, "Amit", 5000.0f); where those values were supplied. The association this.accountNumber with the field and accountNumber with the parameter avoids confusion and guarantees that the field gets the parameter value. Passing values during creation and then calling even.display() prints the supplied numbers.

25.9.3 Usage 2 — Invoking Current Class Method

this can also be used to invoke the current class method without qualifying with an object name.

Take the same Account class, but instead of a constructor, provide an insert method that receives values and initializes fields, and a display method that prints them.

class Account {
    int accountNumber;
    String name;
    float amount;
    void insert(int acc, String n, float amt) {
        this.accountNumber = acc;
        this.name = n;
        this.amount = amt;
        this.display();
    }
    void display() {
        System.out.println(accountNumber + " " + name + " " + amount);
    }
}

In main, an object is created with the default constructor and used as:

Account even = new Account();
even.insert(101, "Amit", 5000.0f);

Inside insert, this.accountNumber, this.name, and this.amount make clear that the fields of the current calling object — even — are being set. The line this.display(); invokes the display method for that same current object. It is equivalent to writing even.display(); from inside the method, but it uses this to mean the current instance that called insert. Even if this is omitted and the code simply says display();, the program behaves the same because the implicit receiver is the current instance that called insert. Writing this.display() makes the receiver explicit and is the form that highlights this keyword usage.

25.9.4 Remaining Usages in Brief

The other four usages follow the same principle — this stands for the current object — applied in different call sites:

• To invoke the current class constructor, this() or this(arguments) is used as the first line inside another constructor to delegate to a sibling constructor of the same class.
• To be passed as an argument in a method call, this is handed to another method so that the receiving method can work with the calling object itself.
• To be passed as an argument in a constructor call, this is handed to a constructor of another class, linking the newly created object with the current one.
• To return the current class instance from a method, the method returns this so that callers can chain calls on the same object.

In each case the phrase current object keeps its meaning: the object that is the receiver of the currently executing method or the object whose constructor is running.

class Account {
    int accountNumber; String name; float amount;
    Account(int accountNumber, String name, float amount){
        this.accountNumber = accountNumber; this.name = name; this.amount = amount;
    }
    void display(){ System.out.println(accountNumber+" "+name+" "+amount); }
}

class Account {
    int accountNumber; String name; float amount;
    void insert(int acc, String n, float amt){
        this.accountNumber = acc; this.name = n; this.amount = amt;
        this.display();
    }
    void display(){ System.out.println(accountNumber+" "+name+" "+amount); }
}

Account even = new Account();
even.insert(101,"Amit",5000.0f);

Quick picture: three object blobs a1, a2, a3 each with an x slot, all pointing with a single arrow to one method box showData. Inside the box a small badge reads this -> current caller. The call arrow from a1 lights up badge this==a1. Takeaway: one code body, many contexts, this selects.

Six usages in brief for later listing: refer to instance variable, invoke method, invoke constructor, pass as method argument, pass as constructor argument, return the instance.

25.10 The final Keyword and Immutable Classes

25.10.1 Three Levels of Restriction

The keyword final is about putting restrictions. It has three distinct applications, all with the same theme that the marked element cannot be changed in a specific way.

• Put final before a variable and the variable becomes a constant variable. Its value cannot be changed after initialization.
• Put final before a method and the method cannot be overridden. In an inheritance hierarchy, a child will not be able to provide a new definition for that method.
• Put final before a class and the class cannot be inherited. No child class can be created that extends it.

Each placement adds one restriction at its own level: variable level is value restriction, method level is override restriction, class level is inheritance restriction.

25.10.2 Mutable versus Immutable Classes

Classes discussed earlier such as Account and Student are mutable classes. They are mutable because there is no final restriction. Inheritance is free, methods can be overridden, and variable values can be changed. That is the default character of ordinary classes.

An immutable class — a class with restrictions that cannot be modified — is the opposite. Once an object is created, its state cannot be changed. Immutability is built by applying final at multiple places in a disciplined way.

25.10.3 Building an Immutable Class

An immutable class satisfies a checklist:

1. The class must be declared final so that its child class cannot be created. If an attempt is made to write class B extends ABC where ABC is final, that attempt will not compile.
2. Data members must be declared final. Their values are set once and then become constant. For example, final int x; in class ABC. If x is initialized to 10 in a parameterized constructor, that 10 is fixed. Trying to change x to 20 later causes a compilation error because a final field cannot be reassigned.
3. Provide a parameterized constructor and getter methods for all variables so that values can be supplied once at creation and read later. Provide no setter methods. Without setters, there is no API to modify a field after the object leaves the constructor. Values can be initialized once when the object is created and retrieved through getters, but they cannot be altered.

A sketch of the pattern inside a class ABC is:

final class ABC {
    final int x;
    ABC(int x) {
        this.x = x;
    }
    int getX() {
        return x;
    }
}

Here final at the class level blocks inheritance, final on x makes the field constant after construction, the parameterized constructor sets x once, and only a getter is present. There is no setX. Attempting x = 20 after construction is a compilation error. That trio — final class, final fields, getters only with no setters — captures what is meant by an immutable class: it cannot be extended, its fields cannot be reassigned, and its API offers no mutation.

Real-world: Immutable representations are favored for values that should stay stable, such as currency amounts, dates, or strings themselves, because sharing them across code is safe when no one can change them.

final class ABC {
    final int x;
    ABC(int x){ this.x = x; }
    int getX(){ return x; }
}

25.11 Arrays — Declaration, Memory and the Arrays Utility Class

25.11.1 Declaration, Creation, Initialization and Indexing

An array — a collection of similar data types — groups many values of the same type together. An array of integers, an array of strings, or an array of nodes are all examples of the same idea: one name for many consecutive slots that hold the same kind of value.

Three syntactic variants are used to declare an array, differing only in bracket placement:

int[] arr;
int arr[];
int []arr;

Any of these tells the compiler that the variable will hold an array of type integer. At this point only the declaration exists. The actual storage is linked when the size is provided, for example:

arr = new int[6];

That reserves six consecutive units of memory for integers. The compiler now knows the physical extent. Initialization can be done on the right-hand side as well, for example:

int[] a = {2, 3, 5, 1, 4, 7};

Here the name of the array is a and it holds six members with those six values. Indexing always starts from zero. So a[0] is 2, a[1] is 3, a[2] is 5, a[3] is 1, a[4] is 4, a[5] is 7.

25.11.2 Loops for Access — Simple, For-Each and Labeled

To access elements, a loop is used.

A simple for loop that prints every element using the length property is:

for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);
}

The loop continues up to a.length. At each iteration one value is printed. When the loop exhausts, all values have appeared on the screen. The name length is a predefined property available with arrays.

A for-each loop offers a shorter form for the same traversal, and it has been used in earlier sessions. A labeled for loop allows a name to be attached to a loop for control flow, for example:

AA: for (int i = 0; i < a.length; i++) {
    // body; the label AA can be referenced to return to this loop
}

Here AA is the label for the loop. Labeling is useful when multiple nested loops exist and the logic needs to refer to a specific loop.

25.11.3 Working with Arrays — Sort, Binary Search, Copy, Fill

Arrays is a class in Java that brings several ready-made methods for working with arrays directly. These methods save manual coding.

Sort. Arrays.sort sorts elements. It can sort a bounded range or the whole array.

int[] a = {2, 3, 5, 1, 4, 7};
Arrays.sort(a, 0, 4);

Here 0 is the starting index and 4 is the number of elements to sort from that start. The first four elements 2, 3, 5, 1 become sorted to 1, 2, 3, 5. The remaining two elements 4, 7 stay unsorted because the sort was bounded to four elements. The array after the call is {1, 2, 3, 5, 4, 7}. If no bounds are provided as Arrays.sort(a), the entire array is sorted to {1, 2, 3, 4, 5, 7}.

Binary search. To find the position of a value in a sorted structure, Arrays.binarySearch is used.

int pos = Arrays.binarySearch(a, 5);

If the array is viewed as {1, 2, 3, 5, 4, 7} after the bounded sort, the call for 5 returns index 3 in zero-based counting. In a fully sorted view, the index for 5 would be 4 as 0:1, 1:2, 2:3, 3:4, 4:5. The method returns the index number where the element is found. The example reports four as the index in that fully sorted framing, counting from zero.

Copy. A copy of an array can be created up to a particular length.

int[] b = Arrays.copyOf(a, 4);
int[] c = Arrays.copyOf(a, a.length);

copyOf takes the source array and a length. With length 4, the first four elements are copied. With a.length, which is 6, all six elements are copied. A related method copyOfRange copies a specific window:

int[] d = Arrays.copyOfRange(a, 1, 4);

Here 1 is the starting index and the logical end is bounded so that four elements starting from index 1 are considered in the description used in the session, producing a copy containing 2, 3, 4 style slices depending on the precise bounds. The session text presents the call as starting at index 1 and taking four elements forward, yielding a copy that reflects that window.

Fill. An array can be filled with a single value.

Arrays.fill(a, 1);

That fills the entire array with 1s, so the array becomes all ones. A bounded fill is also available:

Arrays.fill(a, 0, 4, 1);

Here 0 is the start index, 4 is the end bound, and 1 is the value. The described effect is that the array gets filled with ones in the selected range, and with the one-argument form the whole array becomes ones. The key point is that Arrays as a class brings sort, binarySearch, copyOf, copyOfRange, and fill as predefined operations.

Real-world: These utilities are part of daily Java practice for ordering data, searching efficiently, duplicating buffers, and initializing tables without manual loops.

25.11.4 The Equality Trap — Reference versus Content Comparison

Comparing arrays needs care. Consider two separate arrays:

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};

A natural test is:

if (arr1 == arr2) System.out.println("same");
else System.out.println("not same");

The output is not same even though the elements look identical. The reason is that == compares reference variables, not contents. Suppose arr1 starts at memory location 1000 and arr2 starts at 2000. The comparison is effectively 1000 == 2000, which is false. Each array is a distinct object at a distinct address, so reference comparison fails.

The solution is the content-based method:

if (Arrays.equals(arr1, arr2)) System.out.println("same");
else System.out.println("not same");

Arrays.equals does a one-to-one comparison of the elements in the two arrays. Since 1, 2, 3 matches 1, 2, 3 element by element, it returns true and same is printed. This contrast — == as reference check versus equals as element-wise check — is the essential trap when testing array equality.

Exam note: Expect a question that shows two arrays with identical literals and asks what arr1 == arr2 prints. The intended answer is not same and the fix is Arrays.equals.

int[] arr; int arr[]; int []arr;

arr = new int[6];

int[] a = {2,3,5,1,4,7};

for(int i=0;i<a.length;i++) System.out.println(a[i]);

for(int v: a) System.out.println(v);

AA: for(int i=0;i<a.length;i++){
    if(a[i]==5) continue AA;
    System.out.println(a[i]);
}

Arrays.sort(a,0,4);

int pos = Arrays.binarySearch(a,5);

int[] b = Arrays.copyOf(a,4);
int[] c = Arrays.copyOf(a,a.length);
int[] d = Arrays.copyOfRange(a,1,4);

Arrays.fill(a,1);
Arrays.fill(a,0,4,1);

int[] arr1 = {1,2,3}; int[] arr2 = {1,2,3};
if(arr1==arr2) System.out.println("same"); else System.out.println("not same");

if(Arrays.equals(arr1,arr2)) System.out.println("same"); else System.out.println("not same");

Visualize array a as six consecutive boxes labeled 0..5 on a line. sort reorders values inside boxes. binarySearch hops to middle then halves. copyOf draws a second line of boxes copying values. == compares box-line addresses, Arrays.equals compares box contents.

Arrays reference comparison shows not same — use Arrays.equals for content. That warning is the exam answer to memorize.

25.12 Strings — Constant Pool, Immutability, StringBuffer and StringTokenizer

25.12.1 Nature of Strings and Ways to Create Them

A string — a sequence of characters — is related to arrays but handled in a special way in Java. A string is bounded text, and handling strings involves the ideas of mutable and immutable, which are treated in the next subsection.

Creating a string can be done in several ways:

String str = "ABC";
char[] data = {'A', 'B', 'C'};
String s2 = new String(data);
String s3 = s2;

The first form puts text in double quotes after the type String. The second builds a string from a character array. The third passes one string to another for initialization. All produce a sequence of characters that can be printed, compared, and passed to methods. The crucial difference from arrays lies in how identity and content are treated in memory.

25.12.2 String Constant Pool and the Equality Puzzle

Strings carry a memory optimization called the string constant pool. When a string literal is created, the literal is stored in the pool and given an address, say 1000.

Example with two literals:

String s1 = "Java";
String s2 = "Java";
System.out.println(s1 == s2);

At first this is puzzling because with arrays == returned false for two separate objects with the same content. Here s1 == s2 prints true. The pool explains the difference. When s1 is created, Java is stored in the pool at address 1000 and s1 points there. When a request is made to initialize s2 with the same literal Java, no separate space is provided. Instead s2 is linked directly to the same pool entry at 1000 to save memory. Both references point to the same address, so reference comparison is true.

A contrast with new makes the pool behavior clear:

String s3 = new String("Java");
System.out.println(s2 == s3);

Because new forces creation, s3 is placed at a different address, not the pool entry reused by s1 and s2. Now s2 points to 1000 while s3 points elsewhere, so s2 == s3 is false even though the characters are the same.

The content check uses equals:

System.out.println(s2.equals(s3));

Content-wise the two strings are both Java, so a one-to-one character comparison returns true. This string behavior is the mirror of the array case: with arrays new int[]{1,2,3} always creates distinct addresses, while with string literals the pool reuses an existing entry.

25.12.3 Immutability and StringBuffer for Mutable Sequences

Strings are immutable. Once a string points to Java at address 1000, its content cannot be changed in place. Assigning a modified text creates a separate string and repoints the variable to the new address; the original Java entry keeps existing in the pool.

When mutable, growable, writable character sequences are needed, the class StringBuffer is used. Its size grows automatically to accommodate added characters, and it supports substring, insert, and append operations.

Constructors for StringBuffer include:

StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = new StringBuffer(20);
StringBuffer sb3 = new StringBuffer("hello");

The first is a default constructor, the second specifies a capacity, and the third initializes with a string. The effect is a buffer that can change without creating a fresh string object on each edit, which strings themselves cannot do.

Real-world: Mutable buffers are chosen for building text incrementally in loops or for editing operations where many inserts and appends occur.

25.12.4 StringTokenizer — Breaking a String into Tokens

The class StringTokenizer breaks a string into tokens. A token is a piece of the string separated by delimiters. By default a space is considered the delimiter, though other delimiters can be supplied.

Take the string java programming with objects. With space as delimiter, four tokens are produced: java, then a space, then programming, then a space, then with, then a space, then objects. Logically the word tokens are java, programming, with, objects — four tokens.

Code that extracts them is:

import java.util.StringTokenizer;

class Test {
    public static void main(String args[]) {
        StringTokenizer st = new StringTokenizer("java programming with objects");
        int i = 0;
        int j = st.countTokens();
        while (st.hasMoreTokens()) {
            System.out.println(st.nextToken());
            i++;
        }
        System.out.println("loop iterated " + i + " times");
        System.out.println("countTokens now " + st.countTokens());
    }
}

Steps in full detail:

• Import java.util.StringTokenizer.
• Inside main, create the tokenizer st with the subject string java programming with objects.
• Initialize int i = 0 as a loop counter.
• Initialize int j = st.countTokens() which first counts four tokens and stores 4 in j.
• Enter a while loop with condition st.hasMoreTokens(). While tokens remain, print st.nextToken(). The first call before any token is consumed returns java, the second returns programming, the third returns with, the fourth returns objects. At each iteration increment i.
• After the loop, i is 4 because the loop iterated four times, once per token. Printing the tokens shows each word on its own line in order.
• Calling countTokens after the string is exhausted returns 0 because all tokens have been consumed. The output therefore includes 4 at the start as the initial count and 0 at the end as the exhausted count.

This walkthrough shows how to identify tokens from a string, how to print them one by one, how to track the iteration count, and how countTokens changes as tokens are consumed. The exhaustive versus remaining count distinction is a frequent point of confusion and is made visible by printing before and after the loop.

Real-world: Tokenizing is a step in many text processing pipelines — splitting a sentence into words before counting, indexing, or analyzing.

String str = "ABC";
char[] data = {'A','B','C'}; String s2 = new String(data);
String s3 = s2;

StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = new StringBuffer(20);
StringBuffer sb3 = new StringBuffer("hello");

String s1 = "Java";
String s2 = "Java";
System.out.println(s1==s2);

String s3 = new String("Java");
System.out.println(s2==s3);

System.out.println(s2.equals(s3));

import java.util.StringTokenizer;
class Test {
    public static void main(String args[]){
        StringTokenizer st = new StringTokenizer("java programming with objects");
        int i=0; int j = st.countTokens();
        while(st.hasMoreTokens()){ System.out.println(st.nextToken()); i++; }
        System.out.println("loop iterated "+i+" times");
        System.out.println("countTokens now "+st.countTokens());
    }
}

Visualize strings: pool box at top holds literal "Java" at 1000. Two arrows s1 and s2 point to that same box. A separate heap box holds s3's distinct "Java". The == comparison checks arrow targets; equals checks characters inside boxes. For tokenizer, picture four word boxes in order, st as a cursor moving box by box; countTokens shrinks as cursor advances.

String constant pool memory sharing intuition explains s1==s2 true — the picture of one pool entry with two references is the mental model to keep.

25.13 Streams and File Input-Output — BufferedReader, PrintWriter and Scanner

25.13.1 Streams as Virtual Connections

A stream — a virtual connection between a program and a medium — is the abstraction that handles input and output. To take input, a virtual connection to the source is needed. To give output, a virtual connection to the destination is needed. The connection itself is called a stream.

Two everyday instances make the idea concrete:

• System.in is an input stream that connects to the keyboard. Associating a scanner or reader with System.in lets a program collect data typed by a user.
• System.out is an output stream that connects to the screen, also called the monitor or console. Calling System.out.println writes through that stream to the display.

The same abstraction scales beyond keyboard and screen. By associating the stream object with a File object, the program can read from or write to a file. By associating with a Socket, it can exchange data over a network. The program code looks similar; only the stream partner changes.

25.13.2 BufferedReader for Input and PrintWriter for Output

For taking input, the class BufferedReader is commonly used. Its creation depends on the source:

• From keyboard: BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); Here an InputStreamReader bridges System.in to the reader that collects characters.
• From a network socket: BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); Here socket.getInputStream() is the predefined method that supplies bytes from the network, wrapped by InputStreamReader and BufferedReader.
• From a specific file: BufferedReader br = new BufferedReader(new FileReader("abc.txt")); Here new FileReader("abc.txt") opens the named file and the reader collects its content.

For giving output to a text file, the class PrintWriter is used. It is a stream class that writes to a text file and offers methods print and println that look just like the System.out methods of the same names, except the destination is a file, not the screen.

A complete example that writes to a file demonstrates the life cycle:

import java.io.*;

class TextFileOutputDemo {
    public static void main(String args[]) {
        PrintWriter outStream = null;
        try {
            outStream = new PrintWriter(new FileOutputStream("stuff.txt"));
        } catch (FileNotFoundException e) {
            System.out.println("Error opening file");
            System.exit(0);
        }
        outStream.println("Hello world");
        outStream.println("Second line");
        outStream.close();
    }
}

Walkthrough step by step:

1. Declare an object PrintWriter outStream without initializing it.
2. Inside a try block, initialize it with new PrintWriter(new FileOutputStream("stuff.txt")). The name of the file is stuff.txt. The file is the stream partner.
3. The initialization is placed inside try and catch because the file being opened may not exist or may not be creatable, which would otherwise cause abnormal termination at runtime with an exception. Handling that inside catch keeps the program controlled, often by printing a message and exiting.
4. Write content with outStream.println and string arguments. Each call sends a line to the file.
5. Once writing is complete, close the connection with outStream.close(). Closing clears pointers and background structures that were required to associate the file with the program. The connection between program and file — logically two boxes joined by the stream — is now broken cleanly.

Real-world: PrintWriter plus FileOutputStream is the textbook way to create log files, reports, or exported text from a running application.

25.13.3 Scanner for Reading a Text File — Complete Walkthrough

Input from a text file can be taken with BufferedReader, but the Scanner class can also be used. Earlier, Scanner was associated with System.in to read from the keyboard. The same class can be re-associated with a file to read text from that file.

The needed imports are:

import java.util.Scanner;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

A class that reads from a file and echoes to the screen is TextFileScannerDemo:

import java.util.Scanner;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

class TextFileScannerDemo {
    public static void main(String args[]) {
        System.out.println("I will read three numbers and a line of text from file morestuff.txt");
        Scanner inputStream = null;
        try {
            inputStream = new Scanner(new FileInputStream("morestuff.txt"));
        } catch (FileNotFoundException e) {
            System.out.println("File morestuff.txt not found");
            System.exit(0);
        }
        int n1 = inputStream.nextInt();
        int n2 = inputStream.nextInt();
        int n3 = inputStream.nextInt();
        inputStream.nextLine();
        String line = inputStream.nextLine();
        System.out.println("The three numbers read from file are " + n1 + " " + n2 + " " + n3);
        System.out.println("The line read from file is " + line);
        inputStream.close();
    }
}

Complete execution story:

• Print a prompt: I will read three numbers and a line of text from file morestuff.txt. This goes to the console through System.out.
• Declare Scanner inputStream as null.
• Inside try, initialize it with new Scanner(new FileInputStream("morestuff.txt")). That connects the program to the file morestuff.txt using a file stream wrapped by a scanner. Inside catch, handle the case where the file is not present by printing a message and exiting. This avoids abnormal termination without a message.
• If the try succeeds, the file is available and no exit occurs. The program has an active association — logically the file on one side, the program on the other, linked by the scanner.
• Read three integers: n1 = inputStream.nextInt(), n2 = inputStream.nextInt(), n3 = inputStream.nextInt(). Each nextInt consumes the next number in the file.
• Move to the next line with inputStream.nextLine() so that the subsequent string read starts at the beginning of the text line rather than at the trailing newline after the numbers.
• Read the line: String line = inputStream.nextLine(); That captures the remaining text as a string.
• Print the results to the screen: the three numbers as n1 n2 n3 and the line as stored.
• Close the scanner with inputStream.close().

Consider a concrete file morestuff.txt containing:

1 2 3 4
He is a jolly good fellow

The four numbers 1, 2, 3, 4 and the sentence He is a jolly good fellow are present. The program reads 1, 2, 3 into n1, n2, n3. It then moves to the next line and reads He is a jolly good fellow into line. The remaining 4 on the first line illustrates that only the first three numbers were consumed as directed.

Expected output is:

I will read three numbers and a line of text from file morestuff.txt
The three numbers read from file are 1 2 3
The line read from file is He is a jolly good fellow

Three distinct stream associations have now been seen: System.in to keyboard, System.out to monitor, and file streams through BufferedReader, PrintWriter, or Scanner. For input, BufferedReader and Scanner are alternatives; for output to file, PrintWriter is the direct choice. Choosing among them depends on whether formatted token reading, buffered character reading, or simple line printing is the main need.

Real-world: File-based scanner reading is a quick way to ingest configuration, test data, or small datasets during development without setting up a database.

Exam note: Try-catch handling around file opening is not optional decoration. Programs that open files should place the open inside try and provide a catch for FileNotFoundException, then close the stream at the end.

import java.io.*;
class TextFileOutputDemo {
    public static void main(String args[]){
        PrintWriter outStream = null;
        try{ outStream = new PrintWriter(new FileOutputStream("stuff.txt")); }
        catch(FileNotFoundException e){ System.out.println("Error opening file"); System.exit(0); }
        outStream.println("Hello world");
        outStream.println("Second line");
        outStream.close();
    }
}

import java.util.Scanner; import java.io.FileInputStream; import java.io.FileNotFoundException;
class TextFileScannerDemo {
    public static void main(String args[]){
        System.out.println("I will read three numbers and a line of text from file morestuff.txt");
        Scanner inputStream = null;
        try{ inputStream = new Scanner(new FileInputStream("morestuff.txt")); }
        catch(FileNotFoundException e){ System.out.println("File morestuff.txt not found"); System.exit(0); }
        int n1 = inputStream.nextInt(); int n2 = inputStream.nextInt(); int n3 = inputStream.nextInt();
        inputStream.nextLine(); String line = inputStream.nextLine();
        System.out.println("The three numbers read from file are "+n1+" "+n2+" "+n3);
        System.out.println("The line read from file is "+line);
        inputStream.close();
    }
}

1 2 3 4
He is a jolly good fellow

Picture three diagrams side by side: left shows keyboard -> System.in -> Scanner -> program, middle shows program -> PrintWriter -> stuff.txt, right shows morestuff.txt -> FileInputStream -> Scanner -> program. All three share the stream line metaphor with the medium on one side and the program on the other.

Stream try catch required for file open and close to avoid abnormal termination — the warning that turns a runtime crash into a controlled message and exit.

Exam Guidance Summary

The session is positioned as a review and revision covering the material needed to understand object oriented programming, its basics, and related ideas, spanning modules one to seven in the current meeting. Time for the review is about two hours for this meeting, with a second meeting to cover the later modules.

• Bytes and execution carry weight. Be ready to show the two files created — .java and .class — to name javac as compiler and java as interpreter, and to explain the line first.class is bytecode.
• Portability questions focus on definition and on the single requirement of a correctly installed JVM per platform.
• Classes demand precise language: a set of attributes and operations, a collection of member data and member functions in a single unit, a blueprint that allows many objects with local values. The Account and Circle illustrations are likely short-answer sources.
• Constructors are a frequent trap. Know the two rules — name same as class, no return type — the default values 0, null, 0.0, that an unwritten default is auto-provided only when no parameterized constructor exists, and that once a parameterized constructor is present a no-argument new Account() fails without an explicit no-argument constructor.
• Variables are split into instance versus static. The static statement to memorize is exactly one copy per class regardless of instantiations, accessed as ClassName.variable.
• Static block execution is automatic on class loading, before any explicit call, and is the initializer for static fields.
• this has six usages. At minimum be able to write the disambiguation pattern this.field = field and the method invocation this.display(). The remaining four — constructor delegation, passing as method argument, passing as constructor argument, returning the instance — should be listed.
• final has three restriction levels — variable as constant, method as non-overridable, class as non-inheritable — and ties directly to the immutable class checklist: final class, final fields, parameterized constructor, getters only, no setters.
• Arrays require the three declaration forms, the new type[size] linking to consecutive memory, zero-based indexing, the three loop forms including labeled loops, and the Arrays utility methods sort with and without bounds, binarySearch, copyOf, copyOfRange, and fill. The == versus Arrays.equals distinction for arrays is a predicted question.
• Strings contrast with arrays through the string constant pool. s1 == s2 as true for reused literals, new String creating a separate address as false, and equals for content as true form a standard trio. Immutability versus StringBuffer mutability and the StringTokenizer extraction of four tokens from java programming with objects are the string-to-token steps to rehearse.
• Streams are the virtual connection abstraction. System.in to keyboard and System.out to screen are the base examples. BufferedReader with InputStreamReader or FileReader for input, PrintWriter with FileOutputStream for output inside try and catch, and Scanner with FileInputStream for file reading with nextInt and nextLine are the three file stream patterns to practice with close at the end.
• Overall advice for anticipated question types is to present work in tables or listed steps where possible, to write assumptions in full, and to show code in the exact forms given — especially public static void main(String args[]) and System.out.println.

This appendix is retained with the same guidance as the initial lecture notes and expanded for focused study. The review spans modules one to seven and is allocated about two hours in this meeting, with later modules following. Study advice from the lecture: present answers in tables or listed steps, write assumptions in full sentences, and keep code in the exact forms taught — public static void main(String args[]), System.out.println, javac First.java, java First, ABC.c, this.field = field, final class with final fields and getters.

Rehearsal checks: explain why First.class is bytecode not executable, why a correctly installed JVM per platform is the portability requirement, what the three parts of a class definition are with Account and Circle screenshots, the two constructor rules and suppressed-default case, the single-copy static statement with ClassName.variable access, that a static block runs on class loading, the six this usages with emphasis on disambiguation and this.display(), the three final levels plus immutable checklist, array declarations with new type[size] and Arrays.equals versus ==, the string pool s1==s2 / new / equals trio and StringTokenizer four tokens, and the stream try/catch/close with BufferedReader, PrintWriter, and Scanner.

Key Industry Applications

Real-world: Bytecode as a highly optimized portable instruction set with the JVM as platform-specific interpreter enables write-once-run-anywhere delivery, with portability realized by shipping .class files and requiring only a JVM per target operating system.

Real-world: Encapsulation through classes that bundle member data and member functions underlies account management systems where operations such as withdraw, deposit, and check balance operate on account attributes, student record systems where each student object holds its own identifier and marks, and geometric libraries where circle objects expose area and circumference from center and radius.

Real-world: Polymorphism via overloading, illustrated by multiple getData definitions differentiated by argument count, supports flexible APIs where one name handles varied input shapes.

Real-world: Inheritance via extends with reuse of public and protected members underpins framework extension and reuse without rewriting parent logic.

Real-world: Static or class variables accessed as ClassName.variable support shared configuration such as a program-wide title like Java programming, counters of live objects, or cached defaults that must remain single-copy across many instances.

Real-world: Static blocks that run on class loading provide one-time initialization of those shared values before any object is created.

Real-world: The this reference for the current object enables correct construction when parameter names match field names and supports fluent APIs that return the current instance.

Real-world: Immutable classes built with final classes, final fields, and getter-only access model stable values such as amounts, dates, or keys that are safe to share widely.

Real-world: The Arrays utility class offers production-grade operations — bounded and unbounded sort, binarySearch for position finding, copyOf and copyOfRange for buffer duplication, and fill for initialization — used in data preparation, searching, and table setup.

Real-world: The string constant pool optimization reduces memory for repeated literals in large codebases, while StringBuffer provides growable writable sequences for incremental text construction, and StringTokenizer supports word splitting for analysis tasks such as breaking java programming with objects into tokens.

Real-world: Streams as virtual connections — System.in to keyboard and System.out to screen — scale to file and network programming, where BufferedReader with InputStreamReader or FileReader, PrintWriter with FileOutputStream, and Scanner with FileInputStream cover reading and writing for files and sockets, including logging to stuff.txt and ingest from morestuff.txt.

This appendix is retained to keep industry placement with each technical idea, now with a stronger placement sentence for each. Bytecode and JVM enable write-once-run-anywhere deployment pipelines that ship .class files to cloud nodes with per-OS JVMs. Encapsulation in Account and Student models translates to banking and university information systems; Circle shapes translate to CAD and graphics libraries. Overloading supports flexible API layers; extends with public/protected reuse supports framework evolution. static shared state models configuration singletons and live-object counts; static blocks seed that state at load time. this disambiguation keeps constructors correct and underpins fluent builders that return this. Immutable final types underpin safe keys and money values in concurrent services. Arrays utilities support ETL and search steps; string pooling and buffers support high-throughput text services; tokenizers feed indexing; streams with BufferedReader, PrintWriter, and Scanner cover file and socket I/O for reports and ingest.