📗 Module III: Packages and Access Modifiers, Handling String, Input

Output Classes

( By Santosh )
●​ Packages and Access Modifiers​

○​ Recommended Package Naming Convention​

○​ The Package Declaration​

○​ The CLASSPATH Variable​

○​ The Import Statement​

○​ Java Language Packages​

○​ Importance of Package Design​

●​ Access Protection​

●​ Handling Strings​

○​ Create Strings​

○​ Operations on Strings​

○​ Character Extraction Method​

○​ String Comparison Method​

○​ Searching and Modifying Strings​

○​ Data Conversions and valueOf()​

○​ Methods of StringBuffer and StringBuilder​

○​ Changing Case of Characters​

○​ Wrapper Classes​
 ●​ Input and Output Classes​

○​ Hierarchy of Classes in java.io​

○​ File Classes​

○​ InputStream and OutputStream Classes​

■​ FilterInputStream​

■​ FilterOutputStream​

○​ Reader and Writer Classes​

●​ Basics of Networking​

○​ Java's Networking Protocol​

○​ Hierarchy of Classes in java.net​

○​ Connection-oriented Protocol Classes​

1. Packages and Access Modifiers

What is a Package?

In Java, a package is like a folder or directory that groups related classes and interfaces
together.

●​ Packages help avoid name conflicts. For example, you can have
com.companyA.project.Employee and com.companyB.project.Employee
without collision.​

●​ They provide access protection (access modifiers interact with package boundaries).​

●​ They make maintenance and organization easier.​

Recommended Package Naming Convention

Why reverse domain name?

●​ Domains are unique worldwide, so reversing them makes the package names globally
unique.​

●​ It also reflects ownership and avoids conflicts.​

Example:​
If your organization’s domain is example.com, the package name starts as:

package com.example.myproject;

Inside myproject, you might have sub-packages:

package com.example.myproject.utils;
package com.example.myproject.models;
package com.example.myproject.services;

The Package Declaration

●​ Must be the first statement in a Java source file.​

●​ Defines the package that the class belongs to.​

Example:

package com.example.shapes;

public class Circle {

// class code
}

If omitted, the class goes into the default package, which is discouraged for larger projects.

The CLASSPATH Variable

 ●​ When compiling or running Java programs, the JVM and compiler need to know where
to look for classes.​

●​ CLASSPATH is an environment variable or command-line option that tells JVM where to

look for classes and packages.​

Example:

Suppose your class files are in /home/user/classes.

Set CLASSPATH on Linux:

export CLASSPATH=/home/user/classes:.

The . ensures the current directory is included.

The Import Statement

Used to access classes from other packages without typing their full package names every time.

Syntax:

import package_name.class_name;

Example:

import java.util.ArrayList;
import java.util.HashMap;

You can also import all classes in a package:

import java.util.*;

Java Language Packages

Java provides a set of core packages:

 ●​ java.lang: Fundamental classes, e.g., String, System, Math. Imported automatically.​

●​ java.util: Utility classes like collections (ArrayList, HashMap), dates, random number
generation.​

●​ java.io: Input/output classes for file handling, streams, readers/writers.​

●​ java.net: Networking classes (sockets, URLs).​

●​ java.nio: New I/O classes with buffer-oriented I/O and non-blocking I/O.​

Importance of Package Design

●​ Modularization: Splits large projects into logical modules/packages.​

●​ Reusability: Well-designed packages can be reused in multiple projects.​

●​ Maintainability: Easier to update and debug code organized by function.​

●​ Access Control: Packages define access boundaries via access modifiers.​

Access Protection (Access Modifiers)

Java access modifiers control visibility:

Modifier Within Package Subclass (same Subclass (different Everywher

Class (same) package) package) e

public Yes Yes Yes Yes Yes

protected Yes Yes Yes Yes No

default Yes Yes Yes No No

private Yes No No No No

Examples:
package com.example;

public class MyClass {

public int pubVar;
protected int protVar;
int defVar; // default
private int privVar;

public void demo() {

System.out.println(pubVar); // Accessible
System.out.println(protVar); // Accessible
System.out.println(defVar); // Accessible
System.out.println(privVar); // Accessible
}
}

If another class in the same package accesses MyClass, it can see pubVar, protVar, and
defVar, but not privVar.

If another class is in a different package and is not a subclass, it can only access pubVar.

2. Handling Strings

Creating Strings

●​ Strings in Java are immutable objects.​

●​ Created either by string literals or with the new keyword.​

String s1 = "Hello"; // Literal, stored in String Pool

String s2 = new String("Hello"); // New object on the heap

Operations on Strings
 ●​ Concatenation:

