|
JAVA Interview Questions 28 - 31
|
Back to the list of all Java Interview Questions
|
|
Question 28: What is the main difference between pass-by-reference and pass-by-value?
|
Other languages use pass-by-reference or pass-by-pointer. But in Java no matter what type of argument you
pass the corresponding parameter (primitive variable or object reference) will get a copy of that data, which is
exactly how pass-by-value (i.e. copy-by-value) works.
In Java, if a calling method passes a reference of an object as an argument to the called method then the passedin
reference gets copied first and then passed to the called method. Both the original reference that was
passed-in and the copied reference will be pointing to the same object. So no matter which reference you use, you
will be always modifying the same original object, which is how the pass-by-reference works as well.
|
|
If your method call involves inter-process (e.g. between two JVMs) communication, then the reference of the calling method has a different address space to the called method sitting in a separate process (i.e. separate JVM). Hence inter-process communication involves calling method passing objects as arguments to called method by-value in a serialized form, which can adversely affect performance due to marshaling and unmarshaling cost.
Note: EJB 2.x introduced local interfaces, where enterprise beans that can be used locally within the same JVM using Java’s form of pass-by-reference, hence improving performance.
|
Question 29: What is serialization?
|
Serialization is a process of reading or writing an object. It is a process of saving an object’s state to a sequence of bytes, as well as a process of rebuilding those bytes back into a live object at some future time. An object is marked serializable by implementing the java.io.Serializable interface, which is only a marker interface -- it simply allows the serialization mechanism to verify that the class can be persisted, typically to a file.
Transient variables cannot be serialized. The fields marked transient in a serializable object will not be transmitted in the byte stream. An example would be a file handle, a database connection, a system thread etc.Such objects are only meaningful locally. So they should be marked as transient in a serializable class.
|
|
Serialization can adversely affect performance since it:
- Depends on reflection.
- Has an incredibly verbose data format.
- Is very easy to send surplus data.
|
Question 30: When to use serialization?
|
Do not use serialization if you do not have to. A common use of serialization is to
use it to send an object over the network or if the state of an object needs to be persisted to a flat file or a database. Deep cloning or copy can be achieved through serialization. This may be fast to code but will have performance implications.
To serialize the above “Car” object to a file (sample for illustration purpose only, should use try {} catch {} block):
|
|
Car car = new Car();
// The “Car” class implements a java.io.Serializable interface
FileOutputStream fos
= new FileOutputStream(filename);
ObjectOutputStream
out = new ObjectOutputStream(fos);
out.writeObject(car);
// serialization
mechanism happens here
out.close();
|
|
The objects stored in an HTTP session should be serializable to support in-memory replication of sessions to achieve scalability. Objects are passed in RMI (Remote Method Invocation) across network using serialization.
|
Question 31: What is Java Serial Version ID?
|
|
Say you create a “Car” class, instantiate it, and write it out to an object stream. The flattened car object sits in the file system for some time. Meanwhile, if the “Car” class is modified by adding a new field. Later on, when you try to read (i.e. deserialize) the flattened “Car” object, you get the java.io.InvalidClassException – because all serializable classes are automatically given a unique identifier. This exception is thrown when the identifier of the class is not equal to the identifier of the flattened object. If you really think about it, the exception is thrown because of the addition of the new field. You can avoid this exception being thrown by controlling the versioning yourself by declaring an explicit serialVersionUID. There is also a small performance benefit in explicitly declaring your serialVersionUID (because does not have to be calculated). So, it is best practice to add your own serialVersionUID to your Serializable classes as soon as you create them as shown below:
|
|
public class Car
{
static final long serialVersionUID = 1L; //assign a long value
}
|
|
Note: Alternatively you can use the serialver tool comes with Sun’s JDK. This tool takes a full class name on the command line and returns the serialVersionUID for that compiled class.
|
|
static final long serialVersionUID = 10275439472837494L;
//generated by serialver tool. |
Back to the list of all Java Interview Questions
|
