Java Mid-Sem Exam Prep: 200 Questions
Uploaded by
harshyjethwa2020Java Mid-Sem Exam Prep: 200 Questions
Uploaded by
harshyjethwa2020Common questions
Powered by AIIn Java, the scope of a variable is determined by the block in which it is declared, which dictates where in the code the variable can be accessed. The lifetime of a variable refers to the duration during which the variable is valid and retains memory allocation. Local variables are declared inside methods or blocks and their scope is limited to that block, starting at the point of declaration and lasts until the end of the block . For example: ```java public void exampleMethod() { int localVar = 10; // Scope limited to exampleMethod // localVar accessible here } // localVar not accessible here ``` Instance variables are declared in a class outside any method and their scope extends throughout the class. They exist as long as the class object exists . ```java class Example { int instanceVar = 20; // Scope throughout the class } ``` Static variables also have class-level scope and remain for the entire duration of the application, shared among all instances of a class .
Java is considered an internet-enabled language due to several features. One of the main features is platform independence facilitated by the Java Virtual Machine (JVM) which allows Java applications to be executed on any machine that has a JVM installed, regardless of the underlying hardware . Furthermore, Java applets can be embedded in web pages to provide interactive features in a browser environment, making Java a popular choice for web applications . Additionally, Java includes a library (java.net package) that simplifies the creation of network connections allowing applications to communicate over the internet or an intranet with ease . These characteristics, among others, make Java widely used for web-based applications.
Java supports polymorphism, which refers to the ability of a single function, method, or operator to operate in different ways based on the context, through two main forms: compile-time (method overloading) and runtime (method overriding) polymorphism . Method overloading allows different methods to have the same name with different parameters, while method overriding occurs when a subclass provides a specific implementation of a method already defined in its superclass. Here's an example to illustrate both types: Compile-time polymorphism (Overloading): ```java class Display { void show(int a) { System.out.println("Integer: " + a); } void show(String b) { System.out.println("String: " + b); } } ``` Runtime polymorphism (Overriding): ```java class Animal { void sound() { System.out.println("Animal sound"); } } class Dog extends Animal { void sound() { System.out.println("Bark"); } } public class TestPolymorphism { public static void main(String args[]) { Animal a = new Dog(); a.sound(); // Outputs "Bark" because Dog's sound method is called } } ``` .
In Java, arrays are objects stored in heap memory and they consist of contiguous memory locations where each element can be accessed using an index. The reference to the array object is stored in the stack memory while the actual array data is stored in heap memory . This setup implies that operations on arrays can be efficient in terms of accessing elements due to their arranged contiguous memory, enabling quick access via indices. However, since arrays in Java are fixed in size upon initialization, developers need to be mindful of the allocated array size memory requirements and potential issues with memory fragmentation over time if arrays are frequently resized or new ones created .
The 'final' keyword in Java serves different purposes depending on its application context. When applied to a variable, it means that the variable's value cannot be changed once it is initialized, effectively making it a constant. For methods, 'final' means the method cannot be overridden by subclasses, ensuring that the original method implementation is preserved . When applied to a class, 'final' means the class cannot be subclassed, which is useful for creating immutable classes or preventing method overriding . For example: - Final variable: `final int MAX = 100;` - Final method: ```java class Base { final void display() { System.out.println("Base display"); } } ``` - Final class: `final class Immutable { ... }` By employing 'final', Java enhances security, prevents misuse of inheritance, and can potentially allow performance optimizations by the compiler .
The JVM (Java Virtual Machine) is an abstract machine that enables a computer to run Java programs as well as programs written in other languages that are also compiled to Java bytecode . The JRE (Java Runtime Environment) is a software package that provides the libraries, Java Virtual Machine, and other components necessary for running Java applications . The JDK (Java Development Kit) is a full-featured software development kit for developing Java applications and applets; it includes JRE and development tools like compilers and debuggers . In summary, JVM executes code, JRE provides runtime environment, and JDK provides both tools for development and a runtime environment.
Encapsulation in Java is a fundamental concept of object-oriented programming that involves binding data and the methods that manipulate that data within a single unit, typically a class. This is achieved using access modifiers to restrict access to certain components of an object, thereby protecting the data from unauthorized access and modification . For example, in a Java class, variables are declared private and public getter and setter methods are provided to control and validate data being accessed and modified. Consider the following code: ```java public class EncapsulationExample { private int age; // private variable // public getter method public int getAge() { return age; } // public setter method public void setAge(int age) { if(age > 0) { // simple validation this.age = age; } } } ``` . This example demonstrates encapsulation by controlling access to the age variable through methods, thus enhancing security and data integrity.
Garbage collection in Java is the process by which the Java runtime environment reclaims memory from objects that are no longer in use, thereby preventing memory leaks and optimizing memory utilization . This process automatically manages memory, reduces programmer's task of manual memory management, and helps in avoiding issues such as dangling pointers and memory corruption . The Java Virtual Machine performs garbage collection automatically using a mark-and-sweep algorithm, among other strategies, identifying objects that can no longer be reached from any live references and removing them . The benefits include improved application performance, automatic memory management, and reduced risk of memory-related errors.
Casting in Java is the process of converting a variable from one data type to another. Implicit casting (or widening conversion) happens when a smaller data type is converted to a larger data type automatically, such as int to long. This is safe as it doesn’t lead to data loss . For example: ```java int a = 10; long b = a; // implicit casting ``` Explicit casting (or narrowing conversion), on the other hand, involves converting a larger data type into a smaller data type and requires explicit mention by the programmer, which can lead to data loss if the value is too large to be represented by the new type . For example: ```java long a = 100L; int b = (int) a; // explicit casting ``` Explicit casting needs to be handled with care as it might lead to unexpected results if data is lost during the conversion process.
Runtime polymorphism in Java is achieved through method overriding, where a subclass provides a specific implementation of a method that is already defined in its superclass. This allows the method to be called based on the actual type of the object that the reference variable is pointing to, not the type it was declared as. This enables dynamic method dispatch, where the call to an overridden method is resolved at runtime . Here is an example demonstrating this: ```java class Animal { void sound() { System.out.println("Animal sound"); } } class Dog extends Animal { @Override void sound() { System.out.println("Bark"); } } public class TestPolymorphism { public static void main(String[] args) { Animal myDog = new Dog(); myDog.sound(); // Outputs "Bark" due to runtime polymorphism } } ``` In the example, though the reference variable is of type Animal, the actual object is of class Dog. Thus, the Dog's version of the sound() method is executed .