String s = "Hello" + " World"; // "Hello World"

●​ Length:

int len = s.length(); // returns 11

●​ Check if empty:

boolean empty = s.isEmpty(); // false

●​ Trim whitespace:

String trimmed = s.trim();

Character Extraction Methods

●​ charAt(int index)

char c = s.charAt(0); // 'H'

●​ getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Copies characters from the string into an array.

String Comparison Methods

●​ equals(String another)

Checks if two strings have the same content.

if(s1.equals(s2)) {
System.out.println("Equal");
}

●​ equalsIgnoreCase(String another)​

Ignores case differences.

 ●​ compareTo(String another)​

Lexicographically compares strings (returns negative if less, 0 if equal, positive if greater).

Searching and Modifying Strings

●​ indexOf(String substr)

Returns index of the first occurrence, or -1 if not found.

●​ lastIndexOf(String substr)

Returns index of last occurrence.

●​ substring(int beginIndex, int endIndex)

Extracts a substring.

●​ replace(char oldChar, char newChar)

Replaces all occurrences of a character.

Data Conversions and valueOf()

●​ Converts primitive types to strings:

String intStr = String.valueOf(123); // "123"

String boolStr = String.valueOf(true); // "true"

●​ Can convert objects too.

Methods of StringBuffer and StringBuilder

●​ StringBuffer is thread-safe (synchronized).​

●​ StringBuilder is faster but not thread-safe.​

 ●​ Both allow mutable strings (unlike String).​

Common methods:

StringBuilder sb = new StringBuilder("Hello");

sb.append(" World");
sb.insert(5, ",");
sb.replace(6, 11, "Java");
sb.delete(5, 6);
sb.reverse();

Changing Case of Characters

●​ toUpperCase() converts all characters to uppercase.​

●​ toLowerCase() converts all characters to lowercase.​

Wrapper Classes

Primitive types and their wrapper classes:

Primitive Wrapper Class

int Integer

char Character

boolean Boolean

double Double

Supports autoboxing/unboxing.

Example:

Integer num = 10; // autoboxing

int n = num; // unboxing
3. Input and Output Classes

Hierarchy of Classes in java.io

Abstract Purpose Common subclasses
class

InputStream Reads bytes FileInputStream,

BufferedInputStream

OutputStrea Writes bytes FileOutputStream,

m BufferedOutputStream

Reader Reads FileReader, BufferedReader

characters

Writer Writes characters FileWriter, BufferedWriter

File Class

●​ Represents file or directory path.​

●​ Can create, delete, check file info.​

File file = new File("example.txt");

if(file.exists()) {
System.out.println("File size: " + file.length());
}

InputStream and OutputStream Classes

●​ Work with raw bytes.​

●​ Example reading a file byte-by-byte:

try(FileInputStream fis = new FileInputStream("input.txt")) {

 int data;
while((data = fis.read()) != -1) {
System.out.print((char)data);
}
} catch(IOException e) {
e.printStackTrace();
}

FilterInputStream and FilterOutputStream

●​ Wrap existing streams to add functionality.

Example: BufferedInputStream buffers input for efficiency.

FileInputStream fis = new FileInputStream("file.txt");

BufferedInputStream bis = new BufferedInputStream(fis);

int data;
while((data = bis.read()) != -1) {
System.out.print((char)data);
}
bis.close();
fis.close();

Reader and Writer Classes

●​ For reading and writing characters (Unicode).​

●​ Usually preferred for text data.​

Example reading with BufferedReader:

BufferedReader br = new BufferedReader(new FileReader("file.txt"));

String line;
while((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();

4. Basics of Networking

Java's Networking Protocol

●​ Supports TCP (reliable, connection-oriented)​

●​ Supports UDP (unreliable, connectionless)​

Hierarchy of Classes in java.net

Class Purpose

Socket Client TCP socket

ServerSocke Server socket for listening

t

URL Uniform Resource Locator

InetAddress IP Address resolution

DatagramSoc UDP socket

ket

DatagramPac UDP packet

ket

Connection-oriented Protocol Classes

TCP sockets:

●​ Server creates a ServerSocket to listen on a port.​

 ●​ Client creates a Socket to connect to server.​

●​ Both can send/receive data via streams.​

Example server:

ServerSocket server = new ServerSocket(1234);

Socket client = server.accept(); // waits for client

BufferedReader in = new BufferedReader(new

InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream(), true);

String message = in.readLine();

System.out.println("Received: " + message);
out.println("Hello Client!");

Example client:

Socket socket = new Socket("localhost", 1234);

PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));

out.println("Hello Server");
String response = in.readLine();
System.out.println("Server says: " + response);