|
Q:
|
What
if the main method is declared as private? |
|
A:
|
The
program compiles properly but at runtime it will give "Main method not
public." message.
|
|
Q:
|
What if the static modifier is removed
from the signature of the main method? |
|
|
A:
|
Program
compiles. But at runtime throws an error "NoSuchMethodError".
|
|
|
|
|
|
|
Q:
|
What
if I write static public void instead of public static void? |
|
|
A:
|
Program
compiles and runs properly.
|
|
|
|
|
|
|
Q:
|
What
if I do not provide the String array as the argument to the method? |
|
|
A:
|
Program
compiles but throws a runtime error "NoSuchMethodError".
|
|
|
|
|
|
|
Q:
|
If I do not provide any arguments on the
command line, then the String array of Main method will be empty or null? |
|
|
A:
|
It
is empty. But not null.
|
|
|
|
|
|
|
Q:
|
What environment variables do I need to
set on my machine in order to be able to run Java programs? |
|
|
A:
|
CLASSPATH
and PATH are the two variables.
|
|
|
|
|
|
|
Q:
|
Can
I have multiple main methods in the same class? |
|
|
A:
|
No
the program fails to compile. The compiler says that the main method is
already defined in the class.
|
|
|
|
|
|
|
Q:
|
Do I need to import java.lang package any
time? Why ? |
|
|
A:
|
No.
It is by default loaded internally by the JVM.
|
|
|
|
|
|
Class path
Running a Java program requires all third party supporting libraries to be in the class path. This can be an obstacle to portability, because its syntax is platform-specific: Windows-based systems use backslashes to mark subdirectories and semicolons to separate entries, whereas all other platforms use forward slashes to mark subdirectories and colons to separate entries.
It is also necessary for each .jar or .zip
archive required to be explicitly named in the class path. Java provides a way
around this by allowing directories listed in the class path to end in an
asterisk (*), which will be expanded to the names of all files ending in .jar
or .JAR within the directory. However, such an entry does not match .zip or
.class files within that directory.
License
Sun Java's proprietary nature gave it a controversial position in the free software community. Because Sun's implementation of Java was not free software, it could not be included in projects that require a free software or GPL-compatible license, such as Debian main, the $100 laptop, and Fedora Core. Sun announced in JavaOne 2006 that Java will become open source software. The statement was issued by Sun Software Executive Vice President Rich Green: "It's not a question of whether, it's a question of how, and so we'll go do this."
In July 2006, Sun's CTO Robert Brewin commented that Java
will be partially open source by June 2007 but the entire platform will
take more time to be fully open source. On November 13, 2006, Sun announced
that its standard edition Java runtime environment will be released under the
GPL by March of 2007. Its source code will be available under the GPL.
According to Richard Stallman, this will mean an end to the Java trap. Mark
Shuttleworth called the initial press announcement "a real milestone for
the free software community."License
Sun Java's proprietary nature gave it a controversial position in the free software community. Because Sun's implementation of Java was not free software, it could not be included in projects that require a free software or GPL-compatible license, such as Debian main, the $100 laptop, and Fedora Core. Sun announced in JavaOne 2006 that Java will become open source software. The statement was issued by Sun Software Executive Vice President Rich Green: "It's not a question of whether, it's a question of how, and so we'll go do this."
Resource management
While Java does manage memory, it does not manage all resources, such as JDBC database connections; these must be released just as memory would need to be in C++.
Memory management
Java takes care of memory management. This was done as it makes it harder (but not impossible) for the programmer to create problems such as memory leaks. Java always allocates objects on the heap (unless optimized to the stack or registers by the JIT compiler) and local variables on the stack or in registers. This makes Java less flexible than C++, which allows programmers to choose where objects are allocated.
The garbage collector controls when objects are deleted from memory.
Java does not allow programmers to guarantee when garbage collection happens
(even with System.gc()), they cannot hold off garbage collection, and they
cannot delete one particular object. While this makes programming much simpler
and reduces memory leaks, it lacks the flexibility that can, in some cases,
result in a more efficient handling of memory. Lower-level languages such as C
or assembly language provide this flexibility.
While many programs, such as those written in C++, tend to fall prey to memory leaks, this is not the whole story. Other resource leaks such as file handles, database and network connections are still likely, especially when exceptions are thrown. However, where C++ has the RAII idiom to address both cases, Java programmers need to remember to release resources in finally clauses and must have a good understanding of which resources Java will release and which they must release.
Primitives vs. objects / Autoboxing
Java designers decided not to implement certain features present in other languages (including multiple inheritance, operator overloading, and tuples).
When generics were added to Java 5.0, there was already a large framework of classes (many of which were already deprecated), so generics were chosen to be implemented using erasure to allow backwards compatibility and preservation of these existing classes. This limited the features that could be provided by this addition as compared to other languages.
Java's primitive types are not objects. Primitive types hold their values in the stack rather than being references to values. This was done for performance reasons. Because of this, Java is not considered to be a pure object-oriented programming language and this makes reflection more complicated. However, Java 5.0 supports automatic conversion (autoboxing) of primitive data types to corresponding object form wherever required, during compilation. When autounboxing, a null pointer exception may be thrown. Since this operation occurs implicitly (without a cast or method call), this unchecked exception may not be obvious by inspection of the line of code.
Non-Virtual methods
Java provides no way to make methods non-virtual (although they can be "sealed" by using the final modifier to disallow overriding). This means that there is no way to let derived classes define a new, unrelated method with the same name. This can be a problem when a base class is designed by a different person, and a new version introduces a method with the same name and signature as some method already present in the derived class. This means that the method in the derived class will implicitly override the method in the base class, even though that was not the intent of the designers of either class. To partially accommodate for these versioning problems, Java 5.0 introduced the @Override annotation, but to preserve backwards compatibility it could not be made compulsory by default.
Single paradigm
Java is predominantly a single-paradigm language. The addition of static imports in Java 5.0 accommodates the procedural paradigm better than earlier versions of Java.
Exception handling
Java embraced the concept of exception specifications from C++ where they were optional, but made throws clauses mandatory for any checked exception. While this can be a benefit for small systems, there is not universal agreement that using checked exceptions is a benefit for larger systems. In particular, "higher level" code is often not interested in errors thrown by "lower level" code (eg: NamingException). The coder of the naming classes must make a choice: either force higher level code to deal with naming exceptions as checked exceptions, or allow them to "bubble up" through his own low-level code without compile-time checks.
Closure
Finally, while anonymous inner classes provide a basic form of closures, they are not complete and require referenced variables to either be class fields or declared "final". The rationale behind this is that it allows JVM implementors to choose a stack model for variable lifetimes, so that a variable scope is removed when exited, thus preventing real closures. In addition, when using - for instance - "Runnable" as a closure, one has to declare the "run" method and put the code in that: you cannot simply put some code in braces and pass it around.
Floating point arithmetic
While Java's floating point arithmetic is largely based on IEEE 754 (Standard for Binary Floating-Point Arithmetic), certain features are not supported even when using the "strictfp" modifier, such as Exception Flags and Directed Roundings — capabilities mandated by IEEE Standard 754. Many so-called "Java gotchas" are not problems with Java per se, but problems that are inevitable whenever using floating point arithmetic.
Look and feel
The look and feel of GUI applications written in Java using the Swing platform is often different from native applications. While programmers can choose to use the AWT toolkit that displays native widgets (and thus look like the operating platform), the AWT toolkit is unable to meet advanced GUI programming needs by wrapping around advanced widgets and not sacrificing portability across the various supported platforms, each of which have vastly different APIs especially for higher-level widgets.
The Swing toolkit--written completely in Java--both creates the problem of having a different look and feel from native applications, and avoids the problem of being limited by native toolkit capabilities because it reimplements widgets using only the most basic drawing mechanisms that are guaranteed available on all platforms. Unfortunately, the default installations of the JRE (as of August 2006) do not use the system's "native" look and feel, instead defaulting to the built-in Metal Look and Feel. If the programmer doesn't take care to set the native look and feel, users will have applications whose appearance is vastly different from that of their native applications. Apple Computer's own optimized version of the Java Runtime, which is included within the Mac OS X distribution, by default does set the default and implements its "Aqua" look-and-feel, giving Swing applications on the Macintosh a similar appearance to native software. Even in this environment, the programmer must still do some extra work to ensure that that application looks like an Aqua one (for example, they must set system properties to ensure the menubar is rendered in the OS X menubar and not in the application window as it would be on other platforms).
Performance
It is impossible to make any generalization about the performance of Java programs, because runtime performance is affected much more by the quality of the compiler or JVM than by any intrinsic properties of the language itself. Java bytecode can either be interpreted at run time by a virtual machine, or it can be compiled at load time or runtime into machine code which runs directly on the computer's hardware. Interpretation is slower than native execution, and compilation at load time or runtime has an initial performance penalty for the compilation.
Lack of language features
There are a few language requirements which incur an unavoidable time penalty, although these features are not unique to Java. Among these are array bounds checking, run-time type checking, and virtual function indirection (although each of these can in some situations be avoided by an optimizing compiler). Also the lack of features can affect performance. For example, Java does not have arrays of structures or a true multi-dimensional array, but only an array of references to objects or further arrays. Nor does Java allow returning more than one value from a function without using an object. The net result is that Java code makes more heap allocations than well-written code in some other languages.
Garbage collection
The use of a garbage collector to automatically delete objects adds overhead compared to manual deallocation and can have a positive or negative impact, or no discernible impact at all, on performance depending upon the garbage collector implementation and the characteristics of the application's use of objects. With the modern generational garbage collectors used in many JVMs, many applications actually experience greater performance because of faster allocation and deallocation algorithms.
Byte code vs. native compilation
Relative performance of JIT compilers as compared to native compilers can be quite close, and is often a subject of debate. The JIT compilation stage may be time consuming, which is inconvenient for applications that are short-lived and/or contain large amounts of code. Once compiled to native code, however, the performance of the program can be comparable to that achieved by a native compiler, even on numerical tasks. Although Java does not support manual inlining of method calls, many JIT compilers perform this optimization at load time and can exploit information from the runtime environment to guide more effective transformations, such as profile-directed inlining. Dynamic recompilation, as provided by Sun's HotSpot JVM, can exceed the performance of the static compilation available in most other languages by exploiting information that is only available at runtime.
Hardware interfacing
Because Java was designed with an emphasis on security and portability, it does not support direct access to the machine architecture and address space. This means working directly with a specific piece of hardware such as a scanner, digital camera, audio recorder, video capture, or virtually any hardware that requires direct memory space control (typically those pieces or hardware installed with drivers), cannot easily be accomplished with Java. An illustration of this issue is seen in version 1.0 of Java as it was not possible to access a printer because the interface code to the various printer drivers was not included in this first JVM.
Interfacing with native code
Clients side or server systems that need to "talk" to the hardware must implement a hybrid solution using Java and C/C++ or assembly language via the Java Native Interface (JNI) libraries to link native code to the Java libraries. An alternate solution is to code the hardware software component in its native C/C++/assembler language and then pass the data via files, databases or a shared memory interface, although this is not an ideal solution.
Using the JNI technique introduces many possible inconsistencies such as: machine dependency, potential deadlock situations, memory allocation leaks, and possibly poor application performance, not to mention code complexity of needing to maintain two different code bases. However, it must be noted that it is a common case for other Virtual machine languages, as for example the .NET Framework Common Language Runtime (see Platform Invocation Services).
Inconsistent JVM implementations
Java is a bytecode language that runs on top of the JVM; ultimately the compatibility of the language and the ability to have it run across different platforms is dependent on the stability and version of the JVM. While Java is touted as running on a large variety of systems, the most up to date JVM (and JRE) are only those actively updated for Windows, Linux and Solaris. HP (such as Java for HP-UX) and IBM (for MVS, AIX, OS/400) provide their own implementations for their family of platforms but do not always mirror the latest Sun releases. Other JVM implementations usually follow, but sometimes lag in months or years with the more common implementations and therefore introduce compatibility issues.
While many programs, such as those written in C++, tend to fall prey to memory leaks, this is not the whole story. Other resource leaks such as file handles, database and network connections are still likely, especially when exceptions are thrown. However, where C++ has the RAII idiom to address both cases, Java programmers need to remember to release resources in finally clauses and must have a good understanding of which resources Java will release and which they must release.
Primitives vs. objects / Autoboxing
Java designers decided not to implement certain features present in other languages (including multiple inheritance, operator overloading, and tuples).
When generics were added to Java 5.0, there was already a large framework of classes (many of which were already deprecated), so generics were chosen to be implemented using erasure to allow backwards compatibility and preservation of these existing classes. This limited the features that could be provided by this addition as compared to other languages.
Java's primitive types are not objects. Primitive types hold their values in the stack rather than being references to values. This was done for performance reasons. Because of this, Java is not considered to be a pure object-oriented programming language and this makes reflection more complicated. However, Java 5.0 supports automatic conversion (autoboxing) of primitive data types to corresponding object form wherever required, during compilation. When autounboxing, a null pointer exception may be thrown. Since this operation occurs implicitly (without a cast or method call), this unchecked exception may not be obvious by inspection of the line of code.
Non-Virtual methods
Java provides no way to make methods non-virtual (although they can be "sealed" by using the final modifier to disallow overriding). This means that there is no way to let derived classes define a new, unrelated method with the same name. This can be a problem when a base class is designed by a different person, and a new version introduces a method with the same name and signature as some method already present in the derived class. This means that the method in the derived class will implicitly override the method in the base class, even though that was not the intent of the designers of either class. To partially accommodate for these versioning problems, Java 5.0 introduced the @Override annotation, but to preserve backwards compatibility it could not be made compulsory by default.
Single paradigm
Java is predominantly a single-paradigm language. The addition of static imports in Java 5.0 accommodates the procedural paradigm better than earlier versions of Java.
Exception handling
Java embraced the concept of exception specifications from C++ where they were optional, but made throws clauses mandatory for any checked exception. While this can be a benefit for small systems, there is not universal agreement that using checked exceptions is a benefit for larger systems. In particular, "higher level" code is often not interested in errors thrown by "lower level" code (eg: NamingException). The coder of the naming classes must make a choice: either force higher level code to deal with naming exceptions as checked exceptions, or allow them to "bubble up" through his own low-level code without compile-time checks.
Closure
Finally, while anonymous inner classes provide a basic form of closures, they are not complete and require referenced variables to either be class fields or declared "final". The rationale behind this is that it allows JVM implementors to choose a stack model for variable lifetimes, so that a variable scope is removed when exited, thus preventing real closures. In addition, when using - for instance - "Runnable" as a closure, one has to declare the "run" method and put the code in that: you cannot simply put some code in braces and pass it around.
Floating point arithmetic
While Java's floating point arithmetic is largely based on IEEE 754 (Standard for Binary Floating-Point Arithmetic), certain features are not supported even when using the "strictfp" modifier, such as Exception Flags and Directed Roundings — capabilities mandated by IEEE Standard 754. Many so-called "Java gotchas" are not problems with Java per se, but problems that are inevitable whenever using floating point arithmetic.
Look and feel
The look and feel of GUI applications written in Java using the Swing platform is often different from native applications. While programmers can choose to use the AWT toolkit that displays native widgets (and thus look like the operating platform), the AWT toolkit is unable to meet advanced GUI programming needs by wrapping around advanced widgets and not sacrificing portability across the various supported platforms, each of which have vastly different APIs especially for higher-level widgets.
The Swing toolkit--written completely in Java--both creates the problem of having a different look and feel from native applications, and avoids the problem of being limited by native toolkit capabilities because it reimplements widgets using only the most basic drawing mechanisms that are guaranteed available on all platforms. Unfortunately, the default installations of the JRE (as of August 2006) do not use the system's "native" look and feel, instead defaulting to the built-in Metal Look and Feel. If the programmer doesn't take care to set the native look and feel, users will have applications whose appearance is vastly different from that of their native applications. Apple Computer's own optimized version of the Java Runtime, which is included within the Mac OS X distribution, by default does set the default and implements its "Aqua" look-and-feel, giving Swing applications on the Macintosh a similar appearance to native software. Even in this environment, the programmer must still do some extra work to ensure that that application looks like an Aqua one (for example, they must set system properties to ensure the menubar is rendered in the OS X menubar and not in the application window as it would be on other platforms).
Performance
It is impossible to make any generalization about the performance of Java programs, because runtime performance is affected much more by the quality of the compiler or JVM than by any intrinsic properties of the language itself. Java bytecode can either be interpreted at run time by a virtual machine, or it can be compiled at load time or runtime into machine code which runs directly on the computer's hardware. Interpretation is slower than native execution, and compilation at load time or runtime has an initial performance penalty for the compilation.
Lack of language features
There are a few language requirements which incur an unavoidable time penalty, although these features are not unique to Java. Among these are array bounds checking, run-time type checking, and virtual function indirection (although each of these can in some situations be avoided by an optimizing compiler). Also the lack of features can affect performance. For example, Java does not have arrays of structures or a true multi-dimensional array, but only an array of references to objects or further arrays. Nor does Java allow returning more than one value from a function without using an object. The net result is that Java code makes more heap allocations than well-written code in some other languages.
Garbage collection
The use of a garbage collector to automatically delete objects adds overhead compared to manual deallocation and can have a positive or negative impact, or no discernible impact at all, on performance depending upon the garbage collector implementation and the characteristics of the application's use of objects. With the modern generational garbage collectors used in many JVMs, many applications actually experience greater performance because of faster allocation and deallocation algorithms.
Byte code vs. native compilation
Relative performance of JIT compilers as compared to native compilers can be quite close, and is often a subject of debate. The JIT compilation stage may be time consuming, which is inconvenient for applications that are short-lived and/or contain large amounts of code. Once compiled to native code, however, the performance of the program can be comparable to that achieved by a native compiler, even on numerical tasks. Although Java does not support manual inlining of method calls, many JIT compilers perform this optimization at load time and can exploit information from the runtime environment to guide more effective transformations, such as profile-directed inlining. Dynamic recompilation, as provided by Sun's HotSpot JVM, can exceed the performance of the static compilation available in most other languages by exploiting information that is only available at runtime.
Hardware interfacing
Because Java was designed with an emphasis on security and portability, it does not support direct access to the machine architecture and address space. This means working directly with a specific piece of hardware such as a scanner, digital camera, audio recorder, video capture, or virtually any hardware that requires direct memory space control (typically those pieces or hardware installed with drivers), cannot easily be accomplished with Java. An illustration of this issue is seen in version 1.0 of Java as it was not possible to access a printer because the interface code to the various printer drivers was not included in this first JVM.
Interfacing with native code
Clients side or server systems that need to "talk" to the hardware must implement a hybrid solution using Java and C/C++ or assembly language via the Java Native Interface (JNI) libraries to link native code to the Java libraries. An alternate solution is to code the hardware software component in its native C/C++/assembler language and then pass the data via files, databases or a shared memory interface, although this is not an ideal solution.
Using the JNI technique introduces many possible inconsistencies such as: machine dependency, potential deadlock situations, memory allocation leaks, and possibly poor application performance, not to mention code complexity of needing to maintain two different code bases. However, it must be noted that it is a common case for other Virtual machine languages, as for example the .NET Framework Common Language Runtime (see Platform Invocation Services).
Inconsistent JVM implementations
Java is a bytecode language that runs on top of the JVM; ultimately the compatibility of the language and the ability to have it run across different platforms is dependent on the stability and version of the JVM. While Java is touted as running on a large variety of systems, the most up to date JVM (and JRE) are only those actively updated for Windows, Linux and Solaris. HP (such as Java for HP-UX) and IBM (for MVS, AIX, OS/400) provide their own implementations for their family of platforms but do not always mirror the latest Sun releases. Other JVM implementations usually follow, but sometimes lag in months or years with the more common implementations and therefore introduce compatibility issues.
1.What are the principle concepts
of OOPS?
There are four principle concepts upon which object oriented design and
programming rest. They are:
- Abstraction
- Polymorphism
- Inheritance
- Encapsulation
(i.e. easily remembered as
A-PIE).
2.What is Abstraction?
Abstraction refers to the act of representing essential features
without including the background details or explanations.
3.What is Encapsulation?
Encapsulation is a technique used for hiding the properties and
behaviors of an object and allowing outside access only as appropriate. It
prevents other objects from directly altering or accessing the properties or
methods of the encapsulated object.
4.What is the difference between abstraction and encapsulation?
- Abstraction focuses on
the outside view of an object (i.e. the interface) Encapsulation
(information hiding) prevents clients from seeing it’s inside view, where
the behavior of the abstraction is implemented.
- Abstraction solves the
problem in the design side while Encapsulation is the
Implementation.
- Encapsulation is the deliverables
of Abstraction. Encapsulation barely talks about grouping up your
abstraction to suit the developer needs.
5.What is Inheritance?
- 0Inheritance is the
process by which objects of one class acquire the properties of objects of
another class.
- A class that is
inherited is called a superclass.
- The class that does the
inheriting is called a subclass.
- Inheritance is done by
using the keyword extends.
- The two most common
reasons to use inheritance are:
- To promote code reuse
- To use polymorphism
6.What is Polymorphism?
Polymorphism is briefly described as "one interface, many
implementations." Polymorphism is a characteristic of being able to assign
a different meaning or usage to something in different contexts - specifically,
to allow an entity such as a variable, a function, or an object to have more
than one form.
7.How does Java implement polymorphism?
(Inheritance, Overloading and Overriding are used to achieve
Polymorphism in java).
Polymorphism manifests itself in Java in the form of multiple methods having the same name.
Polymorphism manifests itself in Java in the form of multiple methods having the same name.
- In some cases, multiple
methods have the same name, but different formal argument lists
(overloaded methods).
- In other cases,
multiple methods have the same name, same return type, and same formal
argument list (overridden methods).
8.Explain the different forms of Polymorphism.
There are two types of polymorphism one is Compile time polymorphism
and the other is run time polymorphism. Compile time polymorphism is method
overloading. Runtime time polymorphism is done using inheritance and
interface.
Note: From a practical programming viewpoint, polymorphism manifests itself in three distinct forms in Java:
Note: From a practical programming viewpoint, polymorphism manifests itself in three distinct forms in Java:
- Method overloading
- Method overriding
through inheritance
- Method overriding
through the Java interface
9.What is runtime polymorphism or dynamic method dispatch?
In Java, runtime polymorphism or dynamic method dispatch is a process
in which a call to an overridden method is resolved at runtime rather than at
compile-time. In this process, an overridden method is called through the
reference variable of a superclass. The determination of the method to be
called is based on the object being referred to by the reference variable.
10.What is Dynamic Binding?
Binding refers to the linking of a procedure call to the code to be
executed in response to the call. Dynamic binding (also known as late binding)
means that the code associated with a given procedure call is not known until
the time of the call at run-time. It is associated with polymorphism and
inheritance.
11.What is method overloading?
Method Overloading means to have two or more methods with same name in
the same class with different arguments. The benefit of method overloading is
that it allows you to implement methods that support the same semantic operation
but differ by argument number or type.
Note:
Note:
- Overloaded methods MUST
change the argument list
- Overloaded methods CAN
change the return type
- Overloaded methods CAN
change the access modifier
- Overloaded methods CAN
declare new or broader checked exceptions
- A method can be
overloaded in the same class or in a subclass
12.What is method overriding?
Method overriding occurs when sub class declares a method that has the
same type arguments as a method declared by one of its superclass. The key
benefit of overriding is the ability to define behavior that’s specific to a
particular subclass type.
Note:
Note:
- The overriding method
cannot have a more restrictive access modifier than the method being
overridden (Ex: You can’t override a method marked public and make it
protected).
- You cannot override a
method marked final
- You cannot override a
method marked static
13.What are the differences between method overloading and method overriding?
|
|
Overloaded
Method
|
Overridden
Method
|
|
Arguments
|
Must
change |
Must
not change |
|
Return
type |
Can
change |
Can’t
change except for covariant returns |
|
Exceptions |
Can
change |
Can
reduce or eliminate. Must not throw new or broader checked exceptions |
|
Access |
Can
change |
Must
not make more restrictive (can be less restrictive) |
|
Invocation |
Reference
type determines which overloaded version is selected. Happens at compile
time. |
Object
type determines which method is selected. Happens at runtime. |
14.Can overloaded methods be override too?
Yes, derived classes still can override the overloaded methods.
Polymorphism can still happen. Compiler will not binding the method calls since
it is overloaded, because it might be overridden now or in the future.
15.Is it possible to override the main method?
NO, because main is a static method. A static method can't be
overridden in Java.
16.How to invoke a superclass version of an Overridden method?
To invoke a superclass method that has been overridden in a subclass,
you must either call the method directly through a superclass instance, or use
the super prefix in the subclass itself. From the point of the view of the
subclass, the super prefix provides an explicit reference to the superclass'
implementation of the method.
// From subclass
super.overriddenMethod();
17.What is super?
super is a keyword which is used to access the method or member variables
from the superclass. If a method hides one of the member variables in its
superclass, the method can refer to the ` 1hidden
variable through the use of the super keyword. In the same way, if a method
overrides one of the methods in its superclass, the method can invoke the
overridden method through the use of the super keyword. Note:
- You can only go back
one level.
- In the constructor, if
you use super(), it must be the very first code, and you cannot access any
this.xxxvariables or methods to compute its parameters.
18.How do you prevent a method from being overridden?
To prevent a specific method from being overridden in a subclass, use
the final modifier on the method declaration, which means "this is the
final implementation of this method", the end of its inheritance
hierarchy.
public final void exampleMethod() {
// Method statements
}
19.What is an Interface?
An interface is a description of a set of methods that conforming
implementing classes must have.
Note:
Note:
- You can’t mark an
interface as final.
- Interface variables
must be static.
- An Interface cannot
extend anything but another interfaces.
20.Can we instantiate an
interface?
You can’t instantiate an interface directly, but you can instantiate a
class that implements an interface.
21.Can we create an object for an interface?
Yes, it is always necessary to create an object implementation for an
interface. Interfaces cannot be instantiated in their own right, so you must
write a class that implements the interface and fulfill all the methods defined
in it.
22.Do interfaces have member variables?
Interfaces may have member variables, but these are implicitly
23.What modifiers are allowed for methods in an Interface?
public, static, and final- in other words,
interfaces can declare only constants, not instance variables that are
available to all implementations and may be used as key references for method
arguments for example.23.What modifiers are allowed for methods in an Interface?
Only
24.What is a marker interface?
public and abstract modifiers are allowed for
methods in interfaces.24.What is a marker interface?
Marker interfaces are those which do not declare any required methods,
but signify their compatibility with certain operations. The
java.io.Serializable interface and Cloneable are typical
marker interfaces. These do not contain any methods, but classes must implement
this interface in order to be serialized and de-serialized.25.What is an abstract class?
Abstract classes are classes that contain one or more abstract methods.
An abstract method is a method that is declared, but contains no
implementation.
Note:
Note:
- If even a single method
is abstract, the whole class must be declared abstract.
- Abstract classes may
not be instantiated, and require subclasses to provide implementations for
the abstract methods.
- You can’t mark a class
as both abstract and final.
26.Can we instantiate an abstract class?
An abstract class can never be instantiated. Its sole purpose is to be
extended (subclassed).
27.What are the differences between Interface and Abstract class?
|
Abstract Class
|
Interfaces
|
|
An abstract class can provide complete, default code and/or just the
details that have to be overridden.
|
An interface cannot provide any code at all,just the signature.
|
|
In case of abstract class, a class may extend only one abstract
class.
|
A Class may implement several interfaces.
|
|
An abstract class can have non-abstract methods.
|
All methods of an Interface are abstract.
|
|
An abstract class can have instance variables.
|
An Interface cannot have instance variables.
|
|
An abstract class can have any visibility: public, private,
protected.
|
An Interface visibility must be public (or) none.
|
|
If we add a new method to an abstract class then we have the option
of providing default implementation and therefore all the existing code might
work properly.
|
If we add a new method to an Interface then we have to track down all
the implementations of the interface and define implementation for the new
method.
|
|
An abstract class can contain constructors .
|
An Interface cannot contain constructors .
|
|
Abstract classes are fast.
|
Interfaces are slow as it requires extra indirection to find
corresponding method in the actual class.
|
28.When should I use abstract classes and when should I use interfaces?
Use Interfaces when…
- You see that something
in your design will change frequently.
- If various
implementations only share method signatures then it is better to use
Interfaces.
- you need some classes
to use some methods which you don't want to be included in the class, then
you go for the interface, which makes it easy to just implement and make
use of the methods defined in the interface.
Use Abstract Class when…
- If various
implementations are of the same kind and use common behavior or status
then abstract class is better to use.
- When you want to
provide a generalized form of abstraction and leave the implementation
task with the inheriting subclass.
- Abstract classes are an
excellent way to create planned inheritance hierarchies. They're also a
good choice for nonleaf classes in class hierarchies.
29.When you declare a method as abstract, can other nonabstract methods access it?
Yes, other nonabstract methods can access a method that you declare as
abstract.
30.Can there be an abstract class with no abstract methods in it?
Yes, there can be an abstract class without abstract methods.
31.What is Constructor?
- A constructor is a special
method whose task is to initialize the object of its class.
- It is special because
its name is the same as the class name.
- They do not have return
types, not even void and therefore they cannot return
values.
- They cannot be
inherited, though a derived class can call the base class
constructor.
- Constructor is invoked
whenever an object of its associated class is created.
32.How does the Java default constructor be provided?
If a class defined by the code does not have any
constructor, compiler will automatically provide one no-parameter-constructor
(default-constructor) for the class in the byte code. The access modifier
(public/private/etc.) of the default constructor is the same as the class
itself.
33.Can constructor be inherited?
No, constructor cannot be inherited, though a derived class can call
the base class constructor.
34.What are the differences between Contructors and Methods?
|
|
Constructors
|
Methods
|
|
Purpose |
Create
an instance of a class |
Group
Java statements |
|
Modifiers |
Cannot
be abstract, final, native, static, or synchronized |
Can be
abstract, final, native, static, or synchronized |
|
Return
Type |
No
return type, not even void |
void
or a valid return type |
|
Name |
Same
name as the class (first letter is capitalized by convention) -- usually a
noun |
Any
name except the class. Method names begin with a lowercase letter by
convention -- usually the name of an action |
|
This |
Refers
to another constructor in the same class. If used, it must be the first line
of the constructor |
Refers
to an instance of the owning class. Cannot be used by static methods. |
|
Super |
Calls the constructor of the parent class. If used, must be the first
line of the constructor
|
Calls an overridden method in the parent class
|
|
Inheritance |
Constructors are not inherited
|
Methods are inherited
|
35.How are this() and super() used with constructors?
- Constructors use this
to refer to another constructor in the same class with a different
parameter list.
- Constructors use super
to invoke the superclass's constructor. If a constructor uses super,
it must use it in the first line; otherwise, the compiler will complain.
36.What are the differences between Class Methods and Instance Methods?
|
Class Methods
|
Instance
Methods
|
|
Class methods are methods which are declared as static. The method
can be called without creating an instance of the class
|
Instance methods on the other hand require an instance of the class
to exist before they can be called, so an instance of a class needs to be
created by using the new keyword.
Instance methods operate on specific instances of classes. |
|
Class methods can only operate on class members and not on instance
members as class methods are unaware of instance members.
|
Instance methods of the class can also not be called from within a
class method unless they are being called on an instance of that class.
|
|
Class methods are methods which are declared as static. The method
can be called without creating an instance of the class.
|
Instance methods are not declared as static.
|
37.How are this() and super() used with constructors?
- Constructors use this
to refer to another constructor in the same class with a different
parameter list.
- Constructors use super
to invoke the superclass's constructor. If a constructor uses super, it
must use it in the first line; otherwise, the compiler will complain.
38.What are Access Specifiers?
One of the techniques in object-oriented programming is encapsulation.
It concerns the hiding of data in a class and making this class available only
through methods. Java allows you to control access to classes, methods, and
fields via so-called access specifiers..
39.What are Access Specifiers available in Java?
Java offers four access specifiers, listed below in decreasing
accessibility:
- Public- public
classes, methods, and fields can be accessed from everywhere.
- Protected- protected
methods and fields can only be accessed within the same class to which the
methods and fields belong, within its subclasses, and within classes of
the same package.
- Default(no specifier)- If you do
not set access to specific level, then such a class, method, or field will
be accessible from inside the same package to which the class, method, or
field belongs, but not from outside this package.
- Private- private
methods and fields can only be accessed within the same class to which the
methods and fields belong. private methods and fields are not
visible within subclasses and are not inherited by subclasses.
|
Situation
|
public |
protected |
default
|
private |
|
Accessible to class
from same package? |
yes
|
yes
|
yes
|
no
|
|
Accessible to class
from different package? |
yes
|
no, unless it is
a subclass
|
no
|
no
|
40.What is final modifier?
The final modifier keyword makes that the programmer cannot
change the value anymore. The actual meaning depends on whether it is applied
to a class, a variable, or a method.
·
final Classes- A final class
cannot have subclasses.
- final Variables- A final variable
cannot be changed once it is initialized.
- final Methods- A final
method cannot be overridden by subclasses.
41.What are the uses
of final method?
There are two reasons for marking a method as final:
- Disallowing subclasses
to change the meaning of the method.
- Increasing efficiency
by allowing the compiler to turn calls to the method into inline Java
code.
42.What is static block?
Static block which exactly executed exactly once when the class is
first loaded into JVM. Before going to the main method the static block will
execute.
43.What are static variables?
Variables that have only one copy per class are known as static
variables. They are not attached to a particular instance of a class but rather
belong to a class as a whole. They are declared by using the static keyword as
a modifier.
static type varIdentifier;
where, the name of the variable is varIdentifier and its data type is
specified by type.
Note: Static variables that are not explicitly initialized in the code are autom
Note: Static variables that are not explicitly initialized in the code are autom
atically initialized with a default value. The default value depends on
the data type of the variables.
44.What is the difference between static and non-static variables?
A static variable is associated with the class as a whole rather than
with specific instances of a class. Non-static variables take on unique values
with each object instance.
45.What are static methods?
Methods declared with the keyword static as modifier are called static
methods or class methods. They are so called because they affect a class as a
whole, not a particular instance of the class. Static methods are always
invoked without reference to a particular instance of a class.
Note:The use of a static method suffers from the following restrictions:
Note:The use of a static method suffers from the following restrictions:
- A static method can
only call other static methods.
- A static method must
only access static data.
- A static method cannot
reference to the current object using keywords super or this.
46.What is an Iterator ?
- The Iterator interface
is used to step through the elements of a Collection.
- Iterators let you
process each element of a Collection.
- Iterators are a generic
way to go through all the elements of a Collection no matter how
it is organized.
- Iterator is
an Interface implemented a different way for
every Collection.
47.How do you traverse through a collection using its Iterator?
To use an iterator to traverse through the contents of a collection,
follow these steps:
- Obtain an iterator to
the start of the collection by calling the collection’s iterator()
method.
- Set up a loop that
makes a call to hasNext(). Have the loop iterate as long
as hasNext() returns true.
- Within the loop, obtain
each element by calling next().
48.How do you remove elements during Iteration?
Iterator also has a method remove() when remove
is called, the current element in the iteration is deleted.
49.What is the difference between Enumeration and Iterator?
|
Enumeration
|
Iterator
|
|
Enumeration
doesn't have a remove() method |
Iterator
has a remove() method |
|
Enumeration
acts as Read-only interface, because it has the methods only to traverse and
fetch the objects |
Can be
abstract, final, native, static, or synchronized |
Note: So Enumeration is used whenever we want to make Collection objects as
Read-only.
|
|
50.How is ListIterator?
ListIterator is just like Iterator, except it allows us to
access the collection in either the forward or backward direction and lets us
modify an element
51.What is the List interface?
- The List interface
provides support for ordered collections of objects.
- Lists may contain
duplicate elements.
52.What are the main implementations of the List interface ?
The main implementations of the List interface are as follows :
- ArrayList :
Resizable-array implementation of the List interface. The best all-around
implementation of the List interface.
- Vector :
Synchronized resizable-array implementation of the List interface with
additional "legacy methods."
- LinkedList :
Doubly-linked list implementation of the List interface. May provide
better performance than the ArrayList implementation if elements are
frequently inserted or deleted within the list. Useful for queues and
double-ended queues (deques).
53.What are the advantages of ArrayList over arrays ?
Some of the advantages ArrayList has over arrays are:
- It can grow dynamically
- It provides more
powerful insertion and search mechanisms than arrays.
54.Difference between ArrayList and Vector ?
|
ArrayList
|
Vector
|
|
ArrayList is NOT synchronized by default.
|
Vector List is synchronized by default.
|
|
ArrayList can use only Iterator to access the elements.
|
Vector list can use Iterator and Enumeration Interface to access the
elements.
|
|
The ArrayList increases its array size by 50 percent if it runs out
of room.
|
A Vector defaults to doubling the size of its array if it runs out of
room
|
|
ArrayList has no default size.
|
While vector has a default size of 10.
|
Array can be obtained from an ArrayList using toArray() method
on ArrayList.
List arrayList = new ArrayList();
arrayList.add(…
Object a[] = arrayList.toArray();
56.Why insertion and deletion
in ArrayList is slow compared to LinkedList ?
- ArrayList internally
uses and array to store the elements, when that array gets filled by
inserting elements a new array of roughly 1.5 times the size of the
original array is created and all the data of old array is copied to new
array.
During deletion, all elements present in the array after the deleted elements have to be moved one step back to fill the space created by deletion. In linked list data is stored in nodes that have reference to the previous node and the next node so adding element is simple as creating the node an updating the next pointer on the last node and the previous pointer on the new node. Deletion in linked list is fast because it involves only updating the next pointer in the node before the deleted node and updating the previous pointer in the node after the deleted node.
|
|
57.Why are Iterators returned
by ArrayList called Fail Fast ?
Because, if list is structurally modified at any time after the
iterator is created, in any way except through the iterator's own remove or add
methods, the iterator will throw a ConcurrentModificationException.
Thus, in the face of concurrent modification, the iterator fails quickly and
cleanly, rather than risking arbitrary, non-deterministic behavior at an
undetermined time in the future.+
58.How do you decide when to use ArrayList and When to use LinkedList?
If you need to support random access, without inserting or removing
elements from any place other than the end, then ArrayList offers the optimal
collection. If, however, you need to frequently add and remove elements from
the middle of the list and only access the list elements sequentially, then LinkedList
offers the better implementation.
59.What is the Set interface ?
- The Set interface
provides methods for accessing the elements of a finite mathematical set
- Sets do not allow
duplicate elements
- Contains no methods
other than those inherited from Collection
- It adds the restriction
that duplicate elements are prohibited
- Two Set objects are
equal if they contain the same elements
The main implementations of the List interface are as follows:
- HashSet
- TreeSet
- LinkedHashSet
- EnumSet
- A HashSet is an
unsorted, unordered Set.
- It uses the hashcode of
the object being inserted (so the more efficient your hashcode() implementation
the better access performance you’ll get).
- Use this class when you
want a collection with no duplicates and you don’t care about order when
you iterate through it.
62.What is a TreeSet ?
TreeSet is a Set implementation that keeps the elements in sorted
order. The elements are sorted according to the natural order of elements or by
the comparator provided at creation time.
63.What is an EnumSet ?
An EnumSet is a specialized set for use with enum types, all of the
elements in the EnumSet type that is specified, explicitly or implicitly, when
the set is created.
64.Difference between HashSet and TreeSet ?
|
HashSet
|
TreeSet
|
|
HashSet is under set interface i.e. it does not guarantee for
either sorted order or sequence order.
|
TreeSet is under set i.e. it provides elements in a sorted
order (acceding order).
|
|
We can add any type of elements to hash set.
|
We can add only similar types
of elements to tree set. |
|
|
65.What is a Map ?
- A map is an object that
stores associations between keys and values (key/value pairs).
- Given a key, you can
find its value. Both keys and values are objects.
- The keys must be
unique, but the values may be duplicated.
- Some maps can accept a
null key and null values, others cannot.
66.What are the main Implementations of the Map interface ?
The main implementations of the List interface are as follows:
- HashMap
- HashTable
- TreeMap
- EnumMap
67.What is a TreeMap ?
TreeMap actually implements the SortedMap interface which extends the
Map interface. In a TreeMap the data will be sorted in ascending order of keys
according to the natural order for the key's class, or by the comparator
provided at creation time. TreeMap is based on the Red-Black tree data
structure.
68.How do you decide when to use HashMap and when to use TreeMap ?
For inserting, deleting, and locating elements in a Map, the HashMap
offers the best alternative. If, however, you need to traverse the keys in a
sorted order, then TreeMap is your better alternative. Depending upon the size
of your collection, it may be faster to add elements to a HashMap, then convert
the map to a TreeMap for sorted key traversal.
69.Difference between HashMap and Hashtable ?
|
HashMap
|
Hashtable
|
|
HashMap lets you have null values as well as one null key.
|
HashTable does not allows null values as key and value.
|
|
The iterator in the HashMap is fail-safe (If you change the map while
iterating, you’ll know).
|
The enumerator for the Hashtable is not fail-safe.
|
|
HashMap is unsynchronized.
|
Hashtable is synchronized.
|
Note: Only one NULL is allowed as a key in HashMap. HashMap does not allow
multiple keys to be NULL. Nevertheless, it can have multiple NULL values.
70.How does a Hashtable internally maintain the key-value pairs?
TreeMap actually implements the SortedMap interface which extends the
Map interface. In a TreeMap the data will be sorted in ascending order of keys
according to the natural order for the key's class, or by the comparator
provided at creation time. TreeMap is based on the Red-Black tree data structure.
|
|
71.What Are the different
Collection Views That Maps Provide?
Maps Provide Three Collection Views.
- Key Set - allow a
map's contents to be viewed as a set of keys.
- Values Collection - allow a
map's contents to be viewed as a set of values.
- Entry Set - allow a
map's contents to be viewed as a set of key-value mappings.
72.What is a KeySet View ?
KeySet is a set returned by the keySet() method
of the Map Interface, It is a set that contains all the keys present in the
Map.
73.What is a Values Collection View ?
Values Collection View is a collection returned by the values()
method of the Map Interface, It contains all the objects present as values in
the map.
74.What is an EntrySet View ?
Entry Set view is a set that is returned by the entrySet()
method in the map and contains Objects of type Map. Entry each of which has
both Key and Value.
75.How do you sort an ArrayList (or any list) of user-defined objects ?
Create an implementation of the java.lang.Comparable interface
that knows how to order your objects and pass it to java.util.Collections.sort(List,
Comparator).
76.What is the Comparable interface ?
The Comparable interface is used to sort collections and arrays of
objects using the
Collections.sort() and java.utils.Arrays.sort() methods
respectively. The objects of the class implementing the Comparable interface
can be ordered.
The Comparable interface in the generic form is written as follows:
interface Comparable<T>
where T is the name of the
type parameter.
All classes implementing the Comparable interface must implement the
All classes implementing the Comparable interface must implement the
compareTo() method that has
the return type as an integer. The signature of the compareTo() method is as
follows: int i = object1.compareTo(object2)
- If object1 <
object2: The value of i returned will be negative.
- If object1 >
object2: The value of i returned will be positive.
- If object1 = object2:
The value of i returned will be zero.
77.What are the differences between the Comparable and Comparator interfaces ?
|
Comparable
|
Comparato
|
|
It
uses the compareTo() method. int objectOne.compareTo(objectTwo). |
t uses the compare() method.
int compare(ObjOne, ObjTwo) |
|
It is necessary to modify the class whose instance is going to be
sorted.
|
A separate class can be created in order to sort the instances.
|
|
Only one sort sequence can be created.
|
Many sort sequences can be created.
|
|
It is frequently used by the API classes.
|
It used by third-party classes to sort instances.
|
1.What are the principle
concepts of OOPS?
There are four principle concepts upon which object oriented design and
programming rest. They are:
- Abstraction
- Polymorphism
- Inheritance
- Encapsulation
(i.e. easily remembered as
A-PIE).
2.What is Abstraction?
Abstraction refers to the act of representing essential features
without including the background details or explanations.
3.What is Encapsulation?
Encapsulation is a technique used for hiding the properties and
behaviors of an object and allowing outside access only as appropriate. It
prevents other objects from directly altering or accessing the properties or
methods of the encapsulated object.
4.What is the difference between abstraction and encapsulation?
- Abstraction focuses on
the outside view of an object (i.e. the interface) Encapsulation
(information hiding) prevents clients from seeing it’s inside view, where
the behavior of the abstraction is implemented.
- Abstraction solves the
problem in the design side while Encapsulation is the
Implementation.
- Encapsulation is the
deliverables of Abstraction. Encapsulation barely talks about grouping up
your abstraction to suit the developer needs.
5.What is Inheritance?
- Inheritance is the
process by which objects of one class acquire the properties of objects of
another class.
- A class that is inherited
is called a superclass.
- The class that does the
inheriting is called a subclass.
- Inheritance is done by
using the keyword extends.
- The two most common
reasons to use inheritance are:
- To promote code reuse
- To use polymorphism
6.What is Polymorphism?
Polymorphism is briefly described as "one interface, many
implementations." Polymorphism is a characteristic of being able to assign
a different meaning or usage to something in different contexts - specifically,
to allow an entity such as a variable, a function, or an object to have more
than one form.
7.How does Java implement polymorphism?
(Inheritance, Overloading and Overriding are used to achieve
Polymorphism in java).
Polymorphism manifests itself in Java in the form of multiple methods having the same name.
Polymorphism manifests itself in Java in the form of multiple methods having the same name.
- In some cases, multiple
methods have the same name, but different formal argument lists
(overloaded methods).
- In other cases,
multiple methods have the same name, same return type, and same formal
argument list (overridden methods).
8.Explain the different forms of Polymorphism.
There are two types of polymorphism one is Compile time polymorphism
and the other is run time polymorphism. Compile time polymorphism is method
overloading. Runtime time polymorphism is done using inheritance and
interface.
Note: From a practical programming viewpoint, polymorphism manifests itself in three distinct forms in Java:
Note: From a practical programming viewpoint, polymorphism manifests itself in three distinct forms in Java:
- Method overloading
- Method overriding
through inheritance
- Method overriding
through the Java interface
9.What is runtime polymorphism or dynamic method dispatch?
In Java, runtime polymorphism or dynamic method dispatch is a process
in which a call to an overridden method is resolved at runtime rather than at
compile-time. In this process, an overridden method is called through the
reference variable of a superclass. The determination of the method to be
called is based on the object being referred to by the reference variable.
10.What is Dynamic Binding?
Binding refers to the linking of a procedure call to the code to be executed
in response to the call. Dynamic binding (also known as late binding) means
that the code associated with a given procedure call is not known until the
time of the call at run-time. It is associated with polymorphism and
inheritance.
11.What is method overloading?
Method Overloading means to have two or more methods with same name in
the same class with different arguments. The benefit of method overloading is
that it allows you to implement methods that support the same semantic
operation but differ by argument number or type.
Note:
Note:
- Overloaded methods MUST
change the argument list
- Overloaded methods CAN
change the return type
- Overloaded methods CAN
change the access modifier
- Overloaded methods CAN
declare new or broader checked exceptions
- A method can be
overloaded in the same class or in a subclass
12.What is method overriding?
Method overriding occurs when sub class declares a method that has the
same type arguments as a method declared by one of its superclass. The key
benefit of overriding is the ability to define behavior that’s specific to a
particular subclass type.
Note:
Note:
- The overriding method
cannot have a more restrictive access modifier than the method being
overridden (Ex: You can’t override a method marked public and make it protected).
- You cannot override a
method marked final
- You cannot override a
method marked static
13.What are the differences between method overloading and method overriding?
|
|
Overloaded
Method
|
Overridden
Method
|
|
Arguments
|
Must
change |
Must
not change |
|
Return
type |
Can
change |
Can’t
change except for covariant returns |
|
Exceptions |
Can
change |
Can
reduce or eliminate. Must not throw new or broader checked exceptions |
|
Access |
Can
change |
Must
not make more restrictive (can be less restrictive) |
|
Invocation |
Reference
type determines which overloaded version is selected. Happens at compile
time. |
Object
type determines which method is selected. Happens at runtime. |
14.Can overloaded methods be override too?
Yes, derived classes still can override the overloaded methods.
Polymorphism can still happen. Compiler will not binding the method calls since
it is overloaded, because it might be overridden now or in the future.
15.Is it possible to override the main method?
15.Is it possible to override the main method?
NO, because main is a static method. A static method can't be
overridden in Java.
16.How to invoke a superclass version of an Overridden method?
To invoke a superclass method that has been overridden in a subclass,
you must either call the method directly through a superclass instance, or use
the super prefix in the subclass itself. From the point of the view of the
subclass, the super prefix provides an explicit reference to the superclass'
implementation of the method.
// From subclass
super.overriddenMethod();
17.What is super?
super is a keyword which is used to access the method or member variables
from the superclass. If a method hides one of the member variables in its
superclass, the method can refer to the hidden variable through the use of the
super keyword. In the same way, if a method overrides one of the methods in its
superclass, the method can invoke the overridden method through the use of the
super keyword. Note:
- You can only go back
one level.
- In the constructor, if
you use super(), it must be the very first code, and you cannot access any
this.xxxvariables or methods to compute its parameters.
18.How do you prevent a method from being overridden?
To prevent a specific method from being overridden in a subclass, use
the final modifier on the method declaration, which means "this is the
final implementation of this method", the end of its inheritance
hierarchy.
public final void exampleMethod() {
// Method statements
}
19.What is an Interface?
An interface is a description of a set of methods that conforming
implementing classes must have.
Note:
Note:
- You can’t mark an
interface as final.
- Interface variables
must be static.
- An Interface cannot
extend anything but another interfaces.
20.Can we instantiate an
interface?
You can’t instantiate an interface directly, but you can instantiate a
class that implements an interface.
21.Can we create an object for an interface?
Yes, it is always necessary to create an object implementation for an
interface. Interfaces cannot be instantiated in their own right, so you must
write a class that implements the interface and fulfill all the methods defined
in it.
22.Do interfaces have member variables?
Interfaces may have member variables, but these are implicitly
public, static, and final- in other words,
interfaces can declare only constants, not instance variables that are
available to all implementations and may be used as key references for method
arguments for example.23.What modifiers are allowed for methods in an Interface?
Only
public and abstract modifiers are allowed for
methods in interfaces.24.What is a marker interface?
Marker interfaces are those which do not declare any required methods,
but signify their compatibility with certain operations. The
java.io.Serializable interface and Cloneable are typical
marker interfaces. These do not contain any methods, but classes must implement
this interface in order to be serialized and de-serialized.25.What is an abstract class?
Abstract classes are classes that contain one or more abstract methods.
An abstract method is a method that is declared, but contains no implementation.
Note:
Note:
- If even a single method
is abstract, the whole class must be declared abstract.
- Abstract classes may
not be instantiated, and require subclasses to provide implementations for
the abstract methods.
- You can’t mark a class
as both abstract and final.
26.Can we instantiate an abstract class?
An abstract class can never be instantiated. Its sole purpose is to be
extended (subclassed).
27.What are the differences between Interface and Abstract class?
27.What are the differences between Interface and Abstract class?
|
Abstract Class
|
Interfaces
|
|
An abstract class can provide complete, default code and/or just the
details that have to be overridden.
|
An interface cannot provide any code at all,just the signature.
|
|
In case of abstract class, a class may extend only one abstract
class.
|
A Class may implement several interfaces.
|
|
An abstract class can have non-abstract methods.
|
All methods of an Interface are abstract.
|
|
An abstract class can have instance variables.
|
An Interface cannot have instance variables.
|
|
An abstract class can have any visibility: public, private,
protected.
|
An Interface visibility must be public (or) none.
|
|
If we add a new method to an abstract class then we have the option
of providing default implementation and therefore all the existing code might
work properly.
|
If we add a new method to an Interface then we have to track down all
the implementations of the interface and define implementation for the new
method.
|
|
An abstract class can contain constructors .
|
An Interface cannot contain constructors .
|
|
Abstract classes are fast.
|
Interfaces are slow as it requires extra indirection to find
corresponding method in the actual class.
|
28.When should I use abstract classes and when should I use interfaces?
Use Interfaces when…
- You see that something
in your design will change frequently.
- If various
implementations only share method signatures then it is better to use
Interfaces.
- you need some classes
to use some methods which you don't want to be included in the class, then
you go for the interface, which makes it easy to just implement and make
use of the methods defined in the interface.
Use Abstract Class when…
- If various
implementations are of the same kind and use common behavior or status
then abstract class is better to use.
- When you want to
provide a generalized form of abstraction and leave the implementation
task with the inheriting subclass.
·
Abstract classes are an excellent way to create
planned inheritance hierarchies. They're also a good choice for nonleaf classes
in class hierarchies.
29.When you declare a method as abstract, can other nonabstract methods access it?
29.When you declare a method as abstract, can other nonabstract methods access it?
Yes, other nonabstract methods can access a method that you declare as
abstract.
30.Can there be an abstract class with no abstract methods in it?
Yes, there can be an abstract class without abstract methods.
|
Q:
|
What is the difference between an Interface and an
Abstract class? |
|
A:
|
An
abstract class can have instance methods that implement a default behavior.
An Interface can only declare constants and instance methods, but cannot
implement default behavior and all methods are implicitly abstract. An
interface has all public members and no implementation. An abstract class is
a class which may have the usual flavors of class members (private,
protected, etc.), but has some abstract methods.
. |
|
|
|
Q:
|
What is the purpose of garbage collection in Java,
and when is it used? |
|
A:
|
The
purpose of garbage collection is to identify and discard objects that are no
longer needed by a program so that their resources can be reclaimed and
reused. A Java object is subject to garbage collection when it becomes
unreachable to the program in which it is used.
|
|
|
|
Q:
|
Describe synchronization in respect to
multithreading. |
|
A:
|
With
respect to multithreading, synchronization is the capability to control the
access of multiple threads to shared resources. Without synchonization, it is
possible for one thread to modify a shared variable while another thread is
in the process of using or updating same shared variable. This usually leads
to significant errors.
|
|
|
|
Q:
|
Explain
different way of using thread? |
|
A:
|
The
thread could be implemented by using runnable interface or by inheriting from
the Thread class. The former is more advantageous, 'cause when you are going
for multiple inheritance..the only interface can help.
|
|
|
|
Q:
|
What are pass by reference and passby value? |
|
A:
|
Pass By
Reference means the passing the address itself rather than passing the
value. Passby Value means passing a copy of the value to be
passed.
|
|
|
|
Q:
|
What is HashMap and Map? |
|
A:
|
Map
is Interface and Hashmap is class that implements that.
|
|
|
|
Q:
|
Difference between HashMap and HashTable? |
|
A:
|
The
HashMap class is roughly equivalent to Hashtable, except that it is
unsynchronized and permits nulls. (HashMap allows null values as key and
value whereas Hashtable doesnt allow). HashMap does not guarantee that the
order of the map will remain constant over time. HashMap is unsynchronized
and Hashtable is synchronized.
|
|
|
|
Q:
|
Difference
between Vector and ArrayList? |
|
A:
|
Vector
is synchronized whereas arraylist is not.
|
|
|
|
Q:
|
Difference
between Swing and Awt? |
|
A:
|
AWT
are heavy-weight componenets. Swings are light-weight components. Hence swing
works faster than AWT.
|
|
|
|
Q:
|
What is the difference between a constructor and a
method? |
|
A:
|
A
constructor is a member function of a class that is used to create objects of
that class. It has the same name as the class itself, has no return type, and
is invoked using the new operator.
A method is an ordinary member function of a class. It has its own name, a return type (which may be void), and is invoked using the dot operator. |
|
|
|
Q:
|
What is an Iterator? |
|
A:
|
Some
of the collection classes provide traversal of their contents via a
java.util.Iterator interface. This interface allows you to walk through a
collection of objects, operating on each object in turn. Remember when using
Iterators that they contain a snapshot of the collection at the time the
Iterator was obtained; generally it is not advisable to modify the collection
itself while traversing an Iterator.
|
|
|
|
Q:
|
State the significance of public, private, protected,
default modifiers both singly and in combination and state the effect of
package relationships on declared items qualified by these modifiers. |
|
A:
|
public : Public
class is visible in other packages, field is visible everywhere (class must
be public too)
private : Private variables or methods may be used only by an instance of the same class that declares the variable or method, A private feature may only be accessed by the class that owns the feature. protected : Is available to all classes in the same package and also available to all subclasses of the class that owns the protected feature.This access is provided even to subclasses that reside in a different package from the class that owns the protected feature. default :What you get by default ie, without any access modifier (ie, public private or protected).It means that it is visible to all within a particular package. |
|
|
|
Q:
|
What is an abstract class? |
|
A:
|
Abstract
class must be extended/subclassed (to be useful). It serves as a template. A
class that is abstract may not be instantiated (ie, you may not call its
constructor), abstract class may contain static data. Any class with an
abstract method is automatically abstract itself, and must be declared as
such.
A class may be declared abstract even if it has no abstract methods. This prevents it from being instantiated. |
|
|
|
Q:
|
What is static in java? |
|
A:
|
Static
means one per class, not one for each object no matter how many instance of a
class might exist. This means that you can use them without creating an
instance of a class.Static methods are implicitly final, because overriding
is done based on the type of the object, and static methods are attached to a
class, not an object. A static method in a superclass can be shadowed by
another static method in a subclass, as long as the original method was not
declared final. However, you can't override a static method with a nonstatic
method. In other words, you can't change a static method into an instance
method in a subclass.
|
|
|
|
Q:
|
What is final? |
|
A:
|
A
final class can't be extended ie., final class may not be subclassed. A final
method can't be overridden when its class is inherited. You can't change
value of a final variable (is a constant).
|
|
Q:
|
What if the main method is declared as private? |
|
|
A:
|
The
program compiles properly but at runtime it will give "Main method not
public." message.
|
|
|
|
||
|
Q:
|
What if the static modifier is removed from the
signature of the main method? |
|
|
A:
|
Program
compiles. But at runtime throws an error "NoSuchMethodError".
|
|
|
|
||
|
Q:
|
What if I write static public void instead of public
static void? |
|
|
A:
|
Program
compiles and runs properly.
|
|
|
|
||
|
Q:
|
What if I do not provide the String array as the
argument to the method? |
|
|
A:
|
Program
compiles but throws a runtime error "NoSuchMethodError".
|
|
|
|
||
|
Q:
|
What is the first argument of the String array in
main method? |
|
|
A:
|
The
String array is empty. It does not have any element. This is unlike C/C++
where the first element by default is the program name.
|
|
|
|
||
|
Q:
|
If I do not provide any arguments on the command
line, then the String array of Main method will be empty or null? |
|
A:
|
It
is empty. But not null.
|
No comments:
Post a Comment