java interview questions Flashcards

Question

Can you override static methods in Java?

Answer 1

No. While it is possible to hide the parent static method with a static method of the same signature class, this is not called overriding in the strict sense. This is because, during the run-time, no polymorphism can take place. [source](https://www.turing.com/interview-questions/java)

Answer 2

method1 can only print i and will throw error on printing k because, a non-static variable cannot be accessed from a static method or context. method2 can print both i and k without any errors.

Answer 3

No. While it is possible to hide the parent static method with a static method of the same signature class, this is not called overriding in the strict sense. ``` public class Test { static int i; int k; public static void method1() { System.out.println(i); System.out.println(k); } public static void method2() { } public void method3() { System.out.println(i); System.out.println(k); } } public class Test2 extends Test { public static void method1() { // this is possible } @Override public static void method2() { // this is not possible, it will give error as: static methods cannot be annotated with @override } @Override public void method3() { // this is possible } } ```

Answer 4

ClassLoader is an integral element of the JRE (Java Runtime Environment). The function of the ClassLoader is to dynamically load Java classes directly to the JVM (Java Virtual Machine) during program execution, without notifying the Java run time system. The file to be executed is first loaded by ClassLoaders. Bootstrap, Extension, and Application are the ClassLoaders in Java. This is an advanced Java interview question and answering it can establish your expertise.

Answer 5

A session is any ongoing random conversation between a client and the server. The communication between the two is composed of requests and responses from both sides. There are several ways of managing a session. Applying cookies, using session management API, authenticating the user, hidden fields in HTML, and rewriting URL are some ways of session management. However, the most common way of managing a session is using a session ID when the communication between a client and the server takes place. This Java interview question shows your application orientation to the client.

Answer 6

When we compile our Java program (e.g., using the javac command), we’ll end up with our source code compiled into the binary representation of our code – a JVM bytecode. This bytecode is simpler and more compact than our source code, but conventional processors in our computers cannot execute it. To be able to run a Java program, the JVM interprets the bytecode. Since interpreters are usually a lot slower than native code executing on a real processor, the JVM can run another compiler which will now compile our bytecode into the machine code that can be run by the processor. This so-called just-in-time compiler is much more sophisticated than the javac compiler, and it runs complex optimizations to generate high-quality machine code. [more detailed explaination](https://www.baeldung.com/graal-java-jit-compiler)

Answer 7

Java is a very secure programming language as it is hard to bug or tamper with. It is also very easy to learn and comprehend when developing applications. Most importantly, Java is a self-dependent language that runs on its own JRE platform.

Answer 8

Java is considered platform-independent as it does not depend on any software or hardware. However, it is flexible enough to be run on different platforms with the condition that the platform has a JRE environment installed on it.

Answer 9

The term inheritance occurs when one class in a code extends to another. This means that codes used in one class can be reused in another class.

Answer 10

- Data Hiding: it is a way of restricting the access of our data members by hiding the implementation details. Encapsulation also provides a way for data hiding. The user will have no idea about the inner implementation of the class. It will not be visible to the user how the class is storing values in the variables. The user will only know that we are passing the values to a setter method and variables are getting initialized with that value. - Increased Flexibility: We can make the variables of the class read-only or write-only depending on our requirements. If we wish to make the variables read-only then we have to omit the setter methods like setName(), setAge(), etc. from the above program or if we wish to make the variables write-only then we have to omit the get methods like getName(), getAge(), etc. from the above program - Reusability: Encapsulation also improves the re-usability and is easy to change with new requirements. Testing code is easy: Encapsulated code is easy to test for unit testing. - Freedom to programmer in implementing the details of the system: This is one of the major advantage of encapsulation that it gives the programmer freedom in implementing the details of a system. The only constraint on the programmer is to maintain the abstract interface that outsiders see. [source](https://www.geeksforgeeks.org/encapsulation-in-java/)

Answer 11

The solution to this problem is to use interfaces instead of inheritance. Interfaces allow a class to define multiple behaviors without the need to extend multiple classes.

Answer 12

A block of code used to initialize an object is called a constructor. The constructor must share the same name as the class and it has no return type. Default and parameterized constructors are the two types of constructors.

Answer 13

A new object is created when using new() whereas using literal, the object already existing might return with the same name.

Answer 14

A thread in Java is the direction or path that is taken while a program is being executed. Generally, all the programs have at least one thread, known as the main thread, that is provided by the JVM or Java Virtual Machine at the starting of the program’s execution. At this point, when the main thread is provided, the main() method is invoked by the main thread.

Answer 15

Multi threading in java is simply executing multiple threads in a program. [best video to understand](https://www.youtube.com/watch?v=r_MbozD32eo)

Answer 16

you can implement threads in two ways: 1. By extending `Thread` class 2. By implementing `Runnable` interface

Answer 17

implementing runnable interface is a better choice because, it increases flexibility by letting you add more interfaces to implement in your class. Other classes can also extend your class. Since, java doesn't allow multiple inheritance, extending `Thread` class limits you.

Answer 18

Synchronization in Java is the process that allows only one thread at a particular time to complete a given task entirely. By default, the JVM gives control to all the threads present in the system to access the shared resource, due to which the system approaches race condition. Now, let’s take a real-world example to understand the concept of race condition clearly and how you could avoid the same using Synchronization. Imagine a classroom where three teachers are simultaneously present to teach the same class. In this scenario, the classroom acts as a shared resource, and the three teachers are the threads. All of them can’t teach at the same time. This scenario when looked at in the context of a computer language is referred to as Race Condition, where there are multiple threads present to do a given task. To solve the above problem, we use Synchronization in Java. It is also a good practice especially when the threads update the data concurrently. [source](https://www.simplilearn.com/tutorials/java-tutorial/synchronization-in-java)

Answer 19

Java 8 brought a powerful new syntactic improvement in the form of lambda expressions. A lambda is an anonymous function that we can handle as a first-class language citizen. For instance, we can pass it to or return it from a method. Before Java 8, we would usually create a class for every case where we needed to encapsulate a single piece of functionality. This implied a lot of unnecessary boilerplate code to define something that served as a primitive function representation.

Answer 20

Synchronization in Java is done by using the synchronized keyword. This keyword can be used on top of a method or a block.

Answer 21

There are two types of Synchronization in Java, as mentioned below- Process Synchronization When multiple threads are executed simultaneously process synchronization ensures that they reach a particular state and agree to a certain set of actions. Thread Synchronization When multiple threads want to access the same resource, thread synchronization makes sure that only one thread gains access at a time. [source](https://www.simplilearn.com/tutorials/java-tutorial/synchronization-in-java)

Answer 22

Synchronization helps to execute threads one after another. It also prevents memory constituency errors due to shared access methods.

Answer 23

Java does not use pointers. This is because they are not safe and can increase the complexity of the program. Pointers are the exact opposite of Java’s simplicity.

Answer 24

OOP is an abbreviation for Object-Oriented Programming. It is a model where programs are organized around objects rather than functions and logic. Its main focus is on objects more than using logic and is mainly preferred for large and complex codes.

Answer 25

we can combine the creation and initialization in a single statement; this is where we make use of double braces: ``` @Test public void whenInitializeSetWithDoubleBraces_containsElements() { Set countries = new HashSet() { { add("India"); add("USSR"); add("USA"); } }; assertTrue(countries.contains("India")); } ``` As can be seen from above example, we are: Creating an anonymous inner class which extends HashSet Providing an instance initialization block which invokes the add method and adds the country name to the HashSet Finally, we can assert whether the country is present in the HashSet [source](https://www.baeldung.com/java-double-brace-initialization)

Answer 26

Disadvantages of using double braces are: 1. Obscure, not widely known way to do the initialization 2. It creates an extra class every time we use it Doesn’t support the use of the “diamond operator” – a feature introduced in Java 7 3. Doesn’t work if the class we are trying to extend is marked final 4. Holds a hidden reference to the enclosing instance, which may cause memory leaks 5. It’s due to these disadvantages that double brace initialization is considered as an anti-pattern. [source](https://www.baeldung.com/java-double-brace-initialization)

Answer 27

Composition is a “belongs-to” type of relationship. It means that one of the objects is a logically larger structure, which contains the other object. In other words, it’s part or member of the other object. Alternatively, we often call it a “has-a” relationship (as opposed to an “is-a” relationship, which is inheritance). For example, a room belongs to a building, or in other words a building has a room. So basically, whether we call it “belongs-to” or “has-a” is only a matter of point of view. Composition is a strong kind of “has-a” relationship because the containing object owns it. Therefore, the objects’ lifecycles are tied. It means that if we destroy the owner object, its members also will be destroyed with it. For example, the room is destroyed with the building in our previous example. Note that doesn’t mean, that the containing object can’t exist without any of its parts. For example, we can tear down all the walls inside a building, hence destroy the rooms. But the building will still exist. In terms of cardinality, a containing object can have as many parts as we want. However, all of the parts need to have exactly one container. [source](https://www.baeldung.com/java-composition-aggregation-association)

Answer 28

Aggregation is also a “has-a” relationship. What distinguishes it from composition, that it doesn’t involve owning. As a result, the lifecycles of the objects aren’t tied: every one of them can exist independently of each other. For example, a car and its wheels. We can take off the wheels, and they’ll still exist. We can mount other (preexisting) wheels, or install these to another car and everything will work just fine. Of course, a car without wheels or a detached wheel won’t be as useful as a car with its wheels on. But that’s why this relationship existed in the first place: to assemble the parts to a bigger construct, which is capable of more things than its parts. Since aggregation doesn’t involve owning, a member doesn’t need to be tied to only one container. For example, a triangle is made of segments. But triangles can share segments as their sides. [source](https://www.baeldung.com/java-composition-aggregation-association)

Answer 29

Association is the weakest relationship between the three. It isn’t a “has-a” relationship, none of the objects are parts or members of another. Association only means that the objects “know” each other. For example, a mother and her child. In Java, we can model association the same way as aggregation: ``` class Child {} class Mother { List children; } ``` But wait, how can we tell if a reference means aggregation or association? Well, we can’t. The difference is only logical: whether one of the objects is part of the other or not. Also, we have to maintain the references manually on both ends as we did with aggregation: ``` class Child { Mother mother; } class Mother { List children; } ``` [source](https://www.baeldung.com/java-composition-aggregation-association)

Answer 30

A singleton class is a class that is capable of possessing only one object at a time.

Answer 31

Logging System In a logging system, we may want to have only one instance of the logger, as multiple loggers can cause inconsistent and hard-to-read logs. In this case, we can apply the Singleton pattern to create a single logger instance that can be accessed from different parts of the code. ``` package org.example; public class Logger { private static Logger instance; private Logger() { // private constructor to prevent instantiation from outside the class } public static Logger getInstance() { if(instance == null) { instance = new Logger(); } return instance; } public void log(String message) { // log the message } public static void main(String[] args) { Logger instance1 = Logger.getInstance(); Logger instance2 = Logger.getInstance(); /** * both prints the same instance * org.example.Logger@7cf10a6f * org.example.Logger@7cf10a6f */ System.out.println(instance1); System.out.println(instance2); } } ``` Database Connection In a web application that uses a database, we may want to create a single database connection instance to avoid creating multiple connections that can cause performance issues. By using the Singleton pattern, we can create a single database connection instance that can be shared across the application.

Answer 32

The most popular approach is to implement a Singleton by creating a regular class and making sure it has: a private constructor a static field containing its only instance a static factory method for obtaining the instance ``` package org.example; public class Logger { private static Logger instance; private Logger() { // private constructor to prevent instantiation from outside the class } public static Logger getInstance() { if(instance == null) { instance = new Logger(); } return instance; } public void log(String message) { // log the message } public static void main(String[] args) { Logger instance1 = Logger.getInstance(); Logger instance2 = Logger.getInstance(); /** * both prints the same instance * org.example.Logger@7cf10a6f * org.example.Logger@7cf10a6f */ System.out.println(instance1); System.out.println(instance2); } } ```

Answer 33

The Java string pool is a repository of strings stored in the Java virtual machine (JVM). The pool stores only one instance of each literal string.

Answer 34

JRE has class libraries and other JVM files however, it does not have any tools for Java development such as a debugger and compiler. While JVM has a Just In Time(JIT) tool to convert all the Java codes into compatible machine language.

Answer 35

It's a process of creating multiple method signatures using one method. There are two ways of achieving this i.e changing the return type of the method and varying the number of arguments.

Answer 36

The stages of a thread’s lifecycle are as follows: 1. Newborn state- This is where a new thread is created. In this newborn state, the code has not been run or executed as yet. 2. Runnable state- A thread that is ready to run is put into the runnable state. The code may be running or ready to run at any given time but at this stage, the thread scheduler provides the time for the thread to run. 3. Running state- This stage is when the thread receives a CPU moving from the runnable to the running state. 4. Blocked state- When the thread is inactive for a period of time temporarily, the thread is said to be in a blocked state. 5. Dead state- Also known as the terminated state. This is when the thread has either finished its job and exists or when some unexpected event occurs such as a segmentation fault.

Answer 37

Enumeration also known as enum, is an interface in Java. It allows the sequential access of the elements stored in the collection.

Answer 38

Java packages can be defined as a collection of classes and interfaces which are bundled together while they relate to one another. It also helps developers to group a code for reuse and after being packaged it can be imported in other classes for repurposing.

Answer 39

JPA stands for Java Persistence API. It enables developers to create the persistence layer for desktop/ web applications.

Answer 40

Java is considered as Dynamic because of Byte code [a class file]. A source code written in one platform, that can be executed in any platform. And it also loads the class files at run time. Anything that happens at run time is considered as Dynamic. [source](https://www.tutorialspoint.com/What-is-meant-by-Java-being-a-dynamic-language)

Answer 41

Steps needed to connect to a database in Java are as follows: - Registering the driver class - Creating connection - Creating statement - Executing queries - Closing connects

Answer 42

Serialization is the conversion of the state of an object into a byte stream; deserialization does the opposite. Stated differently, serialization is the conversion of a Java object into a static stream (sequence) of bytes, which we can then save to a database or transfer over a network. [source](https://www.baeldung.com/java-serialization)

Answer 43

The serialization process is instance-independent; for example, we can serialize objects on one platform and deserialize them on another. Classes that are eligible for serialization need to implement a special marker interface, Serializable. Both ObjectInputStream and ObjectOutputStream are high level classes that extend java.io.InputStream and java.io.OutputStream, respectively. ObjectOutputStream can write primitive types and graphs of objects to an OutputStream as a stream of bytes. We can then read these streams using ObjectInputStream. The most important method in ObjectOutputStream is: ``` public final void writeObject(Object o) throws IOException; ``` This method takes a serializable object and converts it into a sequence (stream) of bytes. Similarly, the most important method in ObjectInputStream is: ``` public final Object readObject() throws IOException, ClassNotFoundException; ``` This method can read a stream of bytes and convert it back into a Java object. It can then be cast back to the original object. [source](https://www.baeldung.com/java-serialization)

Answer 44

An array groups data of the same primitive type and is static, while vectors can hold data of different types. Vectors are dynamic though. The Vector class is a thread-safe implementation of a growable array of objects. It implements the java.util.List interface and is a member of the Java Collections Framework. While it’s similar to ArrayList, these classes have significant differences in their implementations. [source](https://www.baeldung.com/java-vector-guide)

Answer 45

The Vector class is designed to function as a dynamic array that can expand or shrink according to the application’s needs. Thus, we can access the objects of the Vector using the indices. Additionally, it maintains the insertion order and stores duplicate elements. Every Vector aims to enhance its storage handling by keeping track of both the capacity and the capacityIncrement. The capacity is nothing but the size of the Vector. The size of the Vector increases as we add elements to it. Therefore, the capacity remains consistently equal to or greater than the Vector‘s size. Every time the length of a Vector reaches its capacity, the new length is calculated: newLength = capacityIncrement == 0 ? currentSize * 2 : currentSize + capacityIncrement Copy Similar to ArrayList, the iterators of the Vector class are also fail-fast. It throws a ConcurrentModificationException if we try to modify the Vector while iterating over it. However, we can access the iterator’s add() or remove() methods to structurally modify the Vector. [source](https://www.baeldung.com/java-vector-guide)

Answer 46

Garbage collection in Java is done automatically by the Java Virtual Machine (JVM) at runtime. The JVM uses a garbage collection algorithm to identify and reclaim memory from objects that are no longer in use.

Answer 47

To create a copy of an object in Java, you can use the clone() method of the Object class. This method creates a shallow copy of the object, meaning that only the object's references are copied, not its values.

Answer 48

Primitives – like int and byte – are always stored and passed as the exact value and not a reference to the value. This is fine because the largest primitive – long – is typically the same amount of memory as the reference would be, and primitives are always immutable, so they can’t be changed anyway. [source](https://www.baeldung.com/cs/deep-vs-shallow-copy)

Answer 49

In some cases, we may want to create a copy of a value so that two different pieces of code see different copies of the same value. This allows one to be manipulated differently from the others, for example. The simplest way to do this is to make a shallow copy of the object. This means we create a new object that contains all the same fields as the original, with copies of the same values. For relatively simple objects, this works fine. However, if our objects contain other objects, then only the reference to these will be copied. This, in turn, means that the two copies contain references to the same value in memory. [source](https://www.baeldung.com/cs/deep-vs-shallow-copy#what-is-a-shallow-copy)

Answer 50

This is where we copy each field from the original to the copy, but as we do so, we perform a deep copy of those instead of just copying the references. This will then mean that the new copy is an exact copy of the original, but in no way connected so that no changes to one will be reflected in the other. [source](https://www.baeldung.com/cs/deep-vs-shallow-copy)

Answer 51

The main difference between stack and queue is that stack is based on LIFO (Last in first out) while a queue is based on FIFO( First in first out) principle. Both are used as placeholders for the collection of data.

Answer 52

Checked exceptions can be caught during the time of program compilation. The checked exceptions must be handled by using the try catch block in the code to successfully compile the code.

Answer 53

Java has its own garbage collection mechanism which destroys automatically objects when they are no longer referenced. Hence no destructors need to be defined.

Answer 54

Yes, it is possible to find the size of an object on the heap in Java. The object size can be calculated by calling the Object.getSize(Object)) method.

Answer 55

Simply put, Java allows us to define classes inside other classes. Nested classes enable us to logically group classes that are only used in one place, write more readable and maintainable code and increase encapsulation. There are several types of nested classes available in the language: Static nested classes Non-static nested classes Local classes Anonymous classes [source](https://www.baeldung.com/java-nested-classes)

Answer 56

Here are a few points to remember about static nested classes: As with static members, these belong to their enclosing class, and not to an instance of the class They can have all types of access modifiers in their declaration They only have access to static members in the enclosing class They can define both static and non-static members Let’s see how we can declare a static nested class: ``` public class Enclosing { private static int x = 1; public static class StaticNested { private void run() { // method implementation } } @Test public void test() { Enclosing.StaticNested nested = new Enclosing.StaticNested(); nested.run(); } } ``` [source](https://www.baeldung.com/java-nested-classes#static-nested-classes)

Answer 57

here are a few quick points to remember about non-static nested classes: They are also called inner classes They can have all types of access modifiers in their declaration Just like instance variables and methods, inner classes are associated with an instance of the enclosing class They have access to all members of the enclosing class, regardless of whether they are static or non-static They can only define non-static members Here’s how we can declare an inner class: ``` public class Outer { public class Inner { // ... } } ``` If we declare a nested class with a modifier static, then it’s a static member one. Otherwise, it’s an inner class. Even though syntactically the difference is just a single keyword (i.e., static), semantically there is a huge difference between these kinds of nested classes. Inner class instances are bound to the enclosing class ones and therefore they have access to their members. We should be aware of this issue when selecting whether to make a nested class be an inner one. To instantiate an inner class, we must first instantiate its enclosing class. Let’s see how we can do that: ``` Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); ``` [source](https://www.baeldung.com/java-nested-classes)

Answer 58

Local classes are a special type of inner classes – in which the class is defined inside a method or scope block. Let’s see a few points to remember about this type of class: They cannot have access modifiers in their declaration They have access to both static and non-static members in the enclosing context They can only define instance members Here’s a quick example: ``` public class NewEnclosing { void run() { class Local { void run() { // method implementation } } Local local = new Local(); local.run(); } @Test public void test() { NewEnclosing newEnclosing = new NewEnclosing(); newEnclosing.run(); } } ``` [source](https://www.baeldung.com/java-nested-classes)

Answer 59

Anonymous classes can be used to define an implementation of an interface or an abstract class without having to create a reusable implementation. Let’s list a few points to remember about anonymous classes: They cannot have access modifiers in their declaration They have access to both static and non-static members in the enclosing context They can only define instance members They’re the only type of nested classes that cannot define constructors or extend/implement other classes or interfaces To define an anonymous class, let’s first define a simple abstract class: ``` abstract class SimpleAbstractClass { abstract void run(); } Now let’s see how we can define an anonymous class: public class AnonymousInnerUnitTest { @Test public void whenRunAnonymousClass_thenCorrect() { SimpleAbstractClass simpleAbstractClass = new SimpleAbstractClass() { void run() { // method implementation } }; simpleAbstractClass.run(); } } ``` [source](https://www.baeldung.com/java-nested-classes)

Answer 60

The declaration of the members of an inner class shadow those of the enclosing class if they have the same name. In this case, the this keyword refers to the instances of the nested class and the members of the outer class can be referred to using the name of the outer class. Let’s see a quick example: ``` public class NewOuter { int a = 1; static int b = 2; public class InnerClass { int a = 3; static final int b = 4; public void run() { System.out.println("a = " + a); // 3 System.out.println("b = " + b); // 4 System.out.println("NewOuterTest.this.a = " + NewOuter.this.a); // 1 System.out.println("NewOuterTest.b = " + NewOuter.b); // 2 System.out.println("NewOuterTest.this.b = " + NewOuter.this.b); //2 } } @Test public void test() { NewOuter outer = new NewOuter(); NewOuter.InnerClass inner = outer.new InnerClass(); inner.run(); } } ``` [source](https://www.baeldung.com/java-nested-classes)

Answer 61

The final keyword in Java is used to indicate that a variable, method, or class cannot be changed or overridden. It is used to create constants that cannot be changed, and to prevent a method from being overridden by a subclass.

Answer 62

Float only takes 4 bytes in memory while double takes twice the bytes as that of a float in memory. Double is also a double-precision decimal number while float is a single-precision floating-point decimal number.

Answer 63

Threads can be created in two ways, by either extending the thread or by implementing the runnable interface.

Answer 64

This error occurs when JVM runs out of memory. OutOfMemoryError is the subclass of Java.lang

Answer 65

If an exception is not caught, it is thrown from the stack and falls down the call stack to the previous procedure. If then it is not caught there, it will fall back again to the previous function. The process repeats until caught or the call stack reaches the bottom.

Answer 66

JCA is an abbreviation of Java Cryptography Architecture and is used by developers to combine it with security applications. It, therefore, gives a platform and provides architecture and application programming interfaces that enable encryption and decryption.

Answer 67

It is an application framework in Java and inversion of control containers of Java. It creates enterprise applications in Java.

Answer 68

Late binding is also known as dynamic binding or run-time binding. Late Binding happens when the method’s code segment is unknown until it is called during the runtime.

Answer 69

The function is faster in Java as the user needs to make a minor update to the pointer value so that the node can point to the next successor in the list.

Answer 70

Java offers two types of threads: user threads and daemon threads. User threads are high-priority threads. The JVM will wait for any user thread to complete its task before terminating it. On the other hand, daemon threads are low-priority threads whose only role is to provide services to user threads. Since daemon threads are meant to serve user threads and are only needed while user threads are running, they won’t prevent the JVM from exiting once all user threads have finished their execution. That’s why infinite loops, which typically exist in daemon threads, will not cause problems, because any code, including the finally blocks, won’t be executed once all user threads have finished their execution. For this reason, daemon threads are not recommended for I/O tasks. However, there’re exceptions to this rule. Poorly designed code in daemon threads can prevent the JVM from exiting. For example, calling Thread.join() on a running daemon thread can block the shutdown of the application. [source](https://www.baeldung.com/java-daemon-thread)

Answer 71

Daemon threads are useful for background supporting tasks such as garbage collection, releasing memory of unused objects and removing unwanted entries from the cache. Most of the JVM threads are daemon threads. [source](https://www.baeldung.com/java-daemon-thread)

Answer 72

To set a thread to be a daemon thread, all we need to do is to call Thread.setDaemon(). In this example, we’ll use the NewThread class which extends the Thread class: ``` NewThread daemonThread = new NewThread(); daemonThread.setDaemon(true); daemonThread.start(); ``` Any thread inherits the daemon status of the thread that created it. Since the main thread is a user thread, any thread that is created inside the main method is by default a user thread. The method setDaemon() can only be called after the Thread object has been created and the thread has not been started. An attempt to call setDaemon() while a thread is running will throw an IllegalThreadStateException: ``` @Test(expected = IllegalThreadStateException.class) public void whenSetDaemonWhileRunning_thenIllegalThreadStateException() { NewThread daemonThread = new NewThread(); daemonThread.start(); daemonThread.setDaemon(true); } ``` [source](https://www.baeldung.com/java-daemon-thread)

Answer 73

to check if a thread is a daemon thread, we can simply call the method isDaemon(): ``` @Test public void whenCallIsDaemon_thenCorrect() { NewThread daemonThread = new NewThread(); NewThread userThread = new NewThread(); daemonThread.setDaemon(true); daemonThread.start(); userThread.start(); assertTrue(daemonThread.isDaemon()); assertFalse(userThread.isDaemon()); } ``` [source](https://www.baeldung.com/java-daemon-thread)

Answer 74

Signed Right Shift [>>] The right shift operator shifts all the bits to the right. The empty space in the left side is filled depending on the input number: When an input number is negative, where the leftmost bit is 1, then the empty spaces will be filled with 1 When an input number is positive, where the leftmost bit is 0, then the empty spaces will be filled with 0 Unsigned Right Shift [>>>] This operator is very similar to the signed right shift operator. The only difference is that the empty spaces in the left are filled with 0 irrespective of whether the number is positive or negative. Therefore, the result will always be a positive integer. [source](https://www.baeldung.com/java-bitwise-operators)

Answer 75

Polymorphism in Java is when we have many forms/classes related to each other by inheritance. A single object can refer to the sub and super class depending on the reference type which is called polymorphism’

Answer 76

An ordered collection means that the elements of the collection have a specific order. The order is independent of the value. A List is an example. A sorted collection means that not only does the collection have order, but the order depends on the value of the element. A SortedSet is an example. In contrast, a collection without any order can maintain the elements in any order. A Set is an example. [source](https://stackoverflow.com/questions/1084146/what-is-the-difference-between-an-ordered-and-a-sorted-collection)

Answer 77

A finally block in Java is a block of code that is always executed after a try/catch block, regardless of whether or not an exception has been thrown.

Answer 78

These are the different types of collectors: Serial Garbage Collector Parallel Garbage Collector CMS Garbage Collector G1 Garbage Collector

Answer 79

System.out is used to display messages and results while System.err is used to display error messages.

Answer 80

Fail-Fast systems abort operation as-fast-as-possible exposing failures immediately and stopping the whole operation. Whereas, Fail-Safe systems don’t abort an operation in the case of a failure. Such systems try to avoid raising failures as much as possible. [source](https://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)

Answer 81

Fail-fast iterators in Java don’t play along when the underlying collection gets modified. Collections maintain an internal counter called modCount. Each time an item is added or removed from the Collection, this counter gets incremented. When iterating, on each next() call, the current value of modCount gets compared with the initial value. If there’s a mismatch, it throws ConcurrentModificationException which aborts the entire operation. Default iterators for Collections from java.util package such as ArrayList, HashMap, etc. are Fail-Fast. ``` ArrayList numbers = // ... Iterator iterator = numbers.iterator(); while (iterator.hasNext()) { Integer number = iterator.next(); numbers.add(50); } ``` In the code snippet above, the ConcurrentModificationException gets thrown at the beginning of a next iteration cycle after the modification was performed. The Fail-Fast behavior isn’t guaranteed to happen in all scenarios as it’s impossible to predict behavior in case of concurrent modifications. These iterators throw ConcurrentModificationException on a best effort basis. If during iteration over a Collection, an item is removed using Iterator‘s remove() method, that’s entirely safe and doesn’t throw an exception. However, if the Collection‘s remove() method is used for removing an element, it throws an exception: ``` ArrayList numbers = // ... Iterator iterator = numbers.iterator(); while (iterator.hasNext()) { if (iterator.next() == 30) { iterator.remove(); // ok! } } iterator = numbers.iterator(); while (iterator.hasNext()) { if (iterator.next() == 40) { numbers.remove(2); // exception } } ``` [source](https://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)

Answer 82

Fail-Safe iterators favor lack of failures over the inconvenience of exception handling. Those iterators create a clone of the actual Collection and iterate over it. If any modification happens after the iterator is created, the copy still remains untouched. Hence, these Iterators continue looping over the Collection even if it’s modified. However, it’s important to remember that there’s no such thing as a truly Fail-Safe iterator. The correct term is Weakly Consistent. That means, if a Collection is modified while being iterated over, what the Iterator sees is weakly guaranteed. This behavior may be different for different Collections and is documented in Javadocs of each such Collection. The Fail-Safe Iterators have a few disadvantages, though. One disadvantage is that the Iterator isn’t guaranteed to return updated data from the Collection, as it’s working on the clone instead of the actual Collection. Another disadvantage is the overhead of creating a copy of the Collection, both regarding time and memory. Iterators on Collections from java.util.concurrent package such as ConcurrentHashMap, CopyOnWriteArrayList, etc. are Fail-Safe in nature. ``` ConcurrentHashMap map = new ConcurrentHashMap<>(); map.put("First", 10); map.put("Second", 20); map.put("Third", 30); map.put("Fourth", 40); Iterator iterator = map.keySet().iterator(); while (iterator.hasNext()) { String key = iterator.next(); map.put("Fifth", 50); } ``` In the code snippet above, we’re using Fail-Safe Iterator. Hence, even though a new element is added to the Collection during the iteration, it doesn’t throw an exception. The default iterator for the ConcurrentHashMap is weakly consistent. This means that this Iterator can tolerate concurrent modification, traverses elements as they existed when Iterator was constructed and may (but isn’t guaranteed to) reflect modifications to the Collection after the construction of the Iterator. Hence, in the code snippet above, the iteration loops five times, which means it does detect the newly added element to the Collection. [source](https://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)

Answer 83

C++, which is based on the C programming language, is compatible with most other high-level languages whereas Java is not compatible with C++.

Answer 84

A copy constructor in a Java class is a constructor that creates an object using another object of the same Java class. That’s helpful when we want to copy a complex object that has several fields, or when we want to make a deep copy of an existing object.

Answer 85

To create a copy constructor, we can first declare a constructor that takes an object of the same type as a parameter: ``` public class Employee { private int id; private String name; public Employee(Employee employee) { } } ``` Then, we copy each field of the input object into the new instance: ``` public class Employee { private int id; private String name; public Employee(Employee employee) { this.id = employee.id; this.name = employee.name; } } ``` What we have here is a shallow copy, which is fine since all of our fields – an int and a String in this case – are either primitive types or immutable types. If the Java class has mutable fields, then we can instead make a deep copy inside its copy constructor. With a deep copy, the newly created object is independent of the original one because we create a distinct copy of each mutable object: ``` public class Employee { private int id; private String name; private Date startDate; public Employee(Employee employee) { this.id = employee.id; this.name = employee.name; this.startDate = new Date(employee.startDate.getTime()); } } ``` [source](https://www.baeldung.com/java-copy-constructor)

Answer 86

The term is a particular word designed as a reference keyword. It is used to refer to the current class properties like method, variable, instance, and constructors

Answer 87

Let’s imagine a scenario where we want to create a list in Java to store Integer. We might try to write the following: ``` List list = new LinkedList(); list.add(new Integer(1)); Integer i = list.iterator().next(); ``` Surprisingly, the compiler will complain about the last line. It doesn’t know what data type is returned. The compiler will require an explicit casting: ``` Integer i = (Integer) list.iterator.next(); ``` No contract could guarantee that the return type of the list is an Integer. The defined list could hold any object. We only know that we are retrieving a list by inspecting the context. When looking at types, it can only guarantee that it is an Object and therefore requires an explicit cast to ensure that the type is safe. This cast can be annoying — we know that the data type in this list is an Integer. The cast is also cluttering our code. It can cause type-related runtime errors if a programmer makes a mistake with the explicit casting. It would be much easier if programmers could express their intention to use specific types and the compiler ensured the correctness of such types. This is the core idea behind generics. Let’s modify the first line of the previous code snippet: ``` List list = new LinkedList<>(); ``` By adding the diamond operator <> containing the type, we narrow the specialization of this list to only Integer type. In other words, we specify the type held inside the list. The compiler can enforce the type at compile time. In small programs, this might seem like a trivial addition. But in larger programs, this can add significant robustness and makes the program easier to read. [source](https://www.baeldung.com/java-generics)

Answer 88

One or more catch blocks can follow a try block, though each catch must have a unique exception handler. Multiple tasks can now be performed using the Java multi-catch block.

Answer 89

Simply put, we can use the super keyword to access the parent class. [source](https://www.baeldung.com/java-super)

Answer 90

Yes, it will print the message because `super()` is used to access the default constructor of the parent class.

Answer 91

Parent class default constructor Hello, from parent class Why the parent class constructor was called? Because that is how Java works. The constructors of the parent classes are called, all the way up the class hierarchy through Object, before the child class's constructor is called. [source](https://stackoverflow.com/questions/34488484/why-is-super-class-constructor-always-called)

Answer 92

The function is faster in Java as the user needs to make a minor update to the pointer value so that the node can point to the next successor in the list.

Answer 93

The interface has only abstract methods in it whereas an abstract class can have both abstract and non-abstract methods.

Answer 94

We define an abstract class with the abstract modifier preceding the class keyword

Answer 95

abstract class

Answer 96

abstract class

Answer 97

abstract class

Answer 98

It’s recommended that all functional interfaces have an informative @FunctionalInterface annotation. This clearly communicates the purpose of the interface, and also allows a compiler to generate an error if the annotated interface does not satisfy the conditions. Any interface with a SAM(Single Abstract Method) is a functional interface, and its implementation may be treated as lambda expressions. Note that Java 8’s default methods are not abstract and do not count; a functional interface may still have multiple default methods.

Answer 99

The most simple and general case of a lambda is a functional interface with a method that receives one value and returns another. This function of a single argument is represented by the Function interface, which is parameterized by the types of its argument and a return value: ``` public interface Function { … } ``` One of the usages of the Function type in the standard library is the Map.computeIfAbsent method. This method returns a value from a map by key, but calculates a value if a key is not already present in a map. To calculate a value, it uses the passed Function implementation: ``` Map nameMap = new HashMap<>(); Integer value = nameMap.computeIfAbsent("John", s -> s.length()); ``` In this case, we will calculate a value by applying a function to a key, put inside a map, and also returned from a method call. We may replace the lambda with a method reference that matches passed and returned value types. Remember that an object we invoke the method on is, in fact, the implicit first argument of a method. This allows us to cast an instance method length reference to a Function interface: ``` Integer value = nameMap.computeIfAbsent("John", String::length); ``` The Function interface also has a default compose method that allows us to combine several functions into one and execute them sequentially: ``` Function intToString = Object::toString; Function quote = s -> "'" + s + "'"; Function quoteIntToString = quote.compose(intToString); assertEquals("'5'", quoteIntToString.apply(5)); ``` The quoteIntToString function is a combination of the quote function applied to a result of the intToString function. [source](https://www.baeldung.com/java-8-functional-interfaces#Functions)

Answer 100

Like regular interface methods, default methods are implicitly public; there’s no need to specify the public modifier. Unlike regular interface methods, we declare them with the default keyword at the beginning of the method signature, and they provide an implementation. Let’s look at a simple example: ``` public interface MyInterface { // regular interface methods default void defaultMethod() { // default method implementation } } ``` The reason why the Java 8 release included default methods is pretty obvious. In a typical design based on abstractions, where an interface has one or multiple implementations, if one or more methods are added to the interface, all the implementations will be forced to implement them too. Otherwise, the design will just break down. Default interface methods are an efficient way to deal with this issue. They allow us to add new methods to an interface that are automatically available in the implementations. Therefore, we don’t need to modify the implementing classes. In this way, backward compatibility is neatly preserved without having to refactor the implementers. [source](https://www.baeldung.com/java-static-default-methods#why-interfaces-need-default-methods)

Answer 101

In Java, default methods in interfaces were introduced in Java 8 to allow the addition of new methods to interfaces without breaking existing implementations. Default methods provide a way to add new functionality to interfaces without requiring all implementing classes to provide an implementation for the new methods. When a new method is added to an interface as a default method, implementing classes that do not override the default method will automatically inherit the default implementation. This ensures backward compatibility because existing classes that implement the interface will still compile and run without modification.

Answer 102

Default interface methods are a pretty nice feature, but there are some caveats worth mentioning. Since Java allows classes to implement multiple interfaces, it’s important to know what happens when a class implements several interfaces that define the same default methods. To better understand this scenario, let’s define a new Alarm interface and refactor the Car class: ``` public interface Alarm { default String turnAlarmOn() { return "Turning the alarm on."; } default String turnAlarmOff() { return "Turning the alarm off."; } } ``` With this new interface defining its own set of default methods, the Car class would implement both Vehicle and Alarm: ``` public class Car implements Vehicle, Alarm { // ... } ``` In this case, the code simply won’t compile, as there’s a conflict caused by multiple interface inheritance (a.k.a the Diamond Problem). The Car class would inherit both sets of default methods. So which ones should we call? To solve this ambiguity, we must explicitly provide an implementation for the methods: ``` @Override public String turnAlarmOn() { // custom implementation } @Override public String turnAlarmOff() { // custom implementation } ``` We can also have our class use the default methods of one of the interfaces. Let’s see an example that uses the default methods from the Vehicle interface: ``` @Override public String turnAlarmOn() { return Vehicle.super.turnAlarmOn(); } @Override public String turnAlarmOff() { return Vehicle.super.turnAlarmOff(); } ``` Similarly, we can have the class use the default methods defined within the Alarm interface: ``` @Override public String turnAlarmOn() { return Alarm.super.turnAlarmOn(); } @Override public String turnAlarmOff() { return Alarm.super.turnAlarmOff(); } ``` It’s even possible to make the Car class use both sets of default methods: ``` @Override public String turnAlarmOn() { return Vehicle.super.turnAlarmOn() + " " + Alarm.super.turnAlarmOn(); } @Override public String turnAlarmOff() { return Vehicle.super.turnAlarmOff() + " " + Alarm.super.turnAlarmOff(); } ``` [source](https://www.baeldung.com/java-static-default-methods#multiple-interface-inheritance-rules)

Answer 103

In addition to declaring default methods in interfaces, Java 8 also allows us to define and implement static methods in interfaces. Since static methods don’t belong to a particular object, they’re not part of the API of the classes implementing the interface; therefore, they have to be called by using the interface name preceding the method name. To understand how static methods work in interfaces, let’s refactor the Vehicle interface and add a static utility method to it: ``` public interface Vehicle { // regular / default interface methods static int getHorsePower(int rpm, int torque) { return (rpm * torque) / 5252; } } ``` Defining a static method within an interface is identical to defining one in a class. Moreover, a static method can be invoked within other static and default methods. Let’s suppose that we want to calculate the horsepower of a given vehicle’s engine. We just call the getHorsePower() method: ``` Vehicle.getHorsePower(2500, 480)); ``` The idea behind static interface methods is to provide a simple mechanism that allows us to increase the degree of cohesion of a design by putting together related methods in one single place without having to create an object. The same can pretty much be done with abstract classes. The main difference is that abstract classes can have constructors, state, and behavior. Furthermore, static methods in interfaces make it possible to group related utility methods, without having to create artificial utility classes that are simply placeholders for static methods. [source](https://www.baeldung.com/java-static-default-methods#static-interface-methods)

Answer 104

Throws can be used to declare multiple exceptions whereas throw can throw one exception at a time

Answer 105

An immutable object is an object whose internal state remains constant after it has been entirely created. This means that once the object has been assigned to a variable, we can neither update the reference nor mutate the internal state by any means.

Answer 106

The key benefits of keeping this class as immutable are caching, security, synchronization, and performance.

Answer 107

The String is the most widely used data structure. Caching the String literals and reusing them saves a lot of heap space because different String variables refer to the same object in the String pool. String intern pool serves exactly this purpose. Java String Pool is the special memory region where Strings are stored by the JVM. Since Strings are immutable in Java, the JVM optimizes the amount of memory allocated for them by storing only one copy of each literal String in the pool. This process is called interning: ``` String s1 = "Hello World"; String s2 = "Hello World"; assertThat(s1 == s2).isTrue(); ``` Because of the presence of the String pool in the preceding example, two different variables are pointing to same String object from the pool, thus saving crucial memory resource. [source](https://www.baeldung.com/java-string-immutable#1-introduce-tostring-pool)

Answer 108

The String is widely used in Java applications to store sensitive pieces of information like usernames, passwords, connection URLs, network connections, etc. It’s also used extensively by JVM class loaders while loading classes. Hence securing String class is crucial regarding the security of the whole application in general. For example, consider this simple code snippet: ``` void criticalMethod(String userName) { // perform security checks if (!isAlphaNumeric(userName)) { throw new SecurityException(); } // do some secondary tasks initializeDatabase(); // critical task connection.executeUpdate("UPDATE Customers SET Status = 'Active' " + " WHERE UserName = '" + userName + "'"); } ``` In the above code snippet, let’s say that we received a String object from an untrustworthy source. We’re doing all necessary security checks initially to check if the String is only alphanumeric, followed by some more operations. Remember that our unreliable source caller method still has reference to this userName object. If Strings were mutable, then by the time we execute the update, we can’t be sure that the String we received, even after performing security checks, would be safe. The untrustworthy caller method still has the reference and can change the String between integrity checks. Thus making our query prone to SQL injections in this case. So mutable Strings could lead to degradation of security over time. It could also happen that the String userName is visible to another thread, which could then change its value after the integrity check. In general, immutability comes to our rescue in this case because it’s easier to operate with sensitive code when values don’t change because there are fewer interleavings of operations that might affect the result. [source](https://www.baeldung.com/java-string-immutable#2-security)

Answer 109

Being immutable automatically makes the String thread safe since they won’t be changed when accessed from multiple threads. Hence immutable objects, in general, can be shared across multiple threads running simultaneously. They’re also thread-safe because if a thread changes the value, then instead of modifying the same, a new String would be created in the String pool. Hence, Strings are safe for multi-threading. [source](https://www.baeldung.com/java-string-immutable#3-synchronization)

Answer 110

As we saw previously, String pool exists because Strings are immutable. In turn, it enhances the performance by saving heap memory and faster access of hash implementations when operated with Strings. Since String is the most widely used data structure, improving the performance of String have a considerable effect on improving the performance of the whole application in general. [source](https://www.baeldung.com/java-string-immutable#5-performance)

Answer 111

The finalize() method is called the finalizer. Finalizers get invoked when JVM figures out that this particular instance should be garbage collected. Such a finalizer may perform any operations, including bringing the object back to life. The main purpose of a finalizer is, however, to release resources used by objects before they’re removed from the memory. A finalizer can work as the primary mechanism for clean-up operations, or as a safety net when other methods fail. [source](https://www.baeldung.com/java-finalize)

Answer 112

Checked Exceptions are a type of Exception that the compiler checks for during the compilation process.

Answer 113

Start() method creates a new thread, while the code inside run() executes in the new thread.

Answer 114

It is not recommended to implement all methods. This is because if one thread accesses the synchronized code then the next thread will have to wait. This will end result in slow performance.

Answer 115

Let’s first understand the serialization before moving to transient as it is used in the context of serialization. Serialization is the process of converting an object into a byte stream, and de-serialization is the opposite of it. When we mark any variable as transient, then that variable is not serialized. Since transient fields aren’t present in the serialized form of an object, the de-serialization process would use the default values (which are null or 0) for such fields when creating an object out of the serialized form.8 The transient keyword is useful in a few scenarios: We can use it for derived fields It is useful for fields that do not represent the state of the object We use it for any non-serializable references When we want to store sensitive information and don’t want to send it through the network [source](https://www.baeldung.com/java-transient-keyword)

Answer 116

The final modifier makes no difference when it has literal initialization. When a variable of type String is declared as final and transient, its value is determined at compile-time and is stored in the class’s constant pool. Since it is final, it’s value can’t be change after it’s initialization. Hence, its value will be taken from the class and not null. [source](https://www.baeldung.com/java-transient-keyword)

Answer 117

In this case, using a new operator to initialize a String will create the object in the Heap memory and the default value for this object when we deserialize will be null. [source](https://www.baeldung.com/java-transient-keyword)

Answer 118

Simply put, we use the serialVersionUID attribute to remember versions of a Serializable class to verify that a loaded class and the serialized object are compatible. The serialVersionUID attributes of different classes are independent. Therefore, it is not necessary for different classes to have unique values. Now, if we change the id, then we would get an exception because: By changing the serialVersionUID of the class, we modified its version/state. As a result, no compatible classes were found during deserialization, and an InvalidClassException was thrown. If serialVersionUID is not provided in a Serializable class, the JVM will generate one automatically. However, it is good practice to provide the serialVersionUID value and update it after changes to the class so that we can have control over the serialization/deserialization process. We’ll take a closer look at it in a later section. [source](https://www.baeldung.com/java-serial-version-uid)

Answer 119

The sleep method is used to sleep the currently executing thread for a given amount of time. Sleep is used to delay the execution period because once the thread wakes up it can move to the runnable state.

Answer 120

Notify() is used to send a signal to wake up a single thread in the waiting pool while notifyAll() sends the signal to wake up all the threads in the waiting pool.

Answer 121

TreeSet maintains the elements in the sorted order. On the other hand, the elements in HashSet are inserted in random order.

Answer 122

Public and private access specifiers are methods and instance variables known as members. Public members are visible in the same package as well as outside whereas private members are visible in the same classes only and not for other classes in the same packages.

Answer 123

As the official documentation suggests, yield() provides a mechanism to inform the “scheduler” that the current thread is willing to relinquish its current use of processor but it’d like to be scheduled back soon as possible. The “scheduler” is free to adhere or ignore this information and in fact, has varying behavior depending upon the operating system. [source](https://www.baeldung.com/java-thread-yield)

Answer 124

This method is used to make the thread wait in the waiting pool. Once executed during the thread execution then instantly the thread gives up the lock on the object and goes into the waiting pool.

Answer 125

Java works only as a “pass by value” as “pass by reference” needs the assistance of pointers. Java does not have pointers.

Answer 126

For a numerical value, it is O, for the boolean value, it is false and NULL value for objects

Answer 127

There are 8 types of primitive data types- int, char, boolean, byte, long, float, short, double.

Answer 128

The size of float and double in java is 32 and 64.

Answer 129

Answer: 2, 4 Widening or Automatic Type Conversion Widening conversion takes place when two data types are automatically converted. This happens when: The two data types are compatible. When we assign a value of a smaller data type to a bigger data type. For Example, in java, the numeric data types are compatible with each other but no automatic conversion is supported from numeric type to char or boolean. Also, char and boolean are not compatible with each other.

Answer 130

24 I will be printed.

Answer 131

This will give compile error - “Lossy conversion from int to short”

Answer 132

Range of byte data in java is -128 to 127. But the byte data type in java is cyclic in nature.

Answer 133

Answer: 120 200 14 016 is an octal number, its equivalent decimal number is 14.

Answer 134

Answer: 2 Arrays are objects in java. It is a container that holds a fixed number of items of a single type.

Answer 135

answer: java.lang.Object

Answer 136

answer: bc str.substring(start, end) returns the string from s[start] till s[end - 1]

Answer 137

Since, t isn’t present in the string str, it returns -1.

Answer 138

replace() replaces all the occurrences of the oldcharacter by the newcharacter.

Answer 139

Using the new keyword creates an object everytime. Hence, 2 objects are created for first two statement. Next, a string is declared which creates another object. For the fourth statement, since, a string ”Interviewbit” already exists, it doesn’t create an additional object again. Hence, answer is 3.

Answer 140

answer: 3.0

Answer 141

in total, three objects are explicitly created using the new keyword, but only two new objects are created in the string pool (due to the use of string literals).

Answer 142

Answer: 2 implicit return type of constructor is the class object in which it is defined.

Answer 143

In the above program, b is a reference of Base type and refers to an abject of Derived class. In Java, functions are virtual by default. So the run time polymorphism happens and derived fun() is called.

Answer 144

Answer: 3. Final methods cannot be overridden.

Answer 145

Answer: 1 Like C++, when a function is static, runtime polymorphism doesn't happen.

Answer 146

Answer: 2 In Java, arrays are objects, they have members like length. The length member is final and cannot be changed. All objects are allocated on heap in Java, so arrays are also allocated on heap.

Answer 147

Answer: 2 The values assigned inside constructor overwrite the values initialized with declaration.

Answer 148

Answer: 4 While it's true that you cannot directly instantiate an abstract class in Java using the new keyword, an abstract class can still have a constructor for several reasons: 1. Initialization: Abstract classes often have fields that need to be initialized when an instance of a concrete subclass is created. The constructor in the abstract class can handle this initialization logic. 2. Code Reusability: An abstract class can contain common functionality that is shared among its subclasses. By providing a constructor in the abstract class, you can centralize common initialization code, reducing redundancy in the code of concrete subclasses. 3. Forcing Initialization: The constructor in an abstract class can enforce certain fields to be initialized, either directly or through method calls. This helps ensure that subclasses adhere to a specific initialization protocol.

Answer 149

Answer: 1 Parameters are passed by value in Java. Hence, swap() method just swapped the values in seperate copies and not the original objects, since references are not passed in java.

Answer 150

There is no error in the program. final variables can be assigned value only once. In the above program, i is assigned a value as 20, so 20 is printed.

Answer 151

Answer: 3 ./Main.java:7: error: show() in Derived cannot override show() in Base public void show() { ^ overridden method is final 1 error

Answer 152

Answer: 1 In Java, a package can be considered as equivalent to C++ language's namespace.

Answer 153

In Java only throwable objects (Throwable objects are instances of any subclass of the Throwable class) can be thrown as exception. So basic data type can no be thrown at all. Following are errors in the above program Main.java:4: error: incompatible types throw 10; ^ required: Throwable found: int Main.java:6: error: unexpected type catch(int e) { ^ required: class found: int 2 errors

Answer 154

Answer: 4 Main.java:12: error: exception Derived has already been caught catch(Derived d) { System.out.println("Caught derived class exception"); }

Answer 155

Answer: 3 Final method can’t be overridden. Thus, an abstract function can’t be final.