Tuesday, 31 January 2012
Class FileInputStream:
- It is use for reading stream of data from a file in the form of raw bytes(8-bit).
- Very useful to read image.
- It can also read character files.
Tuesday, 31 January 2012 4 Read more »
Sunday, 29 January 2012
The class which is defined within another class is called nested class.
It can be divided into 2 types. They are - static nested class & non-static nested class
- Nested class which is declared static is static nested class.
- Its methods & variables are associated with is mother/outer class.
- It can be used only through object reference.
- It is accessed using enclosing class name. Example: MotherClass.StaticNestedClass
- It interacts with enclosing class or other class like any other top-level class.
Sunday, 29 January 2012 21 Read more »
Saturday, 28 January 2012
Whereas, throws is included in the method's declaration part, with a list of exceptions that the method can possible throw. It is necessary for all exceptions(except for Error & RuntimeException & their sub-classes).
Saturday, 28 January 2012 25 Read more »
Friday, 27 January 2012
String class :
- Once an object is created and initialized, it can't be changed because it is Immutable.
- String object can be created Implicitly and Explicitly.
StringBuffer class :
- StringBuffer class is mutable(can be modified), length and content can be changed through certain method calls.
- It creates object Explicitly.
Friday, 27 January 2012 1 Read more »
Wednesday, 25 January 2012
The class Object(java.lang.Object), is the super class of all classes in Java.
Wednesday, 25 January 2012 54 Read more »
Saturday, 21 January 2012
In Java, under Throwable class, there are 2 sub-classes named Exception and Error.
Exception class:
Exception class:
- It is used for exceptional conditions that user programs should catch.
- It's also the class that you will sub-class to create your own custom exception types.
- For example, NullPointerException will be thrown if you try using a null reference.
Saturday, 21 January 2012 5 Read more »
Thursday, 19 January 2012
- Container is a component which can contain other components inside itself. It is also an instance of a subclass of
java.awt.Container, which extendsjava.awt.Component. - An applet is a container.
- Containers include windows, frames, dialogs, and panels.
- As a Container itself is a component, it can contain other containers.
- Every container has a
LayoutManagerwhich helps to determines how different components are placed within the container.
Thursday, 19 January 2012 6 Read more »
Wednesday, 18 January 2012
In Java, there are lots of sub-classes under java.lang.Exception class. we can divide these sub-classes into 2 types on the basis of compile-time checking.
The types are - Checked Exception & Unchecked Exception.
Checked Exception:
- Except RuntimeException( java.lang.RuntimeException) class, all sub-classes of Exception are checked exception.
- These exceptions need to include in a method's throws list, because these are checked by the compiler during compile time if a method handles or throws these exception.
Wednesday, 18 January 2012 1 Read more »
Tuesday, 17 January 2012
1. Interface Externalizable gives a control over the serialization mechanism.
2. It has two methods readExternal and writeExternal, which are use to customize the serialization process.
2. It has two methods readExternal and writeExternal, which are use to customize the serialization process.
Tuesday, 17 January 2012 0 Read more »
1. An object needs to be serialized, when it's need to be sent over the network.
2. If the state of an object is to be saved, objects need to be serialized.
2. If the state of an object is to be saved, objects need to be serialized.
Interface Serializable has no methods, it's empty.
By implementing an interface Serializable in the class whose instances are to be serialized.Then passing the instance to the ObjectOutputStream which is connected to a fileoutputstream. This will save the object to a file.
Example:
Now, we will see a practical implementation of serialization on an object and we will store the serialized data in a file.
Class SampleClass is a pojo class which implements java.io.Serializable . It contains four String fields, one of which is declared as transient. That means, we can't serialized this field.
Class SampleClass :
package
com.interview.question.java;
public class SampleClass implements
java.io.Serializable{
/**
*
* Sample serialized class.
*
* @author
http://interviewquestionjava.blogspot.com
*
**/
private static final long serialVersionUID = 1L;
private String strName;
private String strAddress;
private String strUsername;
/**
*
*
we declared the variable strPassword as transient.
*
So, it will be shield from serialization.
*
**/
private transient String strPassword;
public String
getStrName() {
return strName;
}
public void
setStrName(String strName) {
this.strName = strName;
}
public String
getStrAddress() {
return strAddress;
}
public void
setStrAddress(String strAddress) {
this.strAddress = strAddress;
}
public String
getStrUsername() {
return strUsername;
}
public void
setStrUsername(String strUsername) {
this.strUsername = strUsername;
}
public String
getStrPassword() {
return strPassword;
}
public void
setStrPassword(String strPassword) {
this.strPassword = strPassword;
}
}
Now, Class SerializeObjectToFile, is used to create an object of SampleClass with some values.
Then we serialized that object to a file name sampleClass.ser.
Class SerializeObjectToFile :
package com.interview.question.java;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SerializeObjectToFile {
/**
*
* This class serialized an Object of
SampleClass
* to a file named sampleClass.ser
*
* @author http://interviewquestionjava.blogspot.com
*
**/
public static void main(String[] args) {
SampleClass
objSampleClass = new SampleClass();
objSampleClass.setStrName("Ashoka Maurya");
objSampleClass.setStrAddress("Magadha");
objSampleClass.setStrUsername("Chakravartin");
objSampleClass.setStrPassword("Ashokavadana");
try
{
FileOutputStream objFileOutputStream = new FileOutputStream("src/com/interview/question/java/sampleClass.ser");
ObjectOutputStream objOutputStream = new ObjectOutputStream(objFileOutputStream);
objOutputStream.writeObject(objSampleClass);
objOutputStream.close();
objFileOutputStream.close();
System.out.println("SampleClass is serialized successfully..");
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
Now, to deserialize this data back to an object please check the post Deserializing an Object from File
Monday, 16 January 2012
Serialization is the process of writing the state of an object to a byte stream. It's useful when you want to save the state of your program to a persistent storage area, such as a file.
Monday, 16 January 2012 0 Read more »
When a method in subclass has the same name and type signature as a method in its superclass, the the method in the subclass is called to override the method in the superclass. When an overridden method is called from within a subclass, it will always refer to the version of that method defined by the subclass. The version of the method defined by the superclass will be hidden.
No the program fails to compile. The compiler says that the main method is already defined in the class.
Yes it is possible. While starting the application we mention the class name to be run. The JVM will look for the Main method only in the class whose name you have mentioned. Hence there is not conflict amongst the multiple classes having main method.
Sunday, 15 January 2012
Implicit casting is the process of simply assigning one entity to another without any transformation guidance to the compiler. This type of casting is not permitted in all kinds of transformations and may not work for all scenarios.
short j = i; //Implicit casting
Example
byte i = 1;short j = i; //Implicit casting
Sunday, 15 January 2012 1 Read more »
Program compiles but throws a runtime error "NoSuchMethodError".
Program compiles and runs properly.
Program compiles. But at runtime throws an error “NoSuchMethodError”.
- 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).
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.
public access
private access
protected access
default access
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.
Iterators differ from enumerations in two ways:
|
A while statement (pre test) checks at the beginning of a loop to see whether the next loop iteration should occur. A do while statement (post test) checks at the end of a loop to see whether the next iteration of a loop should occur. The do statement will always execute the loop body at least once.
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.
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.
Global variables are globally accessible. Java does not support globally accessible variables due to following reasons:
- The global variables breaks the referential transparency
- Global variables creates collisions in namespace.
Vector :
ArrayList :
- It's synchronized.
- It's slower than ArrayList.
- It's generally used in multithreading programs.
ArrayList :
- It's unsynchronized.
- It's faster than Vector.
- It's generally used in single-thread programs.
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.
Map is Interface and Hashmap is class that implements that.
1. If you want to extend the Thread class then it will make your class unable to extend other classes as java is having single inheritance feature whereas If you implement runnable interface, you can gain better object-oriented design and consistency and also avoid the single inheritance problems.
2. Extending the thread will give you simple code structure in comparison to Runnable Interface.
3. Using Runnable Interface, you can run class several times whereas Thread have the start() method that can be called only once.
2. Extending the thread will give you simple code structure in comparison to Runnable Interface.
3. Using Runnable Interface, you can run class several times whereas Thread have the start() method that can be called only once.
There are 2 ways of using thread -
- By implementing runnable interface.
- By extending the Thread class.
An application programming interface (API) is a library of functions that Java provides for programmers for common tasks like file transfer, networking, and data structures.
List of Java APIs:
There are three types of APIs in Java.- the official core Java API, contained in the JDK or JRE, of one of the editions of the Java Platform. The three editions of the Java Platform are Java ME (Micro edition), Java SE (Standard edition), and Java EE (Enterprise edition).
- optional official APIs that can be downloaded separately. The specification of these APIs are defined according to a Java Specification Request (JSR), and sometimes some of these APIs are later included in the core APIs of the platform (the most notable example of this kind is Swing).
- unofficial APIs, developed by third parties, but not related to any JSRs.
With respect to multithreading,
synchronization is the capability to control the access of multiple threads to
shared resources. synchronization, 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. So,
its the mechanism that ensures that only one thread is accessed the resources
at a time.
How to achieve synchronization in java?
In java, synchronization can be achieved by using the synchronized keyword.
It can be used in 2 ways.
1. on a method signature: We
can declare synchronized keyword in method signature, therefore, that
method will be thread safe in multi-threaded environment. That means, only, one
thread at a time can access this method.
Below, method execute() is
synchronized, so it is can be accessed by one thread at a time.
synchronized void execute(){
// do something
}
2. Write synchronized block: Secondly, we can write a synchronized block, and
that block will be synchronized.
synchronized(this){
// do something
}
The above code, will lock the object itself, when this piece
of code has been executed by a thread.
Subscribe to:
Posts
(
Atom
)
Popular Posts
-
public - public means everyone can access it.That means it's in global scope. As, main method is called by JVM [ Java Virtual Machine... -
throw is used to throw an exception in a program, explicitly . Whereas, throws is included in the method's declaration part, wi... -
Singleton in one of the most popular yet controversial design pattern, in the world of object oriented programming. It's one of t... -
Web Container / Servlet Container / Servlet Engine : In J2EE Architecture , a web container (also known as servlet container or ser... -
Program compiles. But at runtime throws an error “NoSuchMethodError”.
-
Vector : It's synchronized. It's slower than ArrayList. It's generally used in ... -
doGet(): protected void doGet(HttpServletRequest req, HttpServletResponse resp)throws ServletException, java.io.IOException – is a met... -
In Java Programming Language , we must declare a variable name and type, before using it. The data type of a variable defines the th...
