Unit 1: OOP Concepts
Answer: Object-Oriented Programming (OOP) is a design methodology that uses "objects" to model real-world items. This makes code easier to organize, maintain, and reuse. The five core pillars of OOP in Java are:
- 1. Class: A class is a user-defined blueprint or template from which objects are created. It defines the common properties (variables) and behaviors (methods) that all objects of that type will share. A class does not take up memory until an object is created.
Example:class Car { String color; void drive() { ... } } - 2. Object: An object is a real-world entity and a physical instance of a class. When an object is created using the
newkeyword, memory is allocated. It contains a specific state (data) and behavior.
Example:Car myCar = new Car(); - 3. Encapsulation: This is the process of wrapping data (variables) and the code that acts on that data (methods) together as a single unit, much like a medical capsule. It hides the internal state of an object from the outside world using the
privatekeyword and provides access through public getter and setter methods. This protects data from accidental corruption. - 4. Inheritance: This is a mechanism where one new class (the child or subclass) acquires the properties and methods of an existing class (the parent or superclass) using the
extendskeyword. It promotes code reusability so you do not have to write the same code twice.
Example:class SportsCar extends Car { boolean hasTurbo; } - 5. Polymorphism: Meaning "many forms," this allows one single action to be performed in different ways. In Java, it is achieved through:
- Compile-time Polymorphism: Method Overloading (same method name, different parameters).
- Run-time Polymorphism: Method Overriding (child class provides a specific implementation of a parent's method).
Unit 1: Java Environment
Answer: Java's ability to "Write Once, Run Anywhere" is powered by three main components: the JDK, JRE, and JVM. They work together but serve entirely different purposes.
- 1. JVM (Java Virtual Machine):
The JVM is the heart of Java. It is an abstract machine (software program) that actually executes the Java code. When you compile a Java program, it turns into "bytecode" (a .class file). The JVM reads this bytecode line by line and translates it into machine language (0s and 1s) that your specific computer's operating system (Windows, Mac, Linux) can understand. The JVM is platform-dependent. - 2. JRE (Java Runtime Environment):
The JRE is the physical environment required to run a Java application. If you only want to play a Java game or run Java software, you only need to install the JRE.
Formula:JRE = JVM + Core Class Libraries + Supporting Files. - 3. JDK (Java Development Kit):
The JDK is the complete master toolkit used by programmers to develop and write new Java applications. It contains everything needed to compile, debug, and run code.
Formula:JDK = JRE + Development Tools (like 'javac' compiler, 'java' interpreter, 'javadoc').
The Lifecycle Example:
1. You write code in a text file using the JDK.
2. You use the javac tool in the JDK to compile it into bytecode.
3. The JRE provides the necessary libraries to support the code.
4. The JVM takes the bytecode, translates it, and executes it on your screen.
Unit 1: Classes and Objects
Answer: A Constructor in Java is a special block of code that is used to initialize an object immediately after it is created. It sets up the initial state (default values) for the object's variables.
Rules for creating a Constructor:
- The constructor name must be exactly the same as the class name.
- It must not have any explicit return type, not even
void. - It is called automatically when an object is created using the
newkeyword.
Constructor Overloading:
Constructor overloading is a technique where a single class can have more than one constructor, provided they have different parameter lists (different number of arguments or different data types). The compiler knows which one to use based on the data you provide when creating the object.
Code Example:
class Student {
int id;
String name;
// 1. Default Constructor (No arguments)
Student() {
id = 0;
name = "Unknown";
}
// 2. Parameterized Constructor (Overloaded)
Student(int i, String n) {
id = i;
name = n;
}
}
public class Main {
public static void main(String[] args) {
// Calls the Default Constructor
Student s1 = new Student();
// Calls the Parameterized Constructor
Student s2 = new Student(101, "Manthan");
}
}
Unit 1: Language Basics
Answer: A Java program is basically a collection of tokens, comments, and white spaces. A Token is the smallest individual, meaningful unit in a Java program. When you write code, the compiler breaks the entire code down into these tiny pieces to understand it.
There are five main types of tokens in Java:
- 1. Keywords: These are reserved words that have a special, predefined meaning to the Java compiler. They cannot be used as variable or class names. All keywords are written in lowercase.
Examples:class,public,static,void,if,int. - 2. Identifiers: These are the names created by the programmer for classes, methods, variables, and packages. They must follow certain rules (cannot start with a number, no spaces allowed).
Examples:salary,Student,calculateTotal(). - 3. Literals: These are constant values that are directly assigned to variables. They do not change during execution.
Examples:100(Integer literal),45.5(Float literal),'A'(Character literal),"Hello"(String literal),true(Boolean literal). - 4. Operators: Special symbols used to perform specific mathematical or logical operations on variables and values.
Examples:+,-,*,/(Arithmetic),==,>(Relational),&&,||(Logical). - 5. Separators (Punctuators): Symbols used to format and structure the code, indicating where groups of code begin and end, or separating items in a list.
Examples:{ }(blocks of code),;(end of statement),,(separating variables),( )(method parameters).
Example Breakdown of the statement: int age = 20;
- int -> Keyword
- age -> Identifier
- = -> Operator
- 20 -> Literal
- ; -> Separator
Unit 1: Arrays
Answer: An array is an object in Java that contains a collection of elements of the same data type, stored sequentially in contiguous memory locations. Arrays have a fixed size once they are created.
- 1. One-Dimensional Array:
This is the simplest form of an array, representing a single list or a single row of values. You access the elements using a single index, starting from 0.
Syntax & Example:// Declaration and memory allocation for 5 integers int[] marks = new int[5]; marks[0] = 85; // Initializing the first element - 2. Rectangular Array (Two-Dimensional Array):
A 2D array is essentially an "array of arrays." A rectangular array forms a perfect matrix or table with a fixed number of rows and columns. Every row has the exact same number of columns.
Syntax & Example:// Creates a grid with 3 rows and 4 columns int[][] matrix = new int[3][4]; matrix[0][0] = 10; // First row, first column - 3. Jagged Array:
A Jagged Array is a special type of 2D array where the lengths of the rows (the inner arrays) are not equal. It is an array of arrays with different column sizes. It is highly useful for saving memory when you don't need a perfect rectangular grid.
Syntax & Example:// Declare a 2D array with 2 rows, but leave columns blank int[][] jaggedArray = new int[2][]; // Row 0 has 3 columns jaggedArray[0] = new int[3]; // Row 1 has 5 columns jaggedArray[1] = new int[5];
Unit 1: Classes and Objects
Answer: In Java, class members (variables and methods) can be defined as either static or non-static. The key difference lies in memory allocation and how they are accessed.
- Static Members (Class Level):
- Declared using the
statickeyword. - They belong to the Class itself, not to any specific object.
- Memory is allocated only once in the class area at the time of class loading.
- All objects of the class share the exact same copy of the static variable. If one object changes it, it changes for all objects.
- They can be accessed directly using the class name, without creating an object (e.g.,
ClassName.variableName).
- Declared using the
- Non-Static Members (Instance Level):
- Declared without the static keyword.
- They belong to the Object (instance).
- Memory is allocated multiple times, every time a new object is created using the
newkeyword. - Each object gets its own separate copy of the variable. Changes in one object do not affect others.
- They must be accessed using an object reference (e.g.,
objectName.variableName).
Code Example:
class Student {
// Static variable: Shared by all students
static String universityName = "Saurashtra University";
// Non-Static variable: Unique to each student
int rollNo;
}
public class Main {
public static void main(String[] args) {
// Accessing Static: No object needed
System.out.println(Student.universityName);
// Accessing Non-Static: Object creation is mandatory
Student s1 = new Student();
s1.rollNo = 101;
System.out.println(s1.rollNo);
}
}
Unit 1: Control Flow
Answer: Control flow statements break the normal top-to-bottom execution of code, allowing the program to make choices or repeat tasks.
1. Decision Statements (Branching): Allow the program to execute specific blocks of code based on a condition.
- if-else: Evaluates a boolean condition. If true, the 'if' block runs. If false, the 'else' block runs.
int age = 20; if (age >= 18) { System.out.println("Eligible to vote"); } else { System.out.println("Not eligible"); } - switch: An alternative to long if-else chains. It evaluates a single variable and jumps to the matching
caseblock.int day = 1; switch(day) { case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; default: System.out.println("Invalid day"); }
2. Looping Statements (Iteration): Used to execute a block of code repeatedly until a condition fails.
- for loop: Used when the exact number of iterations is known in advance. It contains initialization, condition, and increment in a single line.
for(int i = 1; i <= 5; i++) { System.out.println(i); // Prints 1, 2, 3, 4, 5 } - while loop: An entry-controlled loop. The condition is checked first; if true, the code runs. Used when the number of iterations is unknown.
int count = 1; while(count <= 3) { System.out.println(count); count++; } - do-while loop: An exit-controlled loop. The code block is executed at least once before the condition is checked at the bottom.
int x = 10; do { System.out.println(x); // Prints 10 even if condition fails next x++; } while(x < 5);
Unit 1: Language Basics
Answer: Type Casting in Java is the process of converting the value of one primitive data type into another primitive data type. Since Java is a strongly typed language, it ensures data is handled safely during these conversions. There are two main types of casting:
- 1. Implicit Casting (Widening Type Casting):
This is done automatically by the Java compiler. It happens when you assign a smaller data type to a larger data type (e.g., converting anintto adouble). Because the target data type has more memory space than the source, there is absolutely no risk of data loss.
Order: byte -> short -> char -> int -> long -> float -> double
Code Example:int myInt = 100; // Automatic conversion from int (4 bytes) to double (8 bytes) double myDouble = myInt; System.out.println(myInt); // Outputs: 100 System.out.println(myDouble); // Outputs: 100.0 (safely converted) - 2. Explicit Casting (Narrowing Type Casting):
This must be done manually by the programmer. It happens when you want to assign a larger data type to a smaller data type (e.g., converting adoubleto anint). Because you are squeezing a large value into a smaller memory space, there is a risk of data loss (truncation). You must use the cast operator(datatype)to force the conversion.
Order: double -> float -> long -> int -> char -> short -> byte
Code Example:double exactPrice = 99.99; // Manual conversion. We force the double into an int. int roundedPrice = (int) exactPrice; System.out.println(exactPrice); // Outputs: 99.99 System.out.println(roundedPrice); // Outputs: 99 (The .99 is lost/truncated)
Unit 2: Inheritance Basics
Answer: When a class inherits from another class (using the extends keyword), the child class does not inherit the parent's constructors. However, when you create an object of the child class, the parent class's constructor must be executed first to set up the inherited properties.
The Rule of Execution: Constructors in Java execute from the top-down. The Parent's constructor runs before the Child's constructor.
The super() Keyword:
Java automatically inserts a hidden super(); call as the first line of the child's constructor to call the parent's default constructor. If the parent class only has a parameterized constructor, you must manually use super(arguments) in the child class to pass the required data upwards.
Code Example:
class Parent {
// Parent Constructor
Parent(String message) {
System.out.println("Parent Constructor: " + message);
}
}
class Child extends Parent {
// Child Constructor
Child() {
// Must explicitly call parent's parameterized constructor
super("Hello from Child!");
System.out.println("Child Constructor created.");
}
}
public class Main {
public static void main(String[] args) {
Child obj = new Child();
// Output:
// Parent Constructor: Hello from Child!
// Child Constructor created.
}
}
Unit 2: Polymorphism & Inheritance
Answer: Method Overriding is a feature that allows a child class to provide its own specific implementation for a method that is already provided by its parent class. This is the core of "Run-time Polymorphism."
Rules for Method Overriding:
- The method must have the exact same name as in the parent class.
- The method must have the exact same parameters (signature).
- There must be an inheritance (IS-A) relationship.
- You cannot override methods marked as
static,final, orprivate.
Code Example:
class Animal {
void makeSound() {
System.out.println("Some generic animal sound");
}
}
class Dog extends Animal {
// Overriding the parent's method
@Override
void makeSound() {
System.out.println("Bark! Bark!");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.makeSound(); // Outputs: Bark! Bark! (Child's version is called)
}
}
Unit 2: Class Modifiers
Answer: abstract and final are exact opposites in Java. One demands inheritance, while the other strictly prevents it.
- Abstract Class:
Declared with theabstractkeyword. It represents an incomplete concept or template.
- You cannot create an object of an abstract class.
- It is meant to be inherited (extended) by child classes.
- It can contain both regular methods (with a body) and abstract methods (without a body, forcing the child class to write the code).
Example:abstract class Shape { abstract void draw(); } - Final Class:
Declared with thefinalkeyword. It represents a completed, secure entity.
- You can create objects of a final class.
- It cannot be inherited. No other class can extend a final class. It is the end of the inheritance line (e.g., theStringclass in Java is final).
Example:final class SecureSystem { ... }
Unit 2: Interfaces & Cloning
Answer:
1. Interface:
An interface is a pure blueprint for a class. It is declared using the interface keyword.
- By default, all methods inside an interface are public and abstract (empty).
- All variables are implicitly public static final (constants).
- It is used to achieve Multiple Inheritance in Java, as one class can implement many interfaces.
interface Printable {
void print(); // Abstract by default
}
class Document implements Printable {
public void print() { System.out.println("Printing..."); }
}2. Object Cloning:
Object cloning is a way to create an exact, independent copy of an existing object. Instead of creating a new object using new and copying variables manually, we use the clone() method provided by the Universal Object class.
- To use it, a class must implement the marker interface Cloneable. If it doesn't, Java will throw a CloneNotSupportedException.
class Student implements Cloneable {
int roll;
// Overriding clone method
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}Unit 2: Core Concepts
Universal Class (Object Class):
In Java, the java.lang.Object class is the universal root class. Every single class you create in Java directly or indirectly inherits from the Object class. It provides default methods like toString(), equals(), and clone().
Access Specifiers:
Access specifiers (or modifiers) determine the visibility or scope of classes, variables, and methods. There are four main types:
- 1. private: The most restrictive. Accessible only within the exact same class. Cannot be seen by child classes or other classes.
- 2. default (no keyword): If you don't specify anything, it becomes default. Accessible only within classes of the same package.
- 3. protected: Accessible within the same package, AND also accessible outside the package only if it is through a child class (inheritance).
- 4. public: The least restrictive. Accessible from absolutely anywhere in the Java project.
Unit 2: Java Packages
Packages:
A package is a container or folder that groups related classes, interfaces, and sub-packages together. It helps organize large projects and prevents "name conflicts" (having two classes with the same name).
You create a user-defined package by placing package mypackagename; at the very top of your Java file.
Normal Import vs Static Import:
- Normal Import: Used to bring a class or an entire package into visibility so you can use its objects. You still need to use the class name to call static methods.
import java.lang.Math; // Normal import public class Test { public static void main(String[] args) { // Must use 'Math.' prefix System.out.println(Math.sqrt(25)); } } - Static Import: Introduced in Java 5. It allows you to import the
staticmembers (variables and methods) of a class directly. This means you can use them without typing the class name, making code shorter.import static java.lang.Math.sqrt; // Static import public class Test { public static void main(String[] args) { // 'Math.' prefix is no longer needed System.out.println(sqrt(25)); } }
Unit 2: java.lang Package
Answer: The java.lang package is automatically imported into every Java program. It contains fundamental classes.
- Wrapper Classes: Java uses primitive data types (like
int,char) for speed. But sometimes we need objects (e.g., to use them in Collections). Wrapper classes convert primitives into objects.
Examples:Integerfor int,Characterfor char,Doublefor double. Converting primitive to object is called Autoboxing. - String Class: Represents a sequence of characters. Strings in Java are immutable, meaning once a String object is created, its data or state cannot be changed. If you try to modify it, a brand new String object is created in memory.
Example:String name = "Java"; - StringBuffer Class: Used to create mutable (modifiable) strings. If you are doing a lot of string concatenations or modifications, StringBuffer is much more memory-efficient than String because it modifies the existing object instead of creating new ones. It is also thread-safe.
StringBuffer sb = new StringBuffer("Hello "); sb.append("World"); // Changes the original object System.out.println(sb); // Outputs: Hello World
Unit 2: java.util Package & Collections
Answer: The Collection framework in java.util provides data structures to store and manipulate groups of objects dynamically.
- Vector: A dynamic array that can grow or shrink in size. Unlike ArrayList, Vector is synchronized (thread-safe), making it suitable for multi-threaded environments.
- LinkedList: Implements a doubly-linked list. Every element (node) contains data and pointers to the previous and next nodes. It is very fast for inserting or deleting data compared to arrays.
- Stack: A subclass of Vector that implements a Last-In-First-Out (LIFO) data structure. You
push()items onto the top andpop()them off. - Queue: An interface representing a First-In-First-Out (FIFO) data structure. Elements are added at the end and removed from the front (like a line at a ticket counter).
- Map: An interface that stores data in Key-Value pairs (like a dictionary). Keys must be unique.
HashTableis a synchronized, legacy implementation of a Map. - SortedSet: An interface that extends Set and guarantees that its elements are kept in ascending, sorted order automatically.
Unit 3: Exception Handling
Answer: An exception is an unwanted or unexpected event occurring during the execution of a program (run-time) that disrupts the normal flow of instructions. Exception Handling is a mechanism to handle these runtime errors so that the normal flow of the application can be maintained.
Java uses five keywords for exception handling:
- 1. try: The
tryblock encloses the code that might generate an exception. It must be followed by either acatchblock or afinallyblock.try { int data = 50 / 0; // May throw ArithmeticException } - 2. catch: The
catchblock is used to handle the exception. It must immediately follow thetryblock. You can have multiple catch blocks to handle different types of exceptions differently.catch(ArithmeticException e) { System.out.println("Cannot divide by zero."); } - 3. finally: The
finallyblock contains crucial code that must be executed whether an exception occurs or not, and whether it is caught or not. It is typically used to close resources like database connections or files.finally { System.out.println("This will always execute."); } - 4. throw: The
throwkeyword is used to explicitly throw a single exception (either built-in or custom) from within a method or a block of code.if (age < 18) { throw new ArithmeticException("Not eligible to vote"); } - 5. throws: The
throwskeyword is used in a method signature to declare that the method might throw exceptions. It doesn't handle the exception itself but passes the responsibility of handling it to the calling method.void checkFile() throws IOException { ... }
Unit 3: Exception Handling
Answer: Sometimes the built-in exceptions in Java are not sufficient to describe an error specific to your application's logic (e.g., an InvalidAgeException). You can create your own custom exceptions by extending the Exception class.
Steps to create a custom exception:
- Create a new class that extends
Exception(for checked exceptions) orRuntimeException(for unchecked exceptions). - Create a constructor that takes a String parameter (the error message) and calls the parent's constructor using
super(message). - Use the
throwkeyword to trigger the exception when a specific condition is met.
Code Example:
// 1. Creating the Custom Exception Class
class InvalidAgeException extends Exception {
public InvalidAgeException(String errorMessage) {
super(errorMessage); // Pass message to parent Exception class
}
}
// 2. Using the Custom Exception
public class CustomExceptionDemo {
// Method declares that it might throw the exception
static void validateAge(int age) throws InvalidAgeException {
if (age < 18) {
// Explicitly throwing the custom exception
throw new InvalidAgeException("Age is less than 18. Not eligible.");
} else {
System.out.println("Welcome to vote!");
}
}
public static void main(String[] args) {
try {
validateAge(16); // This will cause the exception
} catch (InvalidAgeException e) {
System.out.println("Caught an Exception: " + e.getMessage());
}
}
}
Unit 3: Threading
Answer: A Thread is a lightweight sub-process and the smallest unit of processing. Multithreading allows simultaneous execution of two or more parts of a program. In Java, threads are managed by the java.lang.Thread class.
The Thread Life Cycle (5 States): A thread transitions through various states during its lifetime, managed by the JVM's Thread Scheduler.
- 1. New (Born): A thread is in the New state when an instance of the
Threadclass is created using thenewoperator, but before thestart()method is invoked. It is an object, not an executing thread yet.
Code:Thread t = new Thread(); - 2. Runnable (Ready): Once the
start()method is called, the thread becomes runnable. It is added to the thread queue and is waiting for its turn to get CPU time from the thread scheduler.
Code:t.start(); - 3. Running: The thread moves into this state when the thread scheduler selects it from the runnable pool, allocates CPU time, and begins executing its
run()method. This is where the actual action happens. - 4. Blocked / Waiting: A thread becomes inactive temporarily and is not eligible to run. This happens if it is waiting for an I/O operation to complete, waiting for a monitor lock (synchronization), or if methods like
sleep()orwait()have been called on it. Once the condition is met, it returns to the Runnable state. - 5. Terminated (Dead): A thread enters this state when the
run()method has successfully completed its execution or if an unhandled exception causes it to abort. Once dead, a thread cannot be restarted.
Unit 3: Threading
Answer: Synchronization in Java is the capability to control the access of multiple threads to any shared resource.
Why is it needed?
In a multithreaded environment, multiple threads might try to access and modify the same resource (like a variable, object, or file) at the exact same time. This can lead to a "Race Condition" and cause data inconsistency or corrupted data. Synchronization ensures that only one thread can access the shared resource at a time.
How it works:
Java uses the concept of "Monitors" or "Locks." When a method or block is declared as synchronized, a thread must acquire the lock for that object before executing it. Other threads must wait in the Blocked state until the first thread finishes and releases the lock.
Types of Synchronization:
- Synchronized Method: Locks the entire object.
class Counter { int count; // Only one thread can execute this method at a time on a given object public synchronized void increment() { count++; } } - Synchronized Block: Used when you only want to lock a specific section of code within a method, improving performance by not locking the whole method.
public void doTask() { // some non-critical code... synchronized(this) { // critical section: only one thread allowed here count++; } }
Unit 3: Threading
Answer:
- Non-Daemon Thread (User Thread):
- These are the main threads of an application (like the
mainthread). - They perform the core tasks of the program.
- The JVM will wait for all user threads to finish their execution before terminating the application. It will not shut down if even one user thread is still running.
- These are the main threads of an application (like the
- Daemon Thread:
- These are low-priority, background service threads.
- Their sole purpose is to provide services to user threads (e.g., Garbage Collector, spelling checker in Word).
- The JVM does not wait for daemon threads to finish. If all user threads finish their execution, the JVM will automatically terminate all running daemon threads and shut down the application.
- You can make a thread a daemon by calling
setDaemon(true)before starting it.
Unit 3: Streams (Input and Output)
Answer: In Java, a Stream is a logical entity that represents a continuous flow of data. It is a sequence of data moving from a source to a destination. The java.io package contains classes to handle streams.
Streams are broadly classified into two categories based on the type of data they handle:
- 1. Byte Stream:
- Used to perform input and output of 8-bit bytes.
- Best suited for processing raw binary data, such as images, audio files, executable files, or serialized objects.
- The top-most abstract classes for byte streams are
InputStream(for reading) andOutputStream(for writing). - Key Classes:
FileInputStream,FileOutputStream,DataInputStream,DataOutputStream.
- 2. Character Stream:
- Used to perform input and output of 16-bit Unicode characters.
- Introduced to correctly handle textual data and international characters without encoding issues. It is best suited for reading and writing plain text files (.txt, .xml, .html).
- The top-most abstract classes for character streams are
Reader(for reading) andWriter(for writing). - Key Classes:
FileReader,FileWriter,BufferedReader,BufferedWriter.
Unit 3: Streams (Input and Output)
Answer: FileInputStream and FileOutputStream are byte stream classes used to read and write raw bytes of data to files.
1. FileOutputStream (Writing Data):
Used to write data to a file. If the file doesn't exist, it creates it.
import java.io.FileOutputStream;
public class WriteExample {
public static void main(String[] args) {
try {
// Create an output stream linked to a file
FileOutputStream fout = new FileOutputStream("test.txt");
String s = "Hello Java";
// Convert string to byte array
byte b[] = s.getBytes();
// Write bytes to the file
fout.write(b);
fout.close(); // Always close the stream
System.out.println("Success...");
} catch(Exception e) {
System.out.println(e);
}
}
}2. FileInputStream (Reading Data):
Used to read byte-oriented data from a file.
import java.io.FileInputStream;
public class ReadExample {
public static void main(String[] args) {
try {
// Create an input stream linked to an existing file
FileInputStream fin = new FileInputStream("test.txt");
int i = 0;
// read() returns -1 when the end of the file is reached
while((i = fin.read()) != -1) {
// Convert byte back to character and print
System.out.print((char)i);
}
fin.close(); // Always close the stream
} catch(Exception e) {
System.out.println(e);
}
}
}Unit 3: Streams (Input and Output)
Answer: FileReader and FileWriter are character stream classes specifically designed to read and write text files correctly using character encoding.
1. FileWriter (Writing Text):
Used to write character-oriented data to a file. Unlike FileOutputStream, you don't need to convert the String into a byte array manually.
import java.io.FileWriter;
public class FileWriterExample {
public static void main(String[] args) {
try {
FileWriter fw = new FileWriter("abc.txt");
// Directly write a string to the file
fw.write("Welcome to Java Character Streams.");
fw.close(); // Critical: Must close to flush data to the file
System.out.println("Success...");
} catch(Exception e) {
System.out.println(e);
}
}
}2. FileReader (Reading Text):
Used to read data from a file in a character-oriented way.
import java.io.FileReader;
public class FileReaderExample {
public static void main(String[] args) {
try {
FileReader fr = new FileReader("abc.txt");
int i;
// Read character by character until -1 (End of File)
while((i = fr.read()) != -1) {
System.out.print((char)i);
}
fr.close();
} catch(Exception e) {
System.out.println(e);
}
}
}Unit 4: Basic Structure of JAVAFX program .
Answer: JavaFX is a modern framework used to build rich graphical user interfaces (GUIs). Every JavaFX application must extend the javafx.application.Application class. The structure is built around a theatrical metaphor: a Stage, a Scene, and Nodes.
The Visual Hierarchy:
- Stage: This is the top-level container, representing the main window of the application (like a web browser window). The JVM automatically creates the primary stage.
- Scene: This is the container for all the visual content. It acts like the "canvas" placed inside the window. A Stage can only show one Scene at a time.
- Scene Graph (Nodes): This is a tree-like data structure containing visual elements called Nodes (like Buttons, Layout Panes, and Shapes). The root node is the topmost element in the scene.
Lifecycle Methods:
init(): Used to initialize data before the application starts. Cannot be used to create UI elements.start(Stage primaryStage): (Abstract method - Mandatory) This is the main entry point where the UI is constructed, the scene is attached to the stage, and the stage is displayed usingprimaryStage.show().stop(): Called automatically when the application is closed. Used for cleanup operations.
Code Example:
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;
public class Main extends Application {
@Override
public void start(Stage primaryStage) {
Button btn = new Button("Click Me");
StackPane root = new StackPane(); // Layout Pane (Root Node)
root.getChildren().add(btn);
Scene scene = new Scene(root, 300, 250); // Scene containing the root
primaryStage.setTitle("My First JavaFX App");
primaryStage.setScene(scene); // Attaching Scene to Stage
primaryStage.show(); // Displaying the Stage
}
public static void main(String[] args) {
launch(args); // Starts the JavaFX lifecycle
}
}
Unit 4: Panes, UI Control and Shapes, layout panes .
Answer: In JavaFX, Layout Panes are special container classes used to automatically manage and arrange the positions and sizes of UI controls (Nodes) on the screen. If you simply add elements without a pane, they might overlap or position themselves unpredictably when the window is resized.
Common Types of Layout Panes:
- StackPane: Places all its child nodes in a single stack, right on top of each other at the center of the pane. Useful for placing text over an image.
Example:StackPane root = new StackPane(); root.getChildren().addAll(rect, text); - HBox (Horizontal Box): Arranges all its child nodes in a single, continuous horizontal row from left to right.
Example:HBox hbox = new HBox(10); // 10px spacing - VBox (Vertical Box): Arranges all its child nodes in a single, continuous vertical column from top to bottom.
Example:VBox vbox = new VBox(15); // 15px spacing - GridPane: Arranges child nodes in a flexible grid of rows and columns, similar to a spreadsheet or HTML table.
Example:GridPane grid = new GridPane(); grid.add(button, column_index, row_index); - BorderPane: Divides the layout into five distinct regions: Top, Bottom, Left, Right, and Center. Very popular for classic application layouts (e.g., Toolbar at the top, Sidebar on the left, Content in the center).
Unit 4: Property binding .
Answer: Property Binding is a powerful mechanism in JavaFX that allows the value of one property (the Target) to automatically update whenever the value of another property (the Source) changes. This eliminates the need to manually write event listeners to synchronize data.
Properties in JavaFX are observable wrappers around standard data types (e.g., DoubleProperty instead of standard double).
- Unidirectional Binding: The target tracks the source. If the source changes, the target updates automatically. However, you cannot manually change the target anymore.
Syntax:targetProperty.bind(sourceProperty); - Bidirectional Binding: Both properties track each other. If Property A changes, Property B updates. If Property B changes, Property A updates.
Syntax:propertyA.bindBidirectional(propertyB);
Code Example: Imagine a Circle that should automatically stay perfectly centered in the window, even if the user resizes the window.
Pane pane = new Pane();
Circle circle = new Circle(50);
// Bind the circle's X and Y coordinates to be exactly half of the Pane's width and height
circle.centerXProperty().bind(pane.widthProperty().divide(2));
circle.centerYProperty().bind(pane.heightProperty().divide(2));
pane.getChildren().add(circle);
Unit 4: the Color and the Font class, the Image and Image-View class .
Answer: JavaFX provides specific classes to handle aesthetics and multimedia.
- The Color Class (
javafx.scene.paint.Color):
Used to encapsulate colors. You can set colors using predefined constants, RGB values, or web hex codes. It is often used to set the fill or stroke of shapes.
Examples:Color.RED(Constant)Color.color(0.5, 0.5, 0.5)(RGB from 0.0 to 1.0)Color.web("#FF0000")(Hex code) - The Font Class (
javafx.scene.text.Font):
Used to define the font family, weight, posture (italic), and size for text nodes or UI controls.
Example:Font myFont = Font.font("Arial", FontWeight.BOLD, FontPosture.ITALIC, 20);textNode.setFont(myFont); - The Image and ImageView Classes (
javafx.scene.image.*):
To display an image, JavaFX separates the physical image data from the visual node used to display it on screen.- Image: Represents the actual memory data of the image file (loaded via a URL or file path). It is NOT a visual node.
- ImageView: This is the visual Node that you add to your scene graph. It takes the
Imageobject and displays it. You can resize or rotate the ImageView.
// 1. Load the raw image data Image myImage = new Image("file:logo.png"); // 2. Create the visual container to display it ImageView myImageView = new ImageView(myImage); // Optional: Resize the view myImageView.setFitWidth(100); myImageView.setPreserveRatio(true);
Unit 4: Events and Events sources, Registering Handlers and Handling Events .
Answer: Event-Driven Programming is a paradigm where the flow of the program is determined by user actions (events), such as mouse clicks, key presses, or sensor outputs. Instead of executing code top-to-bottom and stopping, the program waits continuously for events to occur.
The Three Components of Event Handling:
- 1. Event: An object that represents an action that has occurred (e.g.,
ActionEventfor a button click,MouseEventfor moving the mouse,KeyEventfor typing). - 2. Event Source: The GUI component or Node that generates the event (e.g., A
Buttonobject). - 3. Event Handler (Listener): A block of code (an object implementing the
EventHandlerinterface) designed to receive the event object and execute specific logic in response to it.
Registering Handlers:
To make a UI component respond to an action, you must "register" the handler to the source. This is typically done using methods starting with setOn....
Button btn = new Button("Submit");
// Registering the handler using a Lambda Expression (Modern Java approach)
btn.setOnAction(event -> {
System.out.println("The button was clicked!");
});
Unit 4: Inner Classes, anonymous inner class handlers .
Answer: When writing Event Handlers in JavaFX, creating a completely separate class file for every single button click is highly inefficient. Java provides Inner Classes to solve this.
- Inner Class:
A class defined inside another class. It has access to all variables of the outer class, making it easy to manipulate the GUI from within the handler.public class MyApp extends Application { TextField txt = new TextField(); // Outer class variable // Inner Class implementing EventHandler class MyHandler implements EventHandler<ActionEvent> { public void handle(ActionEvent e) { txt.setText("Button Clicked!"); } } // Usage: btn.setOnAction(new MyHandler()); } - Anonymous Inner Class:
A class without a name, declared and instantiated in a single expression. It is used when a handler class is needed only once. It drastically reduces code size.Button btn = new Button("Click"); // Anonymous Inner Class Handler btn.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent event) { System.out.println("Handled by Anonymous Class!"); } });
Note: In modern Java (Java 8+), Anonymous Inner Classes with single methods are almost entirely replaced by much shorter Lambda Expressions (event -> { ... }).
Unit 4: mouse and key events .
Answer: Beyond standard button clicks (ActionEvent), JavaFX can detect precise hardware interactions from the mouse and keyboard.
1. Mouse Events (javafx.scene.input.MouseEvent):
Fired whenever the user interacts with the mouse. The event object contains details like exact X/Y screen coordinates and which mouse button was pressed (Primary/Secondary).
setOnMouseEntered: Fired when the cursor enters the boundaries of a Node.setOnMouseExited: Fired when the cursor leaves the boundaries.setOnMouseClicked: Fired when a button is clicked and released without moving.
Circle circle = new Circle(50);
// Change color to Red when mouse touches the circle
circle.setOnMouseEntered(e -> circle.setFill(Color.RED));
// Change back to Black when mouse leaves
circle.setOnMouseExited(e -> circle.setFill(Color.BLACK));
2. Key Events (javafx.scene.input.KeyEvent):
Fired when the user presses keys on the keyboard. It is usually attached to the Scene so it works regardless of which button is currently focused.
setOnKeyPressed: Fired when a key is pushed down.setOnKeyReleased: Fired when a key is let go.
Scene scene = new Scene(pane, 400, 400);
scene.setOnKeyPressed(e -> {
// Determine exactly which key was pressed
if (e.getCode() == KeyCode.UP) {
System.out.println("Up arrow pressed!");
} else if (e.getCode() == KeyCode.ENTER) {
System.out.println("Enter key pressed!");
}
});
Unit 4: listeners for observable objects, animation .
Answer:
1. Listeners for Observable Objects:
While Property Binding perfectly links two properties, sometimes you need to execute complex logic (like an if-statement) whenever a property changes. To do this, you attach a ChangeListener to an Observable property. The listener receives the old value and the new value every time a change occurs.
Slider slider = new Slider(0, 100, 50);
// Adding a listener to track the slider's exact value dynamically
slider.valueProperty().addListener((observable, oldValue, newValue) -> {
System.out.println("Slider changed from " + oldValue + " to " + newValue);
});
2. Animation:
JavaFX provides a powerful javafx.animation package to create motion, color changes, and fading effects easily over a specific duration.
- Transitions: Pre-built animations that manipulate specific properties of a Node.
FadeTransition: Changes the opacity (fade in/out).TranslateTransition: Moves a node from X/Y to another X/Y over time.RotateTransition: Spins a node.
- Timeline: Used for complex, free-form animations by defining specific
KeyFramesat specific points in time.
Rectangle rect = new Rectangle(100, 100, Color.BLUE);
// Create a Fade animation lasting 2 seconds
FadeTransition fade = new FadeTransition(Duration.seconds(2), rect);
fade.setFromValue(1.0); // Fully visible
fade.setToValue(0.0); // Completely invisible
fade.setCycleCount(Animation.INDEFINITE); // Loop forever
fade.setAutoReverse(true); // Fade out, then fade back in
fade.play(); // Start the animation
Unit 5: Labeled, Label, Button .
Answer:
1. The Labeled Class:
In JavaFX, Labeled is a base (parent) class. You don't use it directly, but it provides common properties (like text alignment, font, and graphic placement) to all UI controls that display text, such as Labels, Buttons, and CheckBoxes.
2. Label (javafx.scene.control.Label):
A Label is a non-editable text control. Its primary job is to display a short text string, an image, or both to the user. It does not perform any action when clicked; it just sits there for information.
// Creating a Label with text
Label nameLabel = new Label("Enter your name:");
// Changing its font and color
nameLabel.setFont(new Font("Arial", 16));
nameLabel.setTextFill(Color.BLUE);
3. Button (javafx.scene.control.Button):
A Button is an interactive control. It contains text or an image and allows the user to trigger a specific action when they click it. You attach an event handler to it using setOnAction.
Button submitBtn = new Button("Submit");
// Define what happens when the button is clicked
submitBtn.setOnAction(e -> {
System.out.println("Form Submitted Successfully!");
});
Unit 5: Checkbox, Radiobutton .
Answer: Both of these controls allow the user to make choices, but they are used in very different situations.
1. CheckBox:
A CheckBox is used when you want to let the user select multiple options at the same time. Each CheckBox operates independently of the others. It has three states: Checked, Unchecked, and Undefined.
Use Case: Selecting multiple hobbies (e.g., Reading, Traveling, Coding).
CheckBox chkReading = new CheckBox("Reading");
CheckBox chkCoding = new CheckBox("Coding");
// Check if it is selected
if (chkCoding.isSelected()) {
System.out.println("User likes coding.");
}
2. RadioButton:
A RadioButton is used when the user must choose only one option from a list. To enforce this "single-choice" rule, you must group the RadioButtons together using a ToggleGroup. When one is selected, the others in the group are automatically deselected.
Use Case: Selecting Gender (Male/Female/Other) or a Payment Method.
// Create the options
RadioButton rbMale = new RadioButton("Male");
RadioButton rbFemale = new RadioButton("Female");
// Create a ToggleGroup to link them together
ToggleGroup genderGroup = new ToggleGroup();
rbMale.setToggleGroup(genderGroup);
rbFemale.setToggleGroup(genderGroup);
// Set Male as the default selected option
rbMale.setSelected(true);
Unit 5: Textfield, Textarea .
Answer: Text input controls allow the user to type text into your application.
1. TextField:
A TextField allows the user to enter a single line of unformatted text. It is commonly used for short data entry like usernames, search bars, or email addresses. It does not support multiple lines; if the text is longer than the box, it just scrolls horizontally.
TextField usernameField = new TextField();
// Adds ghost text that disappears when typing
usernameField.setPromptText("Enter your Username");
// Getting the data the user typed
String typedName = usernameField.getText();
2. TextArea:
A TextArea allows the user to enter multiple lines of text. It acts like a large text box and is perfect for longer inputs like comments, essays, addresses, or feedback. It automatically provides vertical and horizontal scrollbars if the text exceeds the visible area.
TextArea commentsArea = new TextArea();
commentsArea.setPromptText("Write your feedback here...");
// Set the preferred visible size (rows and columns)
commentsArea.setPrefRowCount(5);
commentsArea.setPrefColumnCount(20);
// Getting the multi-line text
String feedback = commentsArea.getText();
Unit 5: Combobox, Listview .
Answer: Both ComboBox and ListView are used to present a list of items for the user to choose from.
1. ComboBox:
A ComboBox is a drop-down menu. It shows only the currently selected item until the user clicks on it, which then opens a list of options. This saves a lot of screen space. You can also make a ComboBox "editable" so the user can type in their own value if it's not in the list.
ComboBox<String> cityBox = new ComboBox<>();
// Adding items to the dropdown
cityBox.getItems().addAll("Rajkot", "Ahmedabad", "Surat");
// Set a default value
cityBox.setValue("Rajkot");
// Get the selected item
String selectedCity = cityBox.getValue();
2. ListView:
A ListView displays a scrollable list of items permanently visible on the screen. It takes up more space than a ComboBox but allows the user to see many options at once. By default, it allows single selection, but it can be configured to allow multiple selections.
ListView<String> coursesList = new ListView<>();
coursesList.getItems().addAll("Java", "C#", "Python", "C++");
// Allow the user to select multiple items at once
coursesList.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
Unit 5: Scrollbar, Slider .
Answer:
1. Scrollbar:
A ScrollBar is a control used to scroll the viewing area of another component (like moving a long webpage up and down). It consists of a track, a draggable thumb, and increment/decrement arrows. It is rarely used manually; usually, developers wrap their content in a ScrollPane, which handles the scrollbars automatically.
2. Slider:
A Slider is a control that allows the user to select a numeric value by sliding a thumb along a horizontal or vertical track. It is heavily used for settings like volume control, brightness, or selecting an age range. You can set a minimum value, maximum value, and the starting value. You can also show tick marks and labels.
// Create a slider: Min = 0, Max = 100, Starting Value = 50
Slider volumeSlider = new Slider(0, 100, 50);
// Show the tick marks and labels
volumeSlider.setShowTickMarks(true);
volumeSlider.setShowTickLabels(true);
volumeSlider.setMajorTickUnit(10); // Show a label every 10 units
// Read the current value
double currentVolume = volumeSlider.getValue();
Unit 5: Video and Audio .
Answer: JavaFX provides a robust javafx.scene.media package to handle the playback of audio and video files. The architecture relies on three main classes working together:
- 1. Media:
This class represents the actual multimedia file (the raw audio or video data). You create a Media object by providing the file path or URL as a string. It does not play the file; it just loads the data. - 2. MediaPlayer:
This is the "brain" or the controller. It takes theMediaobject and provides the methods to control playback. You use this class toplay(),pause(),stop(), adjust the volume, or loop the media. - 3. MediaView:
This is the visual screen. Because video requires a screen to be seen,MediaViewis a JavaFX Node that you add to your layout panes. It takes theMediaPlayerobject and displays the video frames. (Note: Audio files do not need a MediaView because there is nothing to see).
Code Example for playing a Video:
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.scene.media.MediaView;
// 1. Load the video file
String videoPath = "file:///C:/videos/myvideo.mp4";
Media media = new Media(videoPath);
// 2. Create the player to control the video
MediaPlayer player = new MediaPlayer(media);
// 3. Create the view to display the video on screen
MediaView mediaView = new MediaView(player);
// Optional: Auto-play the video
player.setAutoPlay(true);
// Add the MediaView to your layout pane (e.g., a StackPane)
// stackPane.getChildren().add(mediaView);
No comments:
Post a Comment