6. Java Program Demonstrating Inheritance ‘This unified program cleanly ilustrates Single, Multilevel, and Hierarchical inheritance configurations within a cohesive system design. Java 11. Core Root Superciass Class StaffMember ( intid = 4001; ‘String institution = “KLE Tech*, void processAttendance() { ‘System out printin("Attendance processed successfully in Central HR Ledger"); 12. Subclass representing Single Inheritance (Professor IS-A StaffMember) lass Professor extends StaffMember { String specialization = “Computer Science Engineering"; void conduct ecture() { ‘[Link] printin("Professor is conducting a technical lecture on Java Core Streams."); 113, Grandchild Class representing Multilevel Inheritance (ResearchScholar IS-A Professor) lass ResearchScholar extends Professor { String active Thesis Topic = "Distributed Consensus Optimization over Cloud Infrastructures”; ‘void publishPaper() { ‘[Link] printin(“Publishing peer-reviewed paper on: * + active Thesis Topic); 1/4, Alternative Subciass representing Hierarchical Branching (AdminOficer IS-A StaffMember) Class AdminOfficer extends StaffMember { double operationaiBudgetApprovalLimit = 500000.00; void processProcurement() { System out printin(Reviewing laboratory hardware inventory requests within budget limits.");b plea aceltapeea aes ol « Polymorphic Decoupling: An interface reference variable can point directly to any instance of an class that implements that interface, providing a highly flexible foundation for runtime polymorphism. ¢ Modem Enhancements: Since Java 8, interfaces can contain concrete default methods (allowin optional default implementations without breaking existing subclasses) and static utility methods Syntax Java Public interface Interfaceldentifier { 1 Constant Field Entry DataType CONSTANT_NAME = value; 4 Abstract Method Contract RetumDataTypes methodSignatureName(ParameterList parameters); } Comprehensive Program Java wa. Defining the structural contract interface interface BankAccountContract { double MINIMUM_BALANCE_LIMIT = 1000.00; // Implicitly public static final void depositFunds(double amount); —_// Implicitly public abstract void withdrawFunds(double amount); —_// Implicitly public abstract / Java 8 Default method providing shared fallback functionality default void displayWelcomeBanner() { } [Link] printin("Welcome to the Secure Online Banking Portal System.” 42. Class implementing the interface contract rules class SavingsAccount implements BankAccountContract { private double currentBalance; public SavingsAccount(double initialDeposit) { } [Link] = initialDeposit; @Override Public void depositFunds(double amount) { currentBalance += amount; [Link] printin("Deposited: $" + amount +" | Current Balance: $" + currentBalance); } @Override Public void withdrawFunds(double amount) { if ((currentBalance - amount) < MINIMUM_BALANCE_LIMIT) ( ‘[Link] printin("Transaction Rejected! Violates minimum balance safety limit of $* + MINIMUM_BALANCE_LIMIT); pelse { currentBalance -= amount; [Link] printin(‘Withdrew: $" + amount + "| Current Balance: $" + currentBalance); } } } 1 Execution and testing sandbox public class InterfaceExamDemo { public static void main(Stringl] args) { } } 11 Polymorphic reference assignment BankAccountContract myAccount = new SavingsAccount(2500.00); [Link](); // Executing the default method logic [Link](500.00); 1 Executing subclass override logic [Link](1800.00); Testing constraint logic limits 2. Packages in Java with Examples Definition5 Marks Questions 1. Explain Object-Oriented Programming (OOP) Concepts in Java ‘OOP is a programming paradigm based on the concept of “objects,” which contain data (fields) and code (methods). Java is a prominent object-oriented language that relies on six core pillars: © Glass: A blueprint or template used to create objects. Il defines data members and methods. ® Object: A basic runtime entity, an instance of a clags thal occupies memory, « Encapsulation: Wrapping data (variables) and code (methods) together into a single unit (@.g., & Class). It protects data using private modifiers and provides access via getters/setters. ¢ Inheritance: The mechanism by which one class acquires the properties and behaviors of a parent class using the extends keyword, promoting code reusability. ¢ Polymorphism: The ability of a single function or object to take on multiple forms. It includes Compile-time (Method Overloading) and Runtime (Method Overriding), © Abstraction: Hiding complex implementation details and showing only essential features to the user using abstract classes or interfaces. Example Java # Inheritance and Encapsulation Example class Animal { void eat() { [Link](’ This animal eats food."); } } class Dog extends Animal { // inheritance void sound() { [Link]("The dog barks."); } } public class Main { Publle static void main(String(] args) { Dog myDog = new Dog(); // Object creation [Link](); # Calling Inherited method [Link](): #f Calling own method } } 2. Explain Features of Java Java's features are widely known as the Java Buzzwords. The key features include: «= «Simple: Java syntax Is clean, easy to learn, and removes confusing concepts like explicit pointers, operator overloading, and multiple inheritance (through classes). « Platform Independent & Portable: Java follows the WORA (Write Once, Run Anywhere) philosophy. The compiler converts source code into an Intermediate format called Bytecede, which can run on any machine containing a compatible JVM. * Object-Oriented: Everything in Java Is associated with classes and objects, organizing software as 8 combination of distinct data types and behaviors. « Secure: Java operates inside a virtual machine sandbox. The absence of explicit pointers prevents unauthorized memory access, and the Bytecode Verifier ensures no illegal code runs. « Robust: Java emphasizes early error checking. It provides strong memory management via automatic Garbage Collection, eliminates pointer errors, and handles runtime anomalies using Exception Handling. « Multithreaded: Java supports executing multiple parts of a program concurrently (Threads), maximizing CPU utilization.default: // defaull statements; } Example Java public class DecisionDemo [ public static void main(String() args) { int choice = 2; switch (choice) { case 1: System,out printin("Selected Choice 1°); break: case 2: [Link] printin("Selected Choice 2"); // This executes break: default: [Link] printin(“Invalid Selection"); ) } ) 8. Explain Looping Statements In Java Looping statements are block structures used to repeatedty execute a set of code instructions as long as a Specified control condition remains true. ® for loop: Best used when the number of iterations is known beforehand. « while loop: An entry-controlied loop that tests the condition before executing the body block. ® do-while loop: An exil-controlied loop thal executes the body block af /east once before evaluating the loop condition. Syntax Java it for Loop for (Initialization; condition; incrementidecrement) { // code ) i while Loop while (condition) { // code } 8 do-while Loop do { /! code ) while (condition): Example Java public class LoopDemo { Public static void main(String[] args) ( fi while loop execubon example int count = 1, while (count <= 3) {2. Explain the History and Features of Java in Detail History of Java Java was conceived in 1991 by the Green Team. a small group of engineers led by James Gosling at Sun Microsystems. (1991: Project Green / Oak] ---> [1995 Renamed to Java & Launched] —> [2010. Oracle Acquisition] © Ondgin: Initially targeted al consumer electromecs lke digital cable telewsion set-top boxes. It was first named Oak (after an oak tree outside Gosiing’s office). but was later renamed Java (inspired by Java coffee from Indonesia) due to trademark issues ® The Web Evolution. In 1995. with the exploswe growth of the World Wide Web, Sun shifted Java's focus toward inlemet programmung. mtroducing Applets to run interactive code inside web browsers. ® = Acquistton: Oracte Corporation acquired Sun Mecrosystems in January 2010. taking stewardship of Java's modem platform specificatons Pnmary Features of Java (The Java Buzzwords) « Platform Independent (WORA) Java code compded into platform-neutral Bytecode ( class files), rather than native machine code. Ths bytecode is interpreted by the platform-specific Java Virtual Machine (JVM), enabling the program to run on any architecture without modification. « Simple: The syntax is modeled on C++. bul complex. error-prone features like explicit pointer Manipulation, operator overloading. and structural multple inheritance have been removed. ® Secure: Java applications execute wettun a restncted runtime enwronment (sandbox). The absence of explicit pointers prevents unauthonzed memory corrupbon. while the internal class loaders and bytecode venfiers catch mahcous or malformed code before execution « Robust: Java focuses on rekabulity through compile-tme and runtme error checking. |t features automatic Garbage Collection for dynarmc memory management. which prevents memory leaks, and provides a structured Exception Handling framework to manage runtime faults. «® Object-Onented: Java foliows an object-centnc model where data models are organized into modular classes, supporting reusability. maintenance. and extensibility. ® Multithreaded: The lanquage provides built~an language pomitves for mult-threading. allowing applications to perform concurrent execution tracks smoothly to maximize CPU utilization. « Distributed: Java features robust networkung capabidibes (such as RMI and URL packages) designed to access files and invoke methods over intemet networks as seamlessly as local environments. ® High Performance: While interpreted. modem JVMs utlize a Just-in-Time (JIT) Compiler to cornpile hotspots of bytecode into natiwe mache code at runtme, optimizing execution speeds.6. Explain Constructors and its Types with Examples * Definition of Constructor: A unique member block of code inside a class used exclusively to initialize an object immediately after its creation. * (Critical Ground Rules: © It must match the class name exactly. © Itcannot declare a retum type (not even void). © ILis executed automatically by the runtime engine exactly once during object instantiation. © The Structural Types: © Default / No-Argument Constructor: Takes no parameters. if a developer provides zero constructors, the compiler builds a implicit default variant that resets ail fields to zero/null. ° Parameterized Constructor: Takes explicit arguments used to dynamically customize ‘object initialization fields. Syntax, Java class ClassName ( #4, Default Style ClassName() { 7 initialization logic */ } #2. Parameterized Style ClassName(data_type parameter1, dala_type parameter2) { /* logic */ } } Complete Example Program Java class Course { String courseName; dfNo-Argument Constructor Course() { courseName = “BCA General Foundation”; } Hf Parameterized Constructor Course(String selectedName) { courseName = selectedName: } } public class Academy { public static void main(String(] args) { Course primary = new Course(); H Invokes No-Arg Course specialized = new Course(“Java RMI"); // Invokes Parameterized [Link]("Course 1: " + [Link]), [Link]("Course 2: “ + [Link]); } ) Output: Plaintext Course 1: BCA General Foundation Course 2: Java RMI2. Explain Instance Variables and Methods in Java © Definition of instance Variables: Variables declared inside a class but outside any specific method, constructor, or block. They hold the data values representing an object's state. * Definition of Instance Methods: Functions defined inside a class that operate directly on the instance variables of the object. They implement the object's behaviors. © Key Characteristics: ‘9 Instance flelds/methods belong entirely to a unique abject instance. © Every object gets its awn separate memory copy of instance variables on the heap, © They cannot be accessed without first instantiating an object using the new keyword. Syntax Java class ClassName { Ht instance Variable Declaration access_modifier data_type variable_name; i Instance Method Declaration access_modifier retum_type method_name{parameters) { W/logie using instance variables ) } ‘Complete Example Program Java class BankAccount { Instance Variables String accountHokder; double currentBalance; Hinstance Method void depositFunds(double depositAmount) { currentfsalance += depositAmount; // Modifies instance copy directly System_out printin{accountHolder + * deposited INR * + depositAmount); } ) public class BankingSystem { public static void main(Stringl] args) { BankAccount customer = new BankAccounti); [Link] = "Suresh Kumar", [Link] = 1500.00; [Link] unds(5000.00); ‘[Link] printin(“Updated Ledger Balance: INR * + customer currentBalance| ‘Output Piaintext ‘Suresh Kumar deposited INR 5000.0 ‘Updated Ledger Balance: INR 20000.0 3. Explain Object Creation and Accessing Class Members © Concepts of Object Creation: Instantiating an object requires three essential processing steps exeeuted via the new keyword 4, Declaration: Defining a reference variable of that class type (0.g., Student 5:). 2, instantiation: Using the new keyword to allocate dynamic memory space on the heap. 3. Initialization: Immediately calling the constructor to populate inital data states. © Accessing Class Members: To readiwrite variable attributes or execute class methods outside their source biock, Java utlizes the Dot Operator (. ) as a linker applied directly to the instantiated relerence name Syntax Java 4 Object Allocation Syntax ‘ClassName referenceVarlable = new CiassName(): 4 Class Member Access Syntax [Link] = value; // Accessing variable referenceVariable. methodName(), —_—i/ Accessing method3. Explain Object Creation and Accessing Class Members © Concepts of Object Creation: Instantiating an object requires three essential processing steps executed via the new keyword: 1. Declaration: Defining a reference variable of that class type (e.g., Student s;). 2. Instantiation: Using the new keyword to allocate dynamic memory space on the heap. 3. Initialization: Immediately calling the constructor to populate initial data states. * Accessing Class Members: To read/write variable attributes or execute class methods outside their source biock, Java utilizes the Dot Operator (. } a8 a linkér applied direct to the instantiated reference name. Syntax Java 1! Object Allocation Syntax ClassName referenceVariable = new ClassName(); 1 Class Member Access Syntax [Link] = value; // Accessing variable reference [Link](}; Hf Accessing method Complete Example Program Java class Product { String productName; double preductPrice: void printinvolceDetails() { System. out printin(’Produet: * + productName +" | Cost: INR * + productPrice): } » public class RetailStore { public static vold main{String(] args) { 1 Step 1, 2. 3 combined: Object creation Product item = new Product(); Hf Accessing variables via dot operator [Link] = “Core Java Textbook"; item productPrice = 650.00; 1 Aecessing method via dat operator item printinvoiceDetails(): } } Output: Plaintext Product: Core Java Textbook | Cost: INR 650.0 4. Explain Argument Passing In Java * Definition: Argument passing refers to the mechanism by which values are passed into methods when they are invoked. The Golden Rule: Java is strictly Call-by-Value for all operations. It never handles arguments using call-by-reference. * Behavier on Primitives: When passing primitive data types (like int, double), a distinct snapshot copy of the primitive data value is passed. Changes inside the execution block have zero effect on the caller's scope. * Behavior on Reference Types (Objects): When passing objects, a copy of the heap memory address reference pointer is passed. While you cannot reassign the original pointer to a new object outside, modifying internal variable fields via that address copy alters the original object permanently Syntax / Execution Flow Diagram Plaintext Primitive: Pass Value Copy ----> Changes affect capy only. Reference: Pass Address Copy ---> Changes affect same heap object fields.Eee Definition Inheritance is an object-oriented programming mechanism that allows a newly created class to acquire the properties (variables) and methods of an existing class. It uses the extends keyword to establish an "ISA" relationship. Point-wise Explanation © Code Reusability: The primary purpose of inheritance is to eliminate duplicate code. Common ‘logic is written once in a parent class and reused across many child classes. . Single Inherttance: A setup where a single child class inherits directly from one parent class ($A \Wightarrow BS). © Multilevel Inheritance: A continuous chain of inherttance where @ child class inherits from a parent, which itself acts as.a chid to another class ($A \rightarrow 8 \nightarrow CS). «Hierarchical Inheritance: A structure where muftipie distinc! chad classes inhent from one single parent class ($A \ightarrow BS and SA \nightarrow C$). © Java's Core Exception: Java does not support Multiple Inheritance using classes (¢.9., one child class extending two parent classes) to prevent ambiguity errors like the “Diamond Problem”. Syntax Java class ChildCiass extends ParentCiass { 11 Subclass properties and methods Example Java, class Device { void powerOni) { System out printin Device turing on." } 4 Single tnhentance class Phone extends Device ( void cail() { System out printin("Making a cail_.*): } public class InhertanceTest { Public static void main(String] args) { Phone myPhone = new Phone): [Link](); // Reusing the parent class method [Link]); 1! Using its own unique method 4. Superclass and Subclass Definition @ Superciass (Parent/Base Class): The existing. more generalized class whose variables and methods are innented. ¢ Subclass (Child/Dertved Class): The new, more specific class that inherits features from the superciass. Point-wise Explanation © Conceptual Modeling: The superciass represents a broad, generalized category (e.g... Vehicle), while the subclass represents a highly specific variation of that category (@.g... Car). © Feature Access: The subciass automatcally inherits all public and protected properties and methods belonging to the superciass. © Specialization: A subciass can introduce its own unique fields and methods that do not exist in the parent class. * Modification: A subclass has the freedom to change how an inherited parent method behaves. by overriding it completety.Definition * Method Overloading: Having multiple methods within the same class that share an identical fame but use different parameter signatures. * Method Overriding: Redefining a method inside a subclass that has the exact same signature and retum type as a method in the parent class. Point-wise Explanation * Context Comparison: Overtaading takes place inside a single, isolated class. Overriding cannot exist without @ parent-child relationship (Inheritance Is mandatory). * Signature Comparison: Overloaded methods must vary their parameter configurations (count, types, or sequence). Overidden methods must be mirror copies with the exact samo parameters. * Polymorphism Nature: Overloading represents Compile-Time Polymorphism (Static Binding). Overriding represents Runtime Polymorphism (Dynamic Binding). * Return Type Flexibility: Overloading permits you to freely change method return types. Overriding requires the retum types to be identical (or covariant), Comparison Summary Table Mathod Overloading = Binding Time | Resolved at Compiie-Time. _| Resolved al Runtime. Example Java Method Overriding Across Parent and Child classes. class CalculationDemo [ Ht -- METHOD OVERLOADING — int compute(int a, int b) { retum a + b: ) double compute(double a, double b) { retum a * b; ) // Parameter types differ class Base { ‘void printMsg() { [Link] printin("Base Message"): }2. Constructors and Constructor Overioading Theory & Rules A Constructor is a special block of code structurally similar to a method, invoked automatically when an object of a class is instantiated ‘Strict Rules for Constructors: 1, They must share the exact same name as the class. 2. They must never declare an explicit return type (not even void). 3. They cannot be marked as abstract, static, or final, ‘Types of Constructors © Default / No-Argument Constructor: If you provide no constructor, the Java compiler automatically inserts an empty no-arg constructor to initialize instance variables to their default values (0, null, false). © Parameterized Constructor: Explicitly defined by the developer to accept arguments and initialize instance variables with custom data during object creation. Constructor Overloading This is @ technique where a class contains multiple constructors thal share the same name but feature distinct parameter lists (differing in number, type, or sequence of parameters). It enables the creation of ‘objects in diverse initialization states, Program Example Java class Student { String name; int rollNo; double gpa; 1/1. Default / No-Arg Constructor Student() { name = “Unknown”; rollNo = 0; gpa = 0.0; } 11 2. Parameterized Constructor (Overloaded) Student(String n, int 1) { gpa = 0.0; // Default state for GPA ) 11,3, Parameterized Constructor (Overloaded again) Student(String n, int r, double g) { void display() { ‘[Link] printin("Name: * + name + *, Roll No: * + rollNo + *, GPA: * + gpa): } } public class ConstructorDemo { Public static void main(Stringf) args) { # invokes Constructor 1 Student s1 = new Student); Winvokes Constructor 2 Student 82 = new Student(“Alice”, 101); M Invokes Constructor 3 ‘Student s3 = new Student(“Bob*, 102, 3.9), [Link]();if Orchestration Class public class CentrallnheritanceEngine { public static void main(Stringl] args) { System. out printin(’=== Evaluating Multilevel Inheritance Path ==="); ResearchScholar scholar = new ResearchScholar): [Link] printin("Scholar ID: * + [Link]). # inherited from StaffiMember System. out printin("Department. " + scholarspecialization); / Inherited from Professor scholar, processAttendance(); # Executed from StaffMember [Link](); 4 Executed from Professor scholar. publishPaper(): 4 Native execution System,.outpnntin(\n=== Evaluating Hierarchical Ciass Isolation ==="); AdminOfficer admin = new AdminOfficer(), System. out printin{"Admin ID: " + admin id). if Shared common inheritance root admin. processAttendance(): 4! Reusing base class functionality admin. processProcurement(): it Native administrative functionality # [Link]{); // COMPILE ERROR: Admin class does not inherit Professor features10. Thread Priorities with Example Definition Thread Priorities are integer values assigned to threads that serve as hints to the JVM thread scheduler, indicating how much CPU time to give a thread relative to other active threads. Point-wise Explanation « The Numeric Priority Scale: Priorities are measured on a scale from $1\text{ to }40$ using three built-in constants defined in the Thread class: © Thread.MIN_PRIORITY (Value = $1$) ° Thread.NORM_PRIORITY (Value = $5$, the default starting priority for all threads). © Thread.MAX_PRIORITY (Value = $10$) « Priority Inheritance: When a new thread is spawned, it automatically inherits the priority level of the parent thread that created it. « Scheduler Behavior: The thread scheduler uses a preemplive model, meaning high-priority threads are generally given CPU time slices before lower-priority threads. « Platform Dependency Warming: Thread priorities are treated as suggestions rather than strict tules. The actual execution behavior depends heavily on how the underlying operating system handles thread scheduling, meaning low-priority threads can still run first or experience thread starvation depending on the system layout. Syntax Java [Link](Thread.MAX_PRIORITY); // Elevates priority to 10 Example Java class PriorityWorker implements Runnable { @Override public void runt) { [Link](* Running Thread: * + [Link]().getName() + " | Priority Value Level: " + [Link]().getPriority()); } } public class ThreadPriorityDemo { Public static void main(String[] args) { 1! Set up separate instances of our task worker Thread lowPriorityWorker = new Thread(new PriorityWorker(), “Low_Priority_Task_Node"); Thread highPriorityWorker = new Thread(new PriorityWorker(), "High_Priority_Task_Node"); Ht Assign explicit integer priority levels before starting the threads [Link](Thread.MIN_PRIORITY); i! Priority level = 1 [Link](Thread. MAX_PRIORITY); #/ Priority level = 10 # Start both threads in parallel [Link](); [Link]();8. Explain Main Thread in Java Definition The Main Thread is the primary line of execution automatically created and launched by the Java Virtual Machine (JVM) the moment a program starts up. It serves as the root controller fram which all application threads are spawned. Point-wise Explanation *® The Entry Point: The main thread is automatically assigned to execute the program's pu static void main(String[] args) method. e Automatic Spawn: You don't need to write any cade to create the main thread; the JVM handles it automatically as soon as the application boots up. « Parent Architecture Control: It acts as the manager for your program's thread structure. If you need to spawn background worker threads, you write the initialization code within the main thread's execution flow e Shutdown Operations: By default, the main thread handles any final cleanup operations and terminates once the main) method finishes executing, as long as there are no other active user threads running in the background. Syntax Reference Java /! Querying access properties of the main thread context Thread mainPtr = Thread. currentThread({}; Example Java public class MainThreadDemo { public static void main(String[] args} { // Get a reference to the currently executing thread Thread mainThread = [Link]{); // Display properties of the automatically generated main thread [Link]("Thread Identifier Name: "+ [Link]()); Ya [Link]("Thread Execution Priority: " + [Link]()): 2 // Altering properties within the main thread context [Link]("Primary_Orchestration_Thread"}; [Link]("Updated Thread Identifier Name: ”" + [Link]()); }* Implicit Modifiers: To avoid boilerplate code, the Java compiler automatically applies modifiers behind the scenes: © All variables are implicitly public static final (compile-time constants). © All standard methods are implicitly public abstract (signatures only). e Solving Multiple Inheritance: Java classes are structurally blocked from extending more than one parent class to prevent ambient inheritance conflicts (the Diamond Problem). Interfaces cleanly bypass this constraint because a class can implement an unlimited number of interfaces simultaneously. ® Polymorphic Decoupling: An interface reference variable can point directly to any instance of any class that implements that interface, providing a highly flexible foundation for runtime polymorphism, e Modem Enhancements: Since Java 4, interfaces can contain concrete default methods {allowing optional default implementations without breaking existing subclasses) and static utility methods. Syntax Java public interface Interfaceldentifier { # Constant Field Entry DataType CONSTANT_NAME = value; # Abstract Method Contract RetumDataTypes methodSignatureName(ParameterList parameters); } Comprehensive Program Java #11. Defining the structural contract interface interface BankAccountContract { double MINIMUM_BALANCE_LIMIT = 1000.00; // Implicitly public static final void depositFunds(double amount); if implicitly public abstract void withdrawFunds(double amount); —_// Implicitly public abstract # Java 8 Default method providing shared fallback functionality default void displayWelcomeBanner() { System, out printin("Welcome to the Secure Online Banking Portal System."); } } 42. Class implementing the interface contract rules class SavingsAccount implements BankAccountContract { private double currentBalance; public SavingsAccount(double initialDeposit) { [Link] = initialDeposit; } @Override public void depositFunds(double amount) { currentBalance += amount; [Link]("Deposited: $" + amount + "| Current Balance: $" + currentBalance